@antv/l7-scene 2.25.7 → 2.25.10

package/lib/index.js

@@ -0,0 +1,516 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Scene: () => Scene
+});
+module.exports = __toCommonJS(src_exports);
+var import_l7_component = require("@antv/l7-component");
+var import_l7_core = require("@antv/l7-core");
+var import_l7_layers = require("@antv/l7-layers");
+var import_l7_renderer = require("@antv/l7-renderer");
+var import_l7_utils = require("@antv/l7-utils");
+var import_boxSelect = __toESM(require("./boxSelect"));
+var Scene = class {
+  constructor(config) {
+    const { id, map, renderer = "device" } = config;
+    const sceneContainer = (0, import_l7_core.createSceneContainer)();
+    this.container = sceneContainer;
+    map.setContainer(sceneContainer, id);
+    if (renderer === "regl") {
+      sceneContainer.rendererService = new import_l7_renderer.ReglRendererService();
+    } else {
+      sceneContainer.rendererService = new import_l7_renderer.DeviceRendererService();
+    }
+    this.sceneService = sceneContainer.sceneService;
+    this.mapService = sceneContainer.mapService;
+    this.iconService = sceneContainer.iconService;
+    this.fontService = sceneContainer.fontService;
+    this.controlService = sceneContainer.controlService;
+    this.layerService = sceneContainer.layerService;
+    this.debugService = sceneContainer.debugService;
+    this.debugService.setEnable(config.debug);
+    this.markerService = sceneContainer.markerService;
+    this.interactionService = sceneContainer.interactionService;
+    this.popupService = sceneContainer.popupService;
+    this.boxSelect = new import_boxSelect.default(this, {});
+    this.initComponent(id);
+    this.sceneService.init(config);
+    this.initControl();
+  }
+  get map() {
+    return this.mapService.map;
+  }
+  get loaded() {
+    return this.sceneService.loaded;
+  }
+  getServiceContainer() {
+    return this.container;
+  }
+  getSize() {
+    return this.mapService.getSize();
+  }
+  getMinZoom() {
+    return this.mapService.getMinZoom();
+  }
+  getMaxZoom() {
+    return this.mapService.getMaxZoom();
+  }
+  getType() {
+    return this.mapService.getType();
+  }
+  getMapContainer() {
+    return this.mapService.getMapContainer();
+  }
+  getMapCanvasContainer() {
+    return this.mapService.getMapCanvasContainer();
+  }
+  getMapService() {
+    return this.mapService;
+  }
+  /**
+   * 对外暴露 debugService
+   * @returns
+   */
+  getDebugService() {
+    return this.debugService;
+  }
+  exportPng(type) {
+    return __async(this, null, function* () {
+      return this.sceneService.exportPng(type);
+    });
+  }
+  exportMap(type) {
+    return __async(this, null, function* () {
+      return this.sceneService.exportPng(type);
+    });
+  }
+  registerRenderService(render) {
+    if (this.sceneService.loaded) {
+      const renderSerivce = new render(this);
+      renderSerivce.init();
+    } else {
+      this.on("loaded", () => {
+        const renderSerivce = new render(this);
+        renderSerivce.init();
+      });
+    }
+  }
+  setBgColor(color) {
+    this.mapService.setBgColor(color);
+  }
+  addLayer(layer) {
+    if (this.loaded) {
+      this.preAddLayer(layer);
+    } else {
+      this.once("loaded", () => {
+        this.preAddLayer(layer);
+      });
+    }
+  }
+  // layer 管理
+  preAddLayer(layer) {
+    const layerContainer = (0, import_l7_core.createLayerContainer)(this.container);
+    layer.setContainer(layerContainer);
+    this.sceneService.addLayer(layer);
+    if (layer.inited) {
+      this.initTileLayer(layer);
+      const maskInstance = this.initMask(layer);
+      this.addMask(maskInstance, layer.id);
+    } else {
+      layer.on("inited", () => {
+        this.initTileLayer(layer);
+        const maskInstance = this.initMask(layer);
+        this.addMask(maskInstance, layer.id);
+      });
+    }
+  }
+  // 兼容历史接口
+  initMask(layer) {
+    const { mask, maskfence, maskColor = "#000", maskOpacity = 0 } = layer.getLayerConfig();
+    if (!mask || !maskfence) {
+      return void 0;
+    }
+    const maskInstance = new import_l7_layers.MaskLayer().source(maskfence).shape("fill").style({
+      color: maskColor,
+      opacity: maskOpacity
+    });
+    return maskInstance;
+  }
+  addMask(mask, layerId) {
+    if (!mask) {
+      return;
+    }
+    const parent = this.getLayer(layerId);
+    if (parent) {
+      const layerContainer = (0, import_l7_core.createLayerContainer)(this.container);
+      mask.setContainer(layerContainer);
+      parent.addMaskLayer(mask);
+      this.sceneService.addMask(mask);
+    } else {
+      console.warn("parent layer not find!");
+    }
+  }
+  getPickedLayer() {
+    return this.layerService.pickedLayerId;
+  }
+  getLayers() {
+    return this.layerService.getLayers();
+  }
+  getLayer(id) {
+    return this.layerService.getLayer(id);
+  }
+  getLayerByName(name) {
+    return this.layerService.getLayerByName(name);
+  }
+  removeLayer(layer, parentLayer) {
+    return __async(this, null, function* () {
+      yield this.layerService.remove(layer, parentLayer);
+    });
+  }
+  removeAllLayer() {
+    return __async(this, null, function* () {
+      yield this.layerService.removeAllLayers();
+    });
+  }
+  render() {
+    this.sceneService.render();
+  }
+  setEnableRender(flag) {
+    this.layerService.setEnableRender(flag);
+  }
+  // asset method
+  /**
+   * 为 layer/point/text 支持 iconfont 模式支持
+   * @param fontUnicode
+   * @param name
+   */
+  addIconFont(name, fontUnicode) {
+    this.fontService.addIconFont(name, fontUnicode);
+  }
+  addIconFonts(options) {
+    options.forEach(([name, fontUnicode]) => {
+      this.fontService.addIconFont(name, fontUnicode);
+    });
+  }
+  /**
+   * 用户自定义添加第三方字体
+   * @param fontFamily
+   * @param fontPath
+   */
+  addFontFace(fontFamily, fontPath) {
+    this.fontService.once("fontloaded", (e) => {
+      this.emit("fontloaded", e);
+    });
+    this.fontService.addFontFace(fontFamily, fontPath);
+  }
+  addImage(id, img) {
+    return __async(this, null, function* () {
+      yield this.iconService.addImage(id, img);
+    });
+  }
+  hasImage(id) {
+    return this.iconService.hasImage(id);
+  }
+  removeImage(id) {
+    this.iconService.removeImage(id);
+  }
+  addIconFontGlyphs(fontFamily, glyphs) {
+    this.fontService.addIconGlyphs(glyphs);
+  }
+  // map control method
+  addControl(ctr) {
+    this.controlService.addControl(ctr, this.container);
+  }
+  removeControl(ctr) {
+    this.controlService.removeControl(ctr);
+  }
+  getControlByName(name) {
+    return this.controlService.getControlByName(name);
+  }
+  // marker
+  addMarker(marker) {
+    this.markerService.addMarker(marker);
+  }
+  addMarkerLayer(layer) {
+    this.markerService.addMarkerLayer(layer);
+  }
+  removeMarkerLayer(layer) {
+    this.markerService.removeMarkerLayer(layer);
+  }
+  removeAllMarkers() {
+    this.markerService.removeAllMarkers();
+  }
+  /**
+   * @deprecated 请使用 removeAllMarkers
+   */
+  removeAllMakers() {
+    console.warn("removeAllMakers 已废弃，请使用 removeAllMarkers");
+    this.markerService.removeAllMarkers();
+  }
+  addPopup(popup) {
+    this.popupService.addPopup(popup);
+  }
+  removePopup(popup) {
+    this.popupService.removePopup(popup);
+  }
+  on(type, handle) {
+    var _a;
+    if (import_boxSelect.BoxSelectEventList.includes(type)) {
+      (_a = this.boxSelect) == null ? void 0 : _a.on(type, handle);
+    } else if (import_l7_core.SceneEventList.includes(type)) {
+      this.sceneService.on(type, handle);
+    } else {
+      this.mapService.on(type, handle);
+    }
+  }
+  once(type, handle) {
+    var _a;
+    if (import_boxSelect.BoxSelectEventList.includes(type)) {
+      (_a = this.boxSelect) == null ? void 0 : _a.once(type, handle);
+    } else if (import_l7_core.SceneEventList.includes(type)) {
+      this.sceneService.once(type, handle);
+    } else {
+      this.mapService.once(type, handle);
+    }
+  }
+  emit(type, ...args) {
+    if (import_l7_core.SceneEventList.includes(type)) {
+      this.sceneService.emit(type, ...args);
+    } else {
+      this.mapService.emit(type, ...args);
+    }
+  }
+  off(type, handle) {
+    var _a;
+    if (import_boxSelect.BoxSelectEventList.includes(type)) {
+      (_a = this.boxSelect) == null ? void 0 : _a.off(type, handle);
+    } else if (import_l7_core.SceneEventList.includes(type)) {
+      this.sceneService.off(type, handle);
+    } else {
+      this.mapService.off(type, handle);
+    }
+  }
+  // implements IMapController
+  getZoom() {
+    return this.mapService.getZoom();
+  }
+  getCenter(options) {
+    return this.mapService.getCenter(options);
+  }
+  setCenter(center, options) {
+    return this.mapService.setCenter(center, options);
+  }
+  getPitch() {
+    return this.mapService.getPitch();
+  }
+  setPitch(pitch) {
+    return this.mapService.setPitch(pitch);
+  }
+  getRotation() {
+    return this.mapService.getRotation();
+  }
+  getBounds() {
+    return this.mapService.getBounds();
+  }
+  setRotation(rotation) {
+    this.mapService.setRotation(rotation);
+  }
+  zoomIn() {
+    this.mapService.zoomIn();
+  }
+  zoomOut() {
+    this.mapService.zoomOut();
+  }
+  panTo(p) {
+    this.mapService.panTo(p);
+  }
+  panBy(x, y) {
+    this.mapService.panBy(x, y);
+  }
+  getContainer() {
+    return this.mapService.getContainer();
+  }
+  setZoom(zoom) {
+    this.mapService.setZoom(zoom);
+  }
+  fitBounds(bound, options) {
+    const { fitBoundsOptions, animate } = this.sceneService.getSceneConfig();
+    this.mapService.fitBounds(
+      bound,
+      // 选项优先级：用户传入，覆盖animate直接配置，覆盖Scene配置项传入
+      options || __spreadProps(__spreadValues({}, fitBoundsOptions), {
+        animate
+      })
+    );
+  }
+  setZoomAndCenter(zoom, center) {
+    this.mapService.setZoomAndCenter(zoom, center);
+  }
+  setMapStyle(style) {
+    this.mapService.setMapStyle(style);
+  }
+  setMapStatus(options) {
+    this.mapService.setMapStatus(options);
+  }
+  // conversion Method
+  pixelToLngLat(pixel) {
+    return this.mapService.pixelToLngLat(pixel);
+  }
+  lngLatToPixel(lnglat) {
+    return this.mapService.lngLatToPixel(lnglat);
+  }
+  containerToLngLat(pixel) {
+    return this.mapService.containerToLngLat(pixel);
+  }
+  lngLatToContainer(lnglat) {
+    return this.mapService.lngLatToContainer(lnglat);
+  }
+  destroy() {
+    this.sceneService.destroy();
+  }
+  /**
+   * 注册自定义后处理效果
+   * @param constructor 后处理效果构造函数
+   * @param name 后处理效果名称，便于在 Layer 中引用
+   */
+  registerPostProcessingPass(constructor, name) {
+    const instance = new constructor();
+    instance.setName(name);
+    this.container.postProcessingPass[name] = instance;
+  }
+  // 控制 shader pick 计算
+  enableShaderPick() {
+    this.layerService.enableShaderPick();
+  }
+  disableShaderPick() {
+    this.layerService.disableShaderPick();
+  }
+  /**
+   * @deprecated 请使用 disableShaderPick
+   */
+  diasbleShaderPick() {
+    console.warn("diasbleShaderPick 已废弃，请使用 disableShaderPick");
+    this.layerService.disableShaderPick();
+  }
+  enableBoxSelect(once = true) {
+    this.boxSelect.enable();
+    if (once) {
+      this.boxSelect.once("selectend", () => {
+        this.disableBoxSelect();
+      });
+    }
+  }
+  disableBoxSelect() {
+    this.boxSelect.disable();
+  }
+  // 数据协议
+  static addProtocol(protocol, handler) {
+    import_l7_utils.SceneConifg.REGISTERED_PROTOCOLS[protocol] = handler;
+  }
+  static removeProtocol(protocol) {
+    delete import_l7_utils.SceneConifg.REGISTERED_PROTOCOLS[protocol];
+  }
+  getProtocol(protocol) {
+    return import_l7_utils.SceneConifg.REGISTERED_PROTOCOLS[protocol];
+  }
+  startAnimate() {
+    this.layerService.startAnimate();
+  }
+  stopAnimate() {
+    this.layerService.stopAnimate();
+  }
+  // get current point size info
+  getPointSizeRange() {
+    return this.sceneService.getPointSizeRange();
+  }
+  initComponent(id) {
+    this.controlService.init(
+      {
+        container: import_l7_utils.DOM.getContainer(id)
+      },
+      this.container
+    );
+    this.markerService.init(this.container);
+    this.popupService.init(this.container);
+  }
+  initControl() {
+    const { logoVisible, logoPosition } = this.sceneService.getSceneConfig();
+    if (logoVisible) {
+      this.addControl(new import_l7_component.Logo({ position: logoPosition }));
+    }
+  }
+  initTileLayer(layer) {
+    if (layer.getSource().isTile) {
+      layer.tileLayer = new import_l7_layers.TileLayer(layer);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Scene
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antv/l7-scene",
-  "version": "2.25.7",
+  "version": "2.25.10",
   "description": "",
   "license": "MIT",
   "author": "https://github.com/orgs/antvis/people",
@@ -15,15 +15,15 @@
   "dependencies": {
     "@babel/runtime": "^7.7.7",
     "eventemitter3": "^4.0.7",
-    "@antv/l7-core": "2.25.7",
-    "@antv/l7-maps": "2.25.7",
-    "@antv/l7-renderer": "2.25.7",
-    "@antv/l7-utils": "2.25.7",
-    "@antv/l7-component": "2.25.7",
-    "@antv/l7-layers": "2.25.7"
+    "@antv/l7-component": "2.25.10",
+    "@antv/l7-maps": "2.25.10",
+    "@antv/l7-layers": "2.25.10",
+    "@antv/l7-core": "2.25.10",
+    "@antv/l7-renderer": "2.25.10",
+    "@antv/l7-utils": "2.25.10"
   },
   "devDependencies": {
-    "@antv/l7-test-utils": "^2.25.7"
+    "@antv/l7-test-utils": "^2.25.10"
   },
   "publishConfig": {
     "access": "public",