@antv/l7-scene 2.9.32-alpha.2 → 2.9.32-alpha.4

package/lib/boxSelect.js

@@ -0,0 +1,126 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/boxSelect.ts
+var boxSelect_exports = {};
+__export(boxSelect_exports, {
+  BoxSelectEventList: () => BoxSelectEventList,
+  default: () => BoxSelect
+});
+module.exports = __toCommonJS(boxSelect_exports);
+var import_l7_utils = require("@antv/l7-utils");
+var import_eventemitter3 = require("eventemitter3");
+var import_bbox = __toESM(require("@turf/bbox"));
+var import_helpers = require("@turf/helpers");
+var BoxSelectEventList = ["selectstart", "selecting", "selectend"];
+var BoxSelect = class extends import_eventemitter3.EventEmitter {
+  constructor(scene, options = {}) {
+    super();
+    this.isEnable = false;
+    this.onDragStart = (e) => {
+      this.box.style.display = "block";
+      this.startEvent = this.endEvent = e;
+      this.syncBoxBound();
+      this.emit("selectstart", this.getLngLatBox(), this.startEvent, this.endEvent);
+    };
+    this.onDragging = (e) => {
+      this.endEvent = e;
+      this.syncBoxBound();
+      this.emit("selecting", this.getLngLatBox(), this.startEvent, this.endEvent);
+    };
+    this.onDragEnd = (e) => {
+      this.endEvent = e;
+      this.box.style.display = "none";
+      this.emit("selectend", this.getLngLatBox(), this.startEvent, this.endEvent);
+    };
+    this.scene = scene;
+    this.options = options;
+  }
+  get container() {
+    return this.scene.getMapService().getMarkerContainer();
+  }
+  enable() {
+    if (this.isEnable) {
+      return;
+    }
+    const { className } = this.options;
+    this.scene.setMapStatus({
+      dragEnable: false
+    });
+    this.container.style.cursor = "crosshair";
+    if (!this.box) {
+      const box = import_l7_utils.DOM.create("div", void 0, this.container);
+      box.classList.add("l7-select-box");
+      if (className) {
+        box.classList.add(className);
+      }
+      box.style.display = "none";
+      this.box = box;
+    }
+    this.scene.on("dragstart", this.onDragStart);
+    this.scene.on("dragging", this.onDragging);
+    this.scene.on("dragend", this.onDragEnd);
+    this.isEnable = true;
+  }
+  disable() {
+    if (!this.isEnable) {
+      return;
+    }
+    this.scene.setMapStatus({
+      dragEnable: true
+    });
+    this.container.style.cursor = "auto";
+    this.scene.off("dragstart", this.onDragStart);
+    this.scene.off("dragging", this.onDragging);
+    this.scene.off("dragend", this.onDragEnd);
+    this.isEnable = false;
+  }
+  syncBoxBound() {
+    const { x: x1, y: y1 } = this.startEvent;
+    const { x: x2, y: y2 } = this.endEvent;
+    const left = Math.min(x1, x2);
+    const top = Math.min(y1, y2);
+    const width = Math.abs(x1 - x2);
+    const height = Math.abs(y1 - y2);
+    this.box.style.top = `${top}px`;
+    this.box.style.left = `${left}px`;
+    this.box.style.width = `${width}px`;
+    this.box.style.height = `${height}px`;
+  }
+  getLngLatBox() {
+    const {
+      lngLat: { lng: lng1, lat: lat1 }
+    } = this.startEvent;
+    const {
+      lngLat: { lng: lng2, lat: lat2 }
+    } = this.endEvent;
+    return (0, import_bbox.default)((0, import_helpers.featureCollection)([
+      (0, import_helpers.lineString)([
+        [lng1, lat1],
+        [lng2, lat2]
+      ])
+    ]));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BoxSelectEventList
+});

package/lib/index.js

@@ -0,0 +1,366 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// 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, canvas, hasBaseMap } = config;
+    const sceneContainer = (0, import_l7_core.createSceneContainer)();
+    this.container = sceneContainer;
+    map.setContainer(sceneContainer, id, canvas, hasBaseMap);
+    sceneContainer.bind(import_l7_core.TYPES.IRendererService).to(import_l7_renderer.ReglRendererService).inSingletonScope();
+    this.sceneService = sceneContainer.get(import_l7_core.TYPES.ISceneService);
+    this.mapService = sceneContainer.get(import_l7_core.TYPES.IMapService);
+    this.iconService = sceneContainer.get(import_l7_core.TYPES.IIconService);
+    this.fontService = sceneContainer.get(import_l7_core.TYPES.IFontService);
+    this.controlService = sceneContainer.get(import_l7_core.TYPES.IControlService);
+    this.layerService = sceneContainer.get(import_l7_core.TYPES.ILayerService);
+    this.markerService = sceneContainer.get(import_l7_core.TYPES.IMarkerService);
+    this.interactionService = sceneContainer.get(import_l7_core.TYPES.IInteractionService);
+    this.popupService = sceneContainer.get(import_l7_core.TYPES.IPopupService);
+    this.boxSelect = new import_boxSelect.default(this, {
+      className: config.selectBoxClassName
+    });
+    if (import_l7_utils.isMini) {
+      this.sceneService.initMiniScene(config);
+    } else {
+      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;
+  }
+  exportPng(type) {
+    return this.sceneService.exportPng(type);
+  }
+  exportMap(type) {
+    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) {
+    const layerContainer = (0, import_l7_core.createLayerContainer)(this.container);
+    layer.setContainer(layerContainer, this.container);
+    this.sceneService.addLayer(layer);
+    const layerConfig = layer.getLayerConfig();
+    if (layerConfig) {
+      const {
+        mask,
+        maskfence,
+        maskColor = "#000",
+        maskOpacity = 0
+      } = layerConfig;
+      if (mask && maskfence) {
+        const maskInstance = new import_l7_layers.MaskLayer().source(maskfence).shape("fill").style({
+          color: maskColor,
+          opacity: maskOpacity
+        });
+        this.addMask(maskInstance, layer.id);
+      }
+    } else {
+      console.warn("addLayer should run after scene loaded!");
+    }
+  }
+  addMask(mask, layerId) {
+    const parent = this.getLayer(layerId);
+    if (parent) {
+      const layerContainer = (0, import_l7_core.createLayerContainer)(this.container);
+      mask.setContainer(layerContainer, this.container);
+      parent.addMaskLayer(mask);
+      this.sceneService.addLayer(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) {
+    this.layerService.remove(layer, parentLayer);
+  }
+  removeAllLayer() {
+    this.layerService.removeAllLayers();
+  }
+  render() {
+    this.sceneService.render();
+  }
+  setEnableRender(flag) {
+    this.layerService.setEnableRender(flag);
+  }
+  addIconFont(name, fontUnicode) {
+    this.fontService.addIconFont(name, fontUnicode);
+  }
+  addIconFonts(options) {
+    options.forEach(([name, fontUnicode]) => {
+      this.fontService.addIconFont(name, fontUnicode);
+    });
+  }
+  addFontFace(fontFamily, fontPath) {
+    this.sceneService.addFontFace(fontFamily, fontPath);
+  }
+  addImage(id, img) {
+    if (!import_l7_utils.isMini) {
+      this.iconService.addImage(id, img);
+    } else {
+      this.iconService.addImageMini(id, img, this.sceneService);
+    }
+  }
+  hasImage(id) {
+    return this.iconService.hasImage(id);
+  }
+  removeImage(id) {
+    this.iconService.removeImage(id);
+  }
+  addIconFontGlyphs(fontFamily, glyphs) {
+    this.fontService.addIconGlyphs(glyphs);
+  }
+  addControl(ctr) {
+    this.controlService.addControl(ctr, this.container);
+  }
+  removeControl(ctr) {
+    this.controlService.removeControl(ctr);
+  }
+  getControlByName(name) {
+    return this.controlService.getControlByName(name);
+  }
+  addMarker(marker) {
+    this.markerService.addMarker(marker);
+  }
+  addMarkerLayer(layer) {
+    this.markerService.addMarkerLayer(layer);
+  }
+  removeMarkerLayer(layer) {
+    this.markerService.removeMarkerLayer(layer);
+  }
+  removeAllMakers() {
+    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);
+    }
+  }
+  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);
+    }
+  }
+  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, options || {
+      ...fitBoundsOptions,
+      animate
+    });
+  }
+  setZoomAndCenter(zoom, center) {
+    this.mapService.setZoomAndCenter(zoom, center);
+  }
+  setMapStyle(style) {
+    this.mapService.setMapStyle(style);
+  }
+  setMapStatus(options) {
+    this.mapService.setMapStatus(options);
+  }
+  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();
+  }
+  registerPostProcessingPass(constructor, name) {
+    this.container.bind(import_l7_core.TYPES.IPostProcessingPass).to(constructor).whenTargetNamed(name);
+  }
+  enableShaderPick() {
+    this.layerService.enableShaderPick();
+  }
+  diasbleShaderPick() {
+    this.layerService.disableShaderPick();
+  }
+  enableBoxSelect(once = true) {
+    this.boxSelect.enable();
+    if (once) {
+      this.boxSelect.once("selectend", () => {
+        this.disableBoxSelect();
+      });
+    }
+  }
+  disableBoxSelect() {
+    this.boxSelect.disable();
+  }
+  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 }));
+    }
+  }
+};
+// 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.9.32-alpha.2",
+  "version": "2.9.32-alpha.4",
   "description": "",
   "main": "lib/index.js",
   "module": "es/index.js",
@@ -23,12 +23,12 @@
   "author": "xiaoiver",
   "license": "ISC",
   "dependencies": {
-    "@antv/l7-component": "2.9.32-alpha.2",
-    "@antv/l7-core": "2.9.32-alpha.2",
-    "@antv/l7-layers": "2.9.32-alpha.2",
-    "@antv/l7-maps": "2.9.32-alpha.2",
-    "@antv/l7-renderer": "2.9.32-alpha.2",
-    "@antv/l7-utils": "2.9.32-alpha.2",
+    "@antv/l7-component": "2.9.32-alpha.4",
+    "@antv/l7-core": "2.9.32-alpha.4",
+    "@antv/l7-layers": "2.9.32-alpha.4",
+    "@antv/l7-maps": "2.9.32-alpha.4",
+    "@antv/l7-renderer": "2.9.32-alpha.4",
+    "@antv/l7-utils": "2.9.32-alpha.4",
     "@babel/runtime": "^7.7.7",
     "@turf/turf": "^6.5.0",
     "eventemitter3": "^4.0.7",
@@ -37,9 +37,9 @@
     "reflect-metadata": "^0.1.13"
   },
   "devDependencies": {
-    "@antv/l7-test-utils": "2.9.32-alpha.2"
+    "@antv/l7-test-utils": "2.9.32-alpha.4"
   },
-  "gitHead": "16555be9682edaeeabec85082fc8c9e49fefabc0",
+  "gitHead": "17a8a05d41a0007db94568d2902a8f539d6e3abc",
   "publishConfig": {
     "access": "public"
   }