ShangHaiYuan-AnXin/src/modules/map/declare/gaode-map.ts

import { ICircle, ILayer, ILngLat, IMap, IMapOptions, IMarker, IMarkerCluster, IMarkOptions, IPixel, IRenderClusterMarker, ISelf } from './map'
import MapTools from './map-tools';
declare var AMap: any;

class GaodeBasic implements ISelf{
    self: any;
    discriminator: string="ISelf";
}

export class GaoDeMap extends GaodeBasic implements IMap {
    constructor(container: string, options: IMapOptions) {
        super();
        this.self = new AMap.Map(container, options);
    }
    getCity(callback: Function) {
        return this.self.getCity(callback)
    }
    setZoomAndCenter(zoom: number, pos: number[]) {
       return this.self.setZoomAndCenter(zoom,pos)
    }
    plugin(eventName: string[], callback: Function) {
        return this.self.plugin(eventName,callback)
    }
    getBounds() {
        return this.self.getBounds()
    }
    add(obj: IMarker) {
        return this.self.add(obj.self)
    }
    remove(obj: any) {
        return this.self.remove(obj)
    }
    setCity(city: string) {
        return this.self.setCity(city)
    }
    setZoom(zoom) {
        return this.self.setZoom(zoom)
    }
    setCenter([x, y]) {
        return this.self.setCenter([x, y])
    }
    getCenter() {
        return this.self.getCenter();
    }
    getZoom() {
        return this.self.getZoom();
    }
    on(eventName: string, callback: Function): void {
        this.self.on(eventName, callback);
    }
}

export class GaoDePixel extends GaodeBasic  implements IPixel {
    constructor(x: number, y: number) {
        super();
        this.self = new AMap.Pixel(x, y);
    }
}

export class GaoDeMarker extends GaodeBasic  implements IMarker {
    constructor(options: IMarkOptions) {
        super();
        let conf = MapTools.InstanceConvert(options);
        this.self = new AMap.Marker(conf);
    }
    setMap() {
        this.self.setMap(null)
    }
    get id(): string {
        return this.self.id;
    }
    set id(str: string) {
        this.self.id = str;
    }
    on(eventName: string, callback: Function): void {
        this.self.on(eventName, callback);
    }
}

export class GaoDeMarkerCluster extends GaodeBasic  implements IMarkerCluster {
    constructor(map:IMap,list:Object[],options:any) {
        super();
        options.renderClusterMarker.
        this.self = new AMap.MarkerCluster(map.self,list,options)
    }
}

export class GaoDeLngLat extends GaodeBasic  implements ILngLat {
    constructor(x: number, y: number) {
        super();
        this.self = new AMap.LngLat(x, y);
    }
    offset(x: number, y: number) {
        return this.self.offset(x,y)
    }
}

export class GaodeLayer extends GaodeBasic  implements ILayer{
    constructor(options: any) {
        super();
        this.self = new AMap.createDefaultLayer(options);
    }
}

export class GaodeCircle extends GaodeBasic implements ICircle{
    constructor(options: any) {
        super();
        this.self = new AMap.Circle(options);
    }
    setMap(map: any) {
        return this.self.setMap(map)
    }
    setCenter(pos: number[]) {
        return this.self.setCenter(pos)
    }
    setRadius(num:number) {
        return this.self.setRadius(num)
    }
}

export class GaoDeRenderClusterMarker implements IRenderClusterMarker{
    setContent(dom: string | HTMLDivElement) {
        throw new Error('Method not implemented.');
    }
    setOffset(IPixel: any) {
        throw new Error('Method not implemented.');
    }
    getFirstImage(context: any): string {
        return context.data[0].image;
    }
    getCount(context: any): number {
        return context.count;
    }
    
    // renderMarker(context: any, content: string, pixel: IPixel): void {
    //     context.marker.setContent(content);
    //     context.marker.setOffset(pixel);
    // }

    test = (a)=>{
        return (b)=>{a+b}
    };
    
}