@ohuoy/easymap 1.0.0 → 1.0.1

package/lib/@antv/l7-core/lib/services/layer/StyleAttributeService.d.ts

@@ -0,0 +1,43 @@
+import type { IAttribute } from '../renderer/IAttribute';
+import type { IElements } from '../renderer/IElements';
+import type { IRendererService } from '../renderer/IRendererService';
+import type { ILayer } from './ILayerService';
+import type { IEncodeFeature, IScaleOptions, IStyleAttribute, IStyleAttributeInitializationOptions, IStyleAttributeService, IStyleAttributeUpdateOptions, Triangulation } from './IStyleAttributeService';
+/**
+ * 每个 Layer 都拥有一个，用于管理样式属性的注册和更新
+ */
+export default class StyleAttributeService implements IStyleAttributeService {
+    private readonly rendererService;
+    constructor(rendererService: IRendererService);
+    attributesAndIndices: {
+        attributes: {
+            [attributeName: string]: IAttribute;
+        };
+        elements: IElements;
+        count: number | null;
+    };
+    private attributes;
+    private triangulation;
+    private featureLayout;
+    registerStyleAttribute(options: Partial<IStyleAttributeInitializationOptions>): IStyleAttribute;
+    unRegisterStyleAttribute(name: string): void;
+    updateScaleAttribute(scaleOption: IScaleOptions): void;
+    updateStyleAttribute(attributeName: string, options: Partial<IStyleAttributeInitializationOptions>, updateOptions?: Partial<IStyleAttributeUpdateOptions>): void;
+    getLayerStyleAttributes(): IStyleAttribute[] | undefined;
+    getLayerStyleAttribute(attributeName: string): IStyleAttribute | undefined;
+    getLayerAttributeScale(name: string): unknown;
+    updateAttributeByFeatureRange(attributeName: string, features: IEncodeFeature[], startFeatureIdx?: number, endFeatureIdx?: number, layer?: ILayer): void;
+    createAttributesAndIndices(features: IEncodeFeature[], triangulation: Triangulation, styleOption: unknown, layer?: ILayer): {
+        attributes: {
+            [attributeName: string]: IAttribute;
+        };
+        elements: IElements;
+        count: number | null;
+    };
+    createAttributes(features: IEncodeFeature[], triangulation: Triangulation): {
+        attributes: {
+            [attributeName: string]: IAttribute;
+        };
+    };
+    clearAllAttributes(): void;
+}

package/lib/@antv/l7-core/lib/services/layer/StyleAttributeService.js

@@ -0,0 +1,367 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _gl = require("../renderer/gl");
+var _StyleAttribute = _interopRequireDefault(require("./StyleAttribute"));
+const _excluded = ["buffer", "update", "name"],
+  _excluded2 = ["buffer", "update", "name"];
+const bytesPerElementMap = {
+  [_gl.gl.FLOAT]: 4,
+  [_gl.gl.UNSIGNED_BYTE]: 1,
+  [_gl.gl.UNSIGNED_SHORT]: 2
+};
+
+/**
+ * 每个 Layer 都拥有一个，用于管理样式属性的注册和更新
+ */
+class StyleAttributeService {
+  constructor(rendererService) {
+    (0, _defineProperty2.default)(this, "attributesAndIndices", void 0);
+    (0, _defineProperty2.default)(this, "attributes", []);
+    (0, _defineProperty2.default)(this, "triangulation", void 0);
+    (0, _defineProperty2.default)(this, "featureLayout", {
+      sizePerElement: 0,
+      elements: []
+    });
+    this.rendererService = rendererService;
+  }
+  registerStyleAttribute(options) {
+    let attributeToUpdate = this.getLayerStyleAttribute(options.name || '');
+    if (attributeToUpdate) {
+      attributeToUpdate.setProps(options);
+    } else {
+      attributeToUpdate = new _StyleAttribute.default(options);
+      this.attributes.push(attributeToUpdate);
+    }
+    return attributeToUpdate;
+  }
+  unRegisterStyleAttribute(name) {
+    const attributeIndex = this.attributes.findIndex(attribute => attribute.name === name);
+    if (attributeIndex > -1) {
+      this.attributes.splice(attributeIndex, 1);
+    }
+  }
+  updateScaleAttribute(scaleOption) {
+    this.attributes.forEach(attr => {
+      var _attr$scale;
+      const name = attr.name;
+      const field = (_attr$scale = attr.scale) === null || _attr$scale === void 0 ? void 0 : _attr$scale.field;
+      if (scaleOption[name] || field && scaleOption[field]) {
+        // 字段类型和映射类型
+        attr.needRescale = true;
+        attr.needRemapping = true;
+        attr.needRegenerateVertices = true;
+      }
+    });
+  }
+  updateStyleAttribute(attributeName, options, updateOptions) {
+    let attributeToUpdate = this.getLayerStyleAttribute(attributeName);
+    if (!attributeToUpdate) {
+      attributeToUpdate = this.registerStyleAttribute((0, _objectSpread2.default)((0, _objectSpread2.default)({}, options), {}, {
+        name: attributeName
+      }));
+    }
+    const {
+      scale
+    } = options;
+    if (scale && attributeToUpdate) {
+      // TODO: 需要比较新旧值确定是否需要 rescale
+      // 需要重新 scale，肯定也需要重新进行数据映射
+      attributeToUpdate.scale = scale;
+      attributeToUpdate.needRescale = true;
+      attributeToUpdate.needRemapping = true;
+      attributeToUpdate.needRegenerateVertices = true;
+      if (updateOptions && updateOptions.featureRange) {
+        attributeToUpdate.featureRange = updateOptions.featureRange;
+      }
+    }
+  }
+  getLayerStyleAttributes() {
+    return this.attributes;
+  }
+  getLayerStyleAttribute(attributeName) {
+    return this.attributes.find(attribute => attribute.name === attributeName);
+  }
+  getLayerAttributeScale(name) {
+    var _attribute$scale;
+    const attribute = this.getLayerStyleAttribute(name);
+    const scale = attribute === null || attribute === void 0 || (_attribute$scale = attribute.scale) === null || _attribute$scale === void 0 ? void 0 : _attribute$scale.scalers;
+    if (scale && scale[0]) {
+      return scale[0].func;
+    }
+    return null;
+  }
+  updateAttributeByFeatureRange(attributeName, features, startFeatureIdx = 0, endFeatureIdx, layer) {
+    const attributeToUpdate = this.attributes.find(attribute => attribute.name === attributeName);
+    if (attributeToUpdate && attributeToUpdate.descriptor) {
+      const {
+        descriptor
+      } = attributeToUpdate;
+      const {
+        update,
+        buffer,
+        size = 0
+      } = descriptor;
+      const bytesPerElement = bytesPerElementMap[buffer.type || _gl.gl.FLOAT];
+      if (update) {
+        const {
+          elements,
+          sizePerElement
+        } = this.featureLayout;
+        // 截取待更新的 feature 范围
+        const featuresToUpdate = elements.slice(startFeatureIdx, endFeatureIdx);
+        // [n, n] 中断更新
+        if (!featuresToUpdate.length) {
+          return;
+        }
+        const {
+          offset
+        } = featuresToUpdate[0];
+        // 以 byte 为单位计算 buffer 中的偏移
+        const bufferOffsetInBytes = offset * size * bytesPerElement;
+        const updatedBufferData = featuresToUpdate.map(({
+          featureIdx,
+          vertices,
+          normals
+        }, attributeIdx) => {
+          const verticesNumForCurrentFeature = vertices.length / sizePerElement;
+          const featureData = [];
+          for (let vertexIdx = 0; vertexIdx < verticesNumForCurrentFeature; vertexIdx++) {
+            const normal = normals ?
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            normals.slice(vertexIdx * 3, vertexIdx * 3 + 3) : [];
+            featureData.push(...update(features[featureIdx], featureIdx, vertices.slice(vertexIdx * sizePerElement, vertexIdx * sizePerElement + sizePerElement), attributeIdx, normal));
+          }
+          return featureData;
+        }).flat();
+
+        // 更新底层 IAttribute 中包含的 IBuffer，使用 subdata
+        attributeToUpdate.vertexAttribute.updateBuffer({
+          data: updatedBufferData,
+          offset: bufferOffsetInBytes
+        });
+        // size color 触发更新事件
+        layer === null || layer === void 0 || layer.emit(`legend:${attributeName}`, layer.getLegend(attributeName));
+      }
+    }
+  }
+  createAttributesAndIndices(features, triangulation, styleOption, layer) {
+    // 每次创建的初始化化 LayerOut
+    this.featureLayout = {
+      sizePerElement: 0,
+      elements: []
+    };
+    if (triangulation) {
+      this.triangulation = triangulation;
+    }
+    const descriptors = this.attributes.map(attr => {
+      attr.resetDescriptor();
+      return attr.descriptor;
+    });
+    let verticesNum = 0;
+    let vecticesCount = 0; // 在不使用 element 的时候记录顶点、图层所有顶点的总数
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const indices = [];
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    let size = 3;
+    features.forEach((feature, featureIdx) => {
+      // 逐 feature 进行三角化
+      const {
+        indices: indicesForCurrentFeature,
+        vertices: verticesForCurrentFeature,
+        normals: normalsForCurrentFeature,
+        size: vertexSize,
+        indexes,
+        count
+      } = this.triangulation(feature, styleOption);
+      if (typeof count === 'number') {
+        // 顶点数
+        vecticesCount += count;
+      }
+      indicesForCurrentFeature.forEach(i => {
+        indices.push(i + verticesNum);
+      });
+      size = vertexSize;
+      const verticesNumForCurrentFeature = verticesForCurrentFeature.length / vertexSize;
+
+      // 记录三角化结果，用于后续精确更新指定 feature
+      this.featureLayout.sizePerElement = size;
+      this.featureLayout.elements.push({
+        featureIdx,
+        vertices: verticesForCurrentFeature,
+        normals: normalsForCurrentFeature,
+        offset: verticesNum
+      });
+      verticesNum += verticesNumForCurrentFeature;
+      // 根据 position 顶点生成其他顶点数据 // color/size/ui
+      for (let vertexIdx = 0; vertexIdx < verticesNumForCurrentFeature; vertexIdx++) {
+        const normal = (normalsForCurrentFeature === null || normalsForCurrentFeature === void 0 ? void 0 : normalsForCurrentFeature.slice(vertexIdx * 3, vertexIdx * 3 + 3)) || [];
+        const vertice = verticesForCurrentFeature.slice(vertexIdx * vertexSize, vertexIdx * vertexSize + vertexSize);
+        let vertexIndex = 0;
+        if (indexes && indexes[vertexIdx] !== undefined) {
+          vertexIndex = indexes[vertexIdx];
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        descriptors.forEach((descriptor, attributeIdx) => {
+          if (descriptor && descriptor.update) {
+            descriptor.buffer.data.push(...descriptor.update(feature, featureIdx, vertice, vertexIdx,
+            // 当前顶点所在feature索引
+            normal, vertexIndex
+            // 传入顶点索引 vertexIdx
+            ));
+          } // end if
+        }); // end for each
+      } // end for
+    }); // end features for Each
+    const {
+      createAttribute,
+      createBuffer,
+      createElements
+    } = this.rendererService;
+    const attributes = {};
+    descriptors.forEach((descriptor, attributeIdx) => {
+      if (descriptor) {
+        // IAttribute 参数透传
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const {
+            buffer,
+            update,
+            name
+          } = descriptor,
+          rest = (0, _objectWithoutProperties2.default)(descriptor, _excluded);
+        const vertexAttribute = createAttribute((0, _objectSpread2.default)({
+          // IBuffer 参数透传
+          buffer: createBuffer(buffer)
+        }, rest));
+        attributes[descriptor.name || ''] = vertexAttribute;
+
+        // 在 StyleAttribute 上保存对 VertexAttribute 的引用
+        this.attributes[attributeIdx].vertexAttribute = vertexAttribute;
+      }
+    });
+    const elements = createElements({
+      data: indices,
+      type: _gl.gl.UNSIGNED_INT,
+      count: indices.length
+    });
+    this.attributesAndIndices = {
+      attributes,
+      elements,
+      count: vecticesCount
+    };
+    Object.values(this.attributes).filter(attribute => attribute.scale).forEach(attribute => {
+      const attributeName = attribute.name;
+      // size color 触发更新事件
+      layer === null || layer === void 0 || layer.emit(`legend:${attributeName}`, layer.getLegend(attributeName));
+    });
+    return this.attributesAndIndices;
+  }
+  createAttributes(features, triangulation) {
+    // 每次创建的初始化化 LayerOut
+    this.featureLayout = {
+      sizePerElement: 0,
+      elements: []
+    };
+    if (triangulation) {
+      this.triangulation = triangulation;
+    }
+    const descriptors = this.attributes.map(attr => {
+      attr.resetDescriptor();
+      return attr.descriptor;
+    });
+    let verticesNum = 0;
+    const indices = [];
+    let size = 3;
+    features.forEach((feature, featureIdx) => {
+      // 逐 feature 进行三角化
+      const {
+        indices: indicesForCurrentFeature,
+        vertices: verticesForCurrentFeature,
+        normals: normalsForCurrentFeature,
+        size: vertexSize,
+        indexes
+      } = this.triangulation(feature);
+      indicesForCurrentFeature.forEach(i => {
+        indices.push(i + verticesNum);
+      });
+      size = vertexSize;
+      const verticesNumForCurrentFeature = verticesForCurrentFeature.length / vertexSize;
+
+      // 记录三角化结果，用于后续精确更新指定 feature
+      this.featureLayout.sizePerElement = size;
+      this.featureLayout.elements.push({
+        featureIdx,
+        vertices: verticesForCurrentFeature,
+        normals: normalsForCurrentFeature,
+        offset: verticesNum
+      });
+      verticesNum += verticesNumForCurrentFeature;
+      // 根据 position 顶点生成其他顶点数据
+      for (let vertexIdx = 0; vertexIdx < verticesNumForCurrentFeature; vertexIdx++) {
+        const normal = (normalsForCurrentFeature === null || normalsForCurrentFeature === void 0 ? void 0 : normalsForCurrentFeature.slice(vertexIdx * 3, vertexIdx * 3 + 3)) || [];
+        const vertice = verticesForCurrentFeature.slice(vertexIdx * vertexSize, vertexIdx * vertexSize + vertexSize);
+        let vertexIndex = 0;
+        if (indexes && indexes[vertexIdx] !== undefined) {
+          vertexIndex = indexes[vertexIdx];
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        descriptors.forEach((descriptor, attributeIdx) => {
+          if (descriptor && descriptor.update) {
+            descriptor.buffer.data.push(...descriptor.update(feature, featureIdx, vertice, vertexIdx,
+            // 当前顶点所在feature索引
+            normal, vertexIndex
+            // 传入顶点索引 vertexIdx
+            ));
+          } // end if
+        }); // end for each
+      } // end for
+    }); // end features for Each
+    const {
+      createAttribute,
+      createBuffer
+    } = this.rendererService;
+    const attributes = {};
+    descriptors.forEach((descriptor, attributeIdx) => {
+      if (descriptor) {
+        // IAttribute 参数透传
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const {
+            buffer,
+            update,
+            name
+          } = descriptor,
+          rest = (0, _objectWithoutProperties2.default)(descriptor, _excluded2);
+        const vertexAttribute = createAttribute((0, _objectSpread2.default)({
+          // IBuffer 参数透传
+          buffer: createBuffer(buffer)
+        }, rest));
+        attributes[descriptor.name || ''] = vertexAttribute;
+
+        // 在 StyleAttribute 上保存对 VertexAttribute 的引用
+        this.attributes[attributeIdx].vertexAttribute = vertexAttribute;
+      }
+    });
+    return {
+      attributes
+    };
+  }
+  clearAllAttributes() {
+    var _this$attributesAndIn;
+    // 销毁关联的 vertex attribute buffer objects
+    this.attributes.forEach(attribute => {
+      if (attribute.vertexAttribute) {
+        attribute.vertexAttribute.destroy();
+      }
+    });
+    (_this$attributesAndIn = this.attributesAndIndices) === null || _this$attributesAndIn === void 0 || _this$attributesAndIn.elements.destroy();
+    this.attributes = [];
+  }
+}
+exports.default = StyleAttributeService;

package/lib/@antv/l7-core/lib/services/map/IMapService.d.ts

@@ -0,0 +1,241 @@
+import type { L7Container } from '../../inversify.config';
+import type { IViewport } from '../camera/ICameraService';
+export type Point = [number, number];
+export type Bounds = [[number, number], [number, number]];
+export interface ILngLat {
+    lng: number;
+    lat: number;
+}
+export interface IPoint {
+    x: number;
+    y: number;
+}
+export interface IMercator {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface IStatusOptions {
+    showIndoorMap: boolean;
+    resizeEnable: boolean;
+    dragEnable: boolean;
+    keyboardEnable: boolean;
+    doubleClickZoom: boolean;
+    zoomEnable: boolean;
+    rotateEnable: boolean;
+}
+export type MapStyleName = 'normal' | 'light' | 'dark' | string;
+export type MapStyleConfig = {
+    [key: MapStyleName]: string | any;
+};
+export type MapStyle = MapStyleName | any;
+export interface IMapWrapper {
+    setContainer(container: L7Container, id: string | HTMLDivElement, canvas?: HTMLCanvasElement): void;
+}
+interface ISimpleMapCoord {
+    setSize(size: number): void;
+    getSize(): [number, number];
+    project(lnglat: [number, number]): [number, number];
+    unproject(xy: [number, number]): [number, number];
+}
+export interface IMapService<RawMap = {}> {
+    version?: string;
+    simpleMapCoord: ISimpleMapCoord;
+    map: RawMap;
+    bgColor: string;
+    setCoordCenter?(center: number[]): void;
+    setBgColor(color: string): void;
+    init(): void;
+    initMiniMap?(): void;
+    destroy(): void;
+    onCameraChanged(callback: (viewport: IViewport) => void): void;
+    addMarkerContainer(): void;
+    getMarkerContainer(): HTMLElement;
+    getOverlayContainer(): HTMLElement | undefined;
+    on(type: string, handler: (...args: any[]) => void): void;
+    off(type: string, handler: (...args: any[]) => void): void;
+    once(type: string, handler: (...args: any[]) => void): void;
+    getContainer(): HTMLElement | null;
+    getSize(): [number, number];
+    getMinZoom(): number;
+    getMaxZoom(): number;
+    getType(): string;
+    getZoom(): number;
+    getCenter(option?: ICameraOptions): ILngLat;
+    getPitch(): number;
+    getRotation(): number;
+    getBounds(): Bounds;
+    getMapContainer(): HTMLElement | null;
+    getMapCanvasContainer(): HTMLElement;
+    getMapStyleConfig(): MapStyleConfig;
+    getMapStyleValue(name: MapStyleName): string | any;
+    getMapStyle(): MapStyleName | any;
+    getCanvasOverlays(): HTMLElement | undefined | null;
+    setMapStyle(style: MapStyleName | any): void;
+    setRotation(rotation: number): void;
+    zoomIn(option?: any, eventData?: any): void;
+    zoomOut(option?: any, eventData?: any): void;
+    panTo(p: Point): void;
+    panBy(x: number, y: number): void;
+    fitBounds(bound: Bounds, fitBoundsOptions?: unknown): void;
+    setZoomAndCenter(zoom: number, center: Point): void;
+    setCenter(center: [number, number], option?: ICameraOptions): void;
+    setPitch(pitch: number): void;
+    setZoom(zoom: number): void;
+    setMapStatus(option: Partial<IStatusOptions>): void;
+    updateView(viewOption: Partial<IMapCamera>): void;
+    meterToCoord(center: number[], lnglat: number[]): number;
+    pixelToLngLat(pixel: Point): ILngLat;
+    lngLatToPixel(lnglat: Point): IPoint;
+    containerToLngLat(pixel: Point): ILngLat;
+    lngLatToContainer(lnglat: Point): IPoint;
+    lngLatToMercator(lnglat: [number, number], altitude: number): IMercator;
+    getModelMatrix(lnglat: [number, number], altitude: number, rotate: [number, number, number], scale: [number, number, number], origin: IMercator): number[];
+    lngLatToCoord?(lnglat: [number, number]): [number, number];
+    lngLatToCoords?(lnglatArray: number[][][] | number[][]): number[][][] | number[][] | number[][][] | number[][];
+    getCustomCoordCenter?(): [number, number];
+    exportMap(type: 'jpg' | 'png'): string;
+    rotateY?(option: {
+        force?: boolean;
+        reg?: number;
+    } | undefined): void;
+}
+export interface IEarthService<RawMap = {}> {
+    version?: string;
+    map: RawMap;
+    bgColor: string;
+    setBgColor(color: string): void;
+    init(): void;
+    destroy(): void;
+    onCameraChanged(callback: (viewport: IViewport) => void): void;
+    addMarkerContainer(): void;
+    getMarkerContainer(): HTMLElement;
+    on(type: string, handler: (...args: any[]) => void): void;
+    off(type: string, handler: (...args: any[]) => void): void;
+    once(type: string, handler: (...args: any[]) => void): void;
+    getContainer(): HTMLElement | null;
+    getSize(): [number, number];
+    getMinZoom(): number;
+    getMaxZoom(): number;
+    getType(): string;
+    getZoom(): number;
+    getCenter(option?: ICameraOptions): ILngLat;
+    getPitch(): number;
+    getRotation(): number;
+    getBounds(): Bounds;
+    getMapContainer(): HTMLElement | null;
+    getMapCanvasContainer(): HTMLElement;
+    getMapStyleConfig(): MapStyleConfig;
+    setRotation(rotation: number): void;
+    zoomIn(option?: any, eventData?: any): void;
+    zoomOut(option?: any, eventData?: any): void;
+    panTo(p: Point): void;
+    panBy(x: number, y: number): void;
+    fitBounds(bound: Bounds, fitBoundsOptions?: unknown): void;
+    setZoomAndCenter(zoom: number, center: Point): void;
+    setCenter(center: [number, number], option?: ICameraOptions): void;
+    setPitch(pitch: number): void;
+    setZoom(zoom: number): void;
+    setMapStyle(style: any): void;
+    setMapStatus(option: Partial<IStatusOptions>): void;
+    meterToCoord(center: number[], lnglat: number[]): number;
+    pixelToLngLat(pixel: Point): ILngLat;
+    lngLatToPixel(lnglat: Point): IPoint;
+    containerToLngLat(pixel: Point): ILngLat;
+    lngLatToContainer(lnglat: Point): IPoint;
+    lngLatToMercator(lnglat: [number, number], altitude: number): IMercator;
+    getModelMatrix(lnglat: [number, number], altitude: number, rotate: [number, number, number], scale: [number, number, number], origin: IMercator): number[];
+    lngLatToCoord?(lnglat: [number, number]): [number, number];
+    lngLatToCoords?(lnglatArray: number[][][] | number[][]): number[][][] | number[][] | number[][][] | number[][];
+    getCustomCoordCenter?(): [number, number];
+    exportMap(type: 'jpg' | 'png'): string;
+    rotateY?(option: {
+        force?: boolean;
+        reg?: number;
+    } | undefined): void;
+}
+export declare const MapServiceEvent: string[];
+/**
+ * 地图初始化配置项
+ */
+export interface IMapConfig<RawMap = {}> {
+    /**
+     * 地图实例
+     */
+    mapInstance?: RawMap;
+    /**
+     * 高德地图API插件
+     */
+    plugin?: string[];
+    /**
+     * 容器 DOM id
+     */
+    id: string | HTMLDivElement;
+    /**
+     * 地图
+     */
+    token?: string;
+    /**
+     * 中心点
+     */
+    center?: [number, number];
+    /**
+     * 地图倾角
+     */
+    pitch?: number;
+    /**
+     * 地图旋转角度
+     */
+    rotation?: number;
+    /**
+     * 缩放等级
+     */
+    zoom?: number;
+    /**
+     * 底图样式
+     */
+    style?: MapStyle;
+    /**
+     * 最小缩放等级
+     */
+    minZoom?: number;
+    /**
+     * 最大缩放等级
+     */
+    maxZoom?: number;
+    attributionControl?: boolean;
+    offsetCoordinate?: boolean;
+    offsetZoom?: number;
+    interactive: boolean;
+    [key: string]: any;
+}
+/**
+ * 地图相机参数
+ * @see
+ */
+export interface IMapCamera {
+    aspect: number;
+    fov: number;
+    near: number;
+    far: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    pitch: number;
+    bearing: number;
+    zoom: number;
+    center: [number, number];
+    cameraHeight: number;
+    cameraPosition?: [number, number, number];
+    up?: [number, number, number];
+    lookAt?: [number, number, number];
+    offsetOrigin: [number, number];
+}
+export interface ICameraOptions {
+    padding: number | [number, number, number, number] | {
+        top?: number;
+        bottom?: number;
+        right?: number;
+        left?: number;
+    };
+}
+export {};

package/lib/@antv/l7-core/lib/services/map/IMapService.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MapServiceEvent = void 0;
+const MapServiceEvent = exports.MapServiceEvent = ['mapload', 'mapchange', 'mapAfterFrameChange'];
+
+/**
+ * 地图初始化配置项
+ */
+
+/**
+ * 地图相机参数
+ * @see
+ */

package/lib/@antv/l7-core/lib/services/renderer/IAttribute.d.ts

@@ -0,0 +1,32 @@
+import type { IBuffer } from './IBuffer';
+export interface IAttributeInitializationOptions {
+    buffer: IBuffer;
+    /**
+     * layout(location = x)
+     */
+    shaderLocation?: number;
+    /**
+     * vertexAttribPointer 单位为 byte，默认值均为 0
+     */
+    offset?: number;
+    stride?: number;
+    /**
+     * 每个顶点数据块大小，取值范围为 [1..4]
+     */
+    size?: number;
+    /**
+     * 是否需要归一化 [-1,1] 或者 [0,1]，默认值 false
+     */
+    normalized?: boolean;
+    /**
+     * gl.vertexAttribDivisorANGLE，自动开启 ANGLE_instanced_arrays 扩展
+     */
+    divisor?: number;
+}
+export interface IAttribute {
+    updateBuffer(options: {
+        data: number[] | number[][] | Uint8Array | Uint16Array | Uint32Array;
+        offset: number;
+    }): void;
+    destroy(): void;
+}