@antv/l7-layers 2.9.24 → 2.9.26-alpha.0

package/lib/core/BaseLayer.js

@@ -1,891 +0,0 @@
-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);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
-  return result;
-};
-
-// src/core/BaseLayer.ts
-var BaseLayer_exports = {};
-__export(BaseLayer_exports, {
-  default: () => BaseLayer
-});
-module.exports = __toCommonJS(BaseLayer_exports);
-var import_async_hook = require("@antv/async-hook");
-var import_l7_core = require("@antv/l7-core");
-var import_l7_source = __toESM(require("@antv/l7-source"));
-var import_l7_utils = require("@antv/l7-utils");
-var import_eventemitter3 = require("eventemitter3");
-var import_lodash = require("lodash");
-var import_blend = require("../utils/blend");
-var import_dataMappingStyle = require("../utils/dataMappingStyle");
-var import_layerData = require("../utils/layerData");
-var import_multiPassRender = require("../utils/multiPassRender");
-var import_updateShape = require("../utils/updateShape");
-var layerIdCounter = 0;
-var BaseLayer = class extends import_eventemitter3.EventEmitter {
-  constructor(config = {}) {
-    super();
-    this.id = `${layerIdCounter++}`;
-    this.name = `${layerIdCounter}`;
-    this.visible = true;
-    this.zIndex = 0;
-    this.inited = false;
-    this.layerModelNeedUpdate = false;
-    this.pickedFeatureID = null;
-    this.selectedFeatureID = null;
-    this.styleNeedUpdate = false;
-    this.clusterZoom = 0;
-    this.dataState = {
-      dataSourceNeedUpdate: false,
-      dataMappingNeedUpdate: false,
-      filterNeedUpdate: false,
-      featureScaleNeedUpdate: false,
-      StyleAttrNeedUpdate: false
-    };
-    this.hooks = {
-      init: new import_async_hook.SyncBailHook(),
-      afterInit: new import_async_hook.SyncBailHook(),
-      beforeRender: new import_async_hook.SyncBailHook(),
-      beforeRenderData: new import_async_hook.SyncWaterfallHook(),
-      afterRender: new import_async_hook.SyncHook(),
-      beforePickingEncode: new import_async_hook.SyncHook(),
-      afterPickingEncode: new import_async_hook.SyncHook(),
-      beforeHighlight: new import_async_hook.SyncHook(["pickedColor"]),
-      afterHighlight: new import_async_hook.SyncHook(),
-      beforeSelect: new import_async_hook.SyncHook(["pickedColor"]),
-      afterSelect: new import_async_hook.SyncHook(),
-      beforeDestroy: new import_async_hook.SyncHook(),
-      afterDestroy: new import_async_hook.SyncHook()
-    };
-    this.models = [];
-    this.layerChildren = [];
-    this.masks = [];
-    this.isVector = false;
-    this.animateOptions = { enable: false };
-    this.currentPickId = null;
-    this.pendingStyleAttributes = [];
-    this.scaleOptions = {};
-    this.aniamateStatus = false;
-    this.bottomColor = "rgba(0, 0, 0, 0)";
-    this.isDestroied = false;
-    this.sourceEvent = () => {
-      this.dataState.dataSourceNeedUpdate = true;
-      const layerConfig = this.getLayerConfig();
-      if (layerConfig && layerConfig.autoFit) {
-        this.fitBounds(layerConfig.fitBoundsOptions);
-      }
-      this.reRender();
-    };
-    this.name = config.name || this.id;
-    this.zIndex = config.zIndex || 0;
-    this.rawConfig = config;
-  }
-  addMaskLayer(maskLayer) {
-    this.masks.push(maskLayer);
-  }
-  removeMaskLayer(maskLayer) {
-    const layerIndex = this.masks.indexOf(maskLayer);
-    if (layerIndex > -1) {
-      this.masks.splice(layerIndex, 1);
-    }
-    maskLayer.destroy();
-  }
-  getAttribute(name) {
-    return this.styleAttributeService.getLayerStyleAttribute(name);
-  }
-  getLayerConfig() {
-    return this.configService.getLayerConfig(this.id);
-  }
-  updateLayerConfig(configToUpdate) {
-    Object.keys(configToUpdate).map((key) => {
-      if (key in this.rawConfig) {
-        this.rawConfig[key] = configToUpdate[key];
-      }
-    });
-    if (!this.inited) {
-      this.needUpdateConfig = {
-        ...this.needUpdateConfig,
-        ...configToUpdate
-      };
-    } else {
-      const sceneId = this.container.get(import_l7_core.TYPES.SceneID);
-      (0, import_dataMappingStyle.handleStyleDataMapping)(configToUpdate, this);
-      this.configService.setLayerConfig(sceneId, this.id, {
-        ...this.configService.getLayerConfig(this.id),
-        ...this.needUpdateConfig,
-        ...configToUpdate
-      });
-      this.needUpdateConfig = {};
-    }
-  }
-  setContainer(container, sceneContainer) {
-    this.container = container;
-    this.sceneContainer = sceneContainer;
-  }
-  getContainer() {
-    return this.container;
-  }
-  setBottomColor(color) {
-    this.bottomColor = color;
-  }
-  getBottomColor() {
-    return this.bottomColor;
-  }
-  addPlugin(plugin) {
-    this.plugins.push(plugin);
-    return this;
-  }
-  init() {
-    const sceneId = this.container.get(import_l7_core.TYPES.SceneID);
-    this.configService.setLayerConfig(sceneId, this.id, this.rawConfig);
-    this.layerType = this.rawConfig.layerType;
-    this.iconService = this.container.get(import_l7_core.TYPES.IIconService);
-    this.fontService = this.container.get(import_l7_core.TYPES.IFontService);
-    this.rendererService = this.container.get(import_l7_core.TYPES.IRendererService);
-    this.layerService = this.container.get(import_l7_core.TYPES.ILayerService);
-    this.interactionService = this.container.get(import_l7_core.TYPES.IInteractionService);
-    this.pickingService = this.container.get(import_l7_core.TYPES.IPickingService);
-    this.mapService = this.container.get(import_l7_core.TYPES.IMapService);
-    const { enableMultiPassRenderer, passes } = this.getLayerConfig();
-    if (enableMultiPassRenderer && (passes == null ? void 0 : passes.length) && passes.length > 0) {
-      this.mapService.on("mapAfterFrameChange", () => {
-        this.renderLayers();
-      });
-    }
-    this.cameraService = this.container.get(import_l7_core.TYPES.ICameraService);
-    this.coordinateService = this.container.get(import_l7_core.TYPES.ICoordinateSystemService);
-    this.shaderModuleService = this.container.get(import_l7_core.TYPES.IShaderModuleService);
-    this.postProcessingPassFactory = this.container.get(import_l7_core.TYPES.IFactoryPostProcessingPass);
-    this.normalPassFactory = this.container.get(import_l7_core.TYPES.IFactoryNormalPass);
-    this.styleAttributeService = this.container.get(import_l7_core.TYPES.IStyleAttributeService);
-    this.multiPassRenderer = this.container.get(import_l7_core.TYPES.IMultiPassRenderer);
-    this.multiPassRenderer.setLayer(this);
-    this.pendingStyleAttributes.forEach(({ attributeName, attributeField, attributeValues, updateOptions }) => {
-      this.styleAttributeService.updateStyleAttribute(attributeName, {
-        scale: {
-          field: attributeField,
-          ...this.splitValuesAndCallbackInAttribute(attributeValues, this.getLayerConfig()[attributeName])
-        }
-      }, updateOptions);
-    });
-    this.pendingStyleAttributes = [];
-    this.plugins = this.container.getAll(import_l7_core.TYPES.ILayerPlugin);
-    for (const plugin of this.plugins) {
-      plugin.apply(this, {
-        rendererService: this.rendererService,
-        mapService: this.mapService,
-        styleAttributeService: this.styleAttributeService,
-        normalPassFactory: this.normalPassFactory,
-        postProcessingPassFactory: this.postProcessingPassFactory
-      });
-    }
-    this.hooks.init.call();
-    this.hooks.afterInit.call();
-    this.emit("inited", {
-      target: this,
-      type: "inited"
-    });
-    this.emit("add", {
-      target: this,
-      type: "add"
-    });
-    return this;
-  }
-  updateModelData(data) {
-    if (data.attributes && data.elements) {
-      this.models.map((m) => {
-        m.updateAttributesAndElements(data.attributes, data.elements);
-      });
-    } else {
-      console.warn("data error");
-    }
-  }
-  createModelData(data, option) {
-    var _a;
-    if ((_a = this.layerModel) == null ? void 0 : _a.createModelData) {
-      return this.layerModel.createModelData(option);
-    }
-    const calEncodeData = this.calculateEncodeData(data, option);
-    const triangulation = this.triangulation;
-    if (calEncodeData && triangulation) {
-      return this.styleAttributeService.createAttributesAndIndices(calEncodeData, triangulation);
-    } else {
-      return {
-        attributes: void 0,
-        elements: void 0
-      };
-    }
-  }
-  calculateEncodeData(data, option) {
-    if (this.inited) {
-      return (0, import_layerData.calculateData)(this, this.fontService, this.mapService, this.styleAttributeService, data, option);
-    } else {
-      console.warn("layer not inited!");
-      return null;
-    }
-  }
-  prepareBuildModel() {
-    this.inited = true;
-    this.updateLayerConfig({
-      ...this.getDefaultConfig(),
-      ...this.rawConfig
-    });
-    const { animateOption } = this.getLayerConfig();
-    if (animateOption == null ? void 0 : animateOption.enable) {
-      this.layerService.startAnimate();
-      this.aniamateStatus = true;
-    }
-  }
-  color(field, values, updateOptions) {
-    this.updateStyleAttribute("color", field, values, updateOptions);
-    return this;
-  }
-  texture(field, values, updateOptions) {
-    this.updateStyleAttribute("texture", field, values, updateOptions);
-    return this;
-  }
-  rotate(field, values, updateOptions) {
-    this.updateStyleAttribute("rotate", field, values, updateOptions);
-    return this;
-  }
-  size(field, values, updateOptions) {
-    this.updateStyleAttribute("size", field, values, updateOptions);
-    return this;
-  }
-  filter(field, values, updateOptions) {
-    this.updateStyleAttribute("filter", field, values, updateOptions);
-    return this;
-  }
-  shape(field, values, updateOptions) {
-    var _a, _b, _c;
-    const lastShape = (_c = (_b = (_a = this.styleAttributeService) == null ? void 0 : _a.getLayerStyleAttribute("shape")) == null ? void 0 : _b.scale) == null ? void 0 : _c.field;
-    const currentShape = field;
-    this.shapeOption = {
-      field,
-      values
-    };
-    this.updateStyleAttribute("shape", field, values, updateOptions);
-    if (!this.tileLayer) {
-      (0, import_updateShape.updateShape)(this, lastShape, currentShape);
-    }
-    return this;
-  }
-  label(field, values, updateOptions) {
-    this.pendingStyleAttributes.push({
-      attributeName: "label",
-      attributeField: field,
-      attributeValues: values,
-      updateOptions
-    });
-    return this;
-  }
-  animate(options) {
-    let rawAnimate = {};
-    if ((0, import_lodash.isObject)(options)) {
-      rawAnimate.enable = true;
-      rawAnimate = {
-        ...rawAnimate,
-        ...options
-      };
-    } else {
-      rawAnimate.enable = options;
-    }
-    this.updateLayerConfig({
-      animateOption: rawAnimate
-    });
-    return this;
-  }
-  source(data, options) {
-    if (data == null ? void 0 : data.data) {
-      this.setSource(data);
-      return this;
-    }
-    this.sourceOption = {
-      data,
-      options
-    };
-    this.clusterZoom = 0;
-    return this;
-  }
-  setData(data, options) {
-    if (this.inited) {
-      this.layerSource.setData(data, options);
-    } else {
-      this.on("inited", () => {
-        const currentSource = this.getSource();
-        if (!currentSource) {
-          this.source(new import_l7_source.default(data, options));
-          this.sourceEvent();
-        } else {
-          this.layerSource.setData(data, options);
-        }
-      });
-    }
-    return this;
-  }
-  style(options) {
-    const lastConfig = this.getLayerConfig();
-    const { passes, ...rest } = options;
-    if (passes) {
-      (0, import_multiPassRender.normalizePasses)(passes).forEach((pass) => {
-        const postProcessingPass = this.multiPassRenderer.getPostProcessor().getPostProcessingPassByName(pass[0]);
-        if (postProcessingPass) {
-          postProcessingPass.updateOptions(pass[1]);
-        }
-      });
-    }
-    this.rawConfig = {
-      ...this.rawConfig,
-      ...rest
-    };
-    if (this.container) {
-      this.updateLayerConfig(this.rawConfig);
-      this.styleNeedUpdate = true;
-    }
-    if (lastConfig && lastConfig.mask === true && options.mask === false) {
-      this.clearModels();
-      this.layerModel.buildModels((models) => {
-        this.models = models;
-      });
-    }
-    return this;
-  }
-  scale(field, cfg) {
-    if ((0, import_lodash.isObject)(field)) {
-      this.scaleOptions = {
-        ...this.scaleOptions,
-        ...field
-      };
-    } else {
-      this.scaleOptions[field] = cfg;
-    }
-    return this;
-  }
-  renderLayers() {
-    this.rendering = true;
-    this.layerService.renderLayers();
-    this.rendering = false;
-  }
-  render() {
-    if (this.tileLayer !== void 0) {
-      this.tileLayer.render();
-      return this;
-    }
-    if (this.getEncodedData() && this.getEncodedData().length !== 0) {
-      this.renderModels();
-    }
-    return this;
-  }
-  async renderMultiPass() {
-    if (this.getEncodedData() && this.getEncodedData().length !== 0) {
-      if (this.multiPassRenderer && this.multiPassRenderer.getRenderFlag()) {
-        await this.multiPassRenderer.render();
-      } else if (this.multiPassRenderer) {
-        this.renderModels();
-      } else {
-        this.renderModels();
-      }
-    }
-  }
-  active(options) {
-    const activeOption = {};
-    activeOption.enableHighlight = (0, import_lodash.isObject)(options) ? true : options;
-    if ((0, import_lodash.isObject)(options)) {
-      activeOption.enableHighlight = true;
-      if (options.color) {
-        activeOption.highlightColor = options.color;
-      }
-      if (options.mix) {
-        activeOption.activeMix = options.mix;
-      }
-    } else {
-      activeOption.enableHighlight = !!options;
-    }
-    this.updateLayerConfig(activeOption);
-    return this;
-  }
-  setActive(id, options) {
-    if ((0, import_lodash.isObject)(id)) {
-      const { x = 0, y = 0 } = id;
-      this.updateLayerConfig({
-        highlightColor: (0, import_lodash.isObject)(options) ? options.color : this.getLayerConfig().highlightColor,
-        activeMix: (0, import_lodash.isObject)(options) ? options.mix : this.getLayerConfig().activeMix
-      });
-      this.pick({ x, y });
-    } else {
-      this.updateLayerConfig({
-        pickedFeatureID: id,
-        highlightColor: (0, import_lodash.isObject)(options) ? options.color : this.getLayerConfig().highlightColor,
-        activeMix: (0, import_lodash.isObject)(options) ? options.mix : this.getLayerConfig().activeMix
-      });
-      this.hooks.beforeSelect.call((0, import_l7_utils.encodePickingColor)(id)).then(() => {
-        setTimeout(() => {
-          this.reRender();
-        }, 1);
-      });
-    }
-  }
-  select(option) {
-    const activeOption = {};
-    activeOption.enableSelect = (0, import_lodash.isObject)(option) ? true : option;
-    if ((0, import_lodash.isObject)(option)) {
-      activeOption.enableSelect = true;
-      if (option.color) {
-        activeOption.selectColor = option.color;
-      }
-      if (option.mix) {
-        activeOption.selectMix = option.mix;
-      }
-    } else {
-      activeOption.enableSelect = !!option;
-    }
-    this.updateLayerConfig(activeOption);
-    return this;
-  }
-  setSelect(id, options) {
-    if ((0, import_lodash.isObject)(id)) {
-      const { x = 0, y = 0 } = id;
-      this.updateLayerConfig({
-        selectColor: (0, import_lodash.isObject)(options) ? options.color : this.getLayerConfig().selectColor,
-        selectMix: (0, import_lodash.isObject)(options) ? options.mix : this.getLayerConfig().selectMix
-      });
-      this.pick({ x, y });
-    } else {
-      this.updateLayerConfig({
-        pickedFeatureID: id,
-        selectColor: (0, import_lodash.isObject)(options) ? options.color : this.getLayerConfig().selectColor,
-        selectMix: (0, import_lodash.isObject)(options) ? options.mix : this.getLayerConfig().selectMix
-      });
-      this.hooks.beforeSelect.call((0, import_l7_utils.encodePickingColor)(id)).then(() => {
-        setTimeout(() => {
-          this.reRender();
-        }, 1);
-      });
-    }
-  }
-  setBlend(type) {
-    this.updateLayerConfig({
-      blend: type
-    });
-    this.layerModelNeedUpdate = true;
-    this.reRender();
-    return this;
-  }
-  show() {
-    this.updateLayerConfig({
-      visible: true
-    });
-    this.reRender();
-    return this;
-  }
-  hide() {
-    if (this.type === "CanvasLayer" && this.layerModel.clearCanvas) {
-      this.layerModel.clearCanvas();
-    }
-    this.updateLayerConfig({
-      visible: false
-    });
-    this.reRender();
-    return this;
-  }
-  setIndex(index) {
-    this.zIndex = index;
-    this.layerService.updateLayerRenderList();
-    this.layerService.renderLayers();
-    return this;
-  }
-  setCurrentPickId(id) {
-    this.currentPickId = id;
-  }
-  getCurrentPickId() {
-    return this.currentPickId;
-  }
-  setCurrentSelectedId(id) {
-    this.selectedFeatureID = id;
-  }
-  getCurrentSelectedId() {
-    return this.selectedFeatureID;
-  }
-  isVisible() {
-    const zoom = this.mapService.getZoom();
-    const {
-      visible,
-      minZoom = -Infinity,
-      maxZoom = Infinity
-    } = this.getLayerConfig();
-    return !!visible && zoom >= minZoom && zoom <= maxZoom;
-  }
-  setMultiPass(enableMultiPass, currentPasses) {
-    this.updateLayerConfig({
-      enableMultiPassRenderer: enableMultiPass
-    });
-    if (currentPasses) {
-      this.updateLayerConfig({
-        passes: currentPasses
-      });
-    }
-    if (enableMultiPass) {
-      const { passes = [] } = this.getLayerConfig();
-      this.multiPassRenderer = (0, import_multiPassRender.createMultiPassRenderer)(this, passes, this.postProcessingPassFactory, this.normalPassFactory);
-      this.multiPassRenderer.setRenderFlag(true);
-      const { width, height } = this.rendererService.getViewportSize();
-      this.multiPassRenderer.resize(width, height);
-    }
-    return this;
-  }
-  setMinZoom(minZoom) {
-    this.updateLayerConfig({
-      minZoom
-    });
-    return this;
-  }
-  getMinZoom() {
-    const { minZoom } = this.getLayerConfig();
-    return minZoom;
-  }
-  getMaxZoom() {
-    const { maxZoom } = this.getLayerConfig();
-    return maxZoom;
-  }
-  get(name) {
-    const cfg = this.getLayerConfig();
-    return cfg[name];
-  }
-  setMaxZoom(maxZoom) {
-    this.updateLayerConfig({
-      maxZoom
-    });
-    return this;
-  }
-  setAutoFit(autoFit) {
-    this.updateLayerConfig({
-      autoFit
-    });
-    return this;
-  }
-  fitBounds(fitBoundsOptions) {
-    if (!this.inited) {
-      this.updateLayerConfig({
-        autoFit: true
-      });
-      return this;
-    }
-    const source = this.getSource();
-    const extent = source.extent;
-    const isValid = extent.some((v) => Math.abs(v) === Infinity);
-    if (isValid) {
-      return this;
-    }
-    this.mapService.fitBounds([
-      [extent[0], extent[1]],
-      [extent[2], extent[3]]
-    ], fitBoundsOptions);
-    return this;
-  }
-  destroy(refresh = true) {
-    var _a;
-    if (this.isDestroied) {
-      return;
-    }
-    this.layerChildren.map((child) => child.destroy());
-    this.layerChildren = [];
-    this.masks.map((mask) => mask.destroy());
-    this.masks = [];
-    this.hooks.beforeDestroy.call();
-    this.layerSource.off("sourceUpdate", this.sourceEvent);
-    this.multiPassRenderer.destroy();
-    this.styleAttributeService.clearAllAttributes();
-    this.hooks.afterDestroy.call();
-    (_a = this.layerModel) == null ? void 0 : _a.clearModels();
-    this.models = [];
-    this.layerService.cleanRemove(this, refresh);
-    this.emit("remove", {
-      target: this,
-      type: "remove"
-    });
-    this.emit("destroy", {
-      target: this,
-      type: "destroy"
-    });
-    this.removeAllListeners();
-    this.isDestroied = true;
-  }
-  clear() {
-    this.styleAttributeService.clearAllAttributes();
-  }
-  clearModels() {
-    var _a;
-    this.models.forEach((model) => model.destroy());
-    (_a = this.layerModel) == null ? void 0 : _a.clearModels();
-    this.models = [];
-  }
-  isDirty() {
-    return !!(this.styleAttributeService.getLayerStyleAttributes() || []).filter((attribute) => attribute.needRescale || attribute.needRemapping || attribute.needRegenerateVertices).length;
-  }
-  setSource(source) {
-    if (this.layerSource) {
-      this.layerSource.off("sourceUpdate", this.sourceEvent);
-    }
-    this.layerSource = source;
-    this.clusterZoom = 0;
-    if (this.inited && this.layerSource.cluster) {
-      const zoom = this.mapService.getZoom();
-      this.layerSource.updateClusterData(zoom);
-    }
-    if (this.layerSource.inited) {
-      this.sourceEvent();
-    }
-    this.layerSource.on("sourceUpdate", () => {
-      this.sourceEvent();
-    });
-  }
-  getSource() {
-    return this.layerSource;
-  }
-  getScaleOptions() {
-    return this.scaleOptions;
-  }
-  setEncodedData(encodedData) {
-    this.encodedData = encodedData;
-  }
-  getEncodedData() {
-    return this.encodedData;
-  }
-  getScale(name) {
-    return this.styleAttributeService.getLayerAttributeScale(name);
-  }
-  getLegendItems(name) {
-    const scale = this.styleAttributeService.getLayerAttributeScale(name);
-    if (!scale) {
-      return [];
-    }
-    if (scale.invertExtent) {
-      const items = scale.range().map((item) => {
-        return {
-          value: scale.invertExtent(item),
-          [name]: item
-        };
-      });
-      return items;
-    } else if (scale.ticks) {
-      const items = scale.ticks().map((item) => {
-        return {
-          value: item,
-          [name]: scale(item)
-        };
-      });
-      return items;
-    } else if (scale == null ? void 0 : scale.domain) {
-      const items = scale.domain().filter((item) => !(0, import_lodash.isUndefined)(item)).map((item) => {
-        return {
-          value: item,
-          [name]: scale(item)
-        };
-      });
-      return items;
-    }
-    return [];
-  }
-  pick({ x, y }) {
-    this.interactionService.triggerHover({ x, y });
-  }
-  boxSelect(box, cb) {
-    this.pickingService.boxPickLayer(this, box, cb);
-  }
-  buildLayerModel(options) {
-    const {
-      moduleName,
-      vertexShader,
-      fragmentShader,
-      triangulation,
-      segmentNumber,
-      workerEnabled = false,
-      workerOptions,
-      ...rest
-    } = options;
-    this.shaderModuleService.registerModule(moduleName, {
-      vs: vertexShader,
-      fs: fragmentShader
-    });
-    const { vs, fs, uniforms } = this.shaderModuleService.getModule(moduleName);
-    const { createModel } = this.rendererService;
-    return new Promise((resolve, reject) => {
-      if (workerOptions && workerOptions.modelType in import_l7_utils.WorkerSourceMap && workerEnabled) {
-        this.styleAttributeService.createAttributesAndIndicesAscy(this.encodedData, segmentNumber, workerOptions).then(({ attributes, elements }) => {
-          const m = createModel({
-            attributes,
-            uniforms,
-            fs,
-            vs,
-            elements,
-            blend: import_blend.BlendTypes[import_l7_core.BlendType.normal],
-            ...rest
-          });
-          resolve(m);
-        }).catch((err) => reject(err));
-      } else {
-        const {
-          attributes,
-          elements,
-          count
-        } = this.styleAttributeService.createAttributesAndIndices(this.encodedData, triangulation, segmentNumber);
-        const modeloptions = {
-          attributes,
-          uniforms,
-          fs,
-          vs,
-          elements,
-          blend: import_blend.BlendTypes[import_l7_core.BlendType.normal],
-          ...rest
-        };
-        if (count) {
-          modeloptions.count = count;
-        }
-        const m = createModel(modeloptions);
-        resolve(m);
-      }
-    });
-  }
-  createAttrubutes(options) {
-    const { triangulation } = options;
-    const { attributes } = this.styleAttributeService.createAttributes(this.encodedData, triangulation);
-    return attributes;
-  }
-  getTime() {
-    return this.layerService.clock.getDelta();
-  }
-  setAnimateStartTime() {
-    this.animateStartTime = this.layerService.clock.getElapsedTime();
-  }
-  stopAnimate() {
-    if (this.aniamateStatus) {
-      this.layerService.stopAnimate();
-      this.aniamateStatus = false;
-      this.updateLayerConfig({
-        animateOption: {
-          enable: false
-        }
-      });
-    }
-  }
-  getLayerAnimateTime() {
-    return this.layerService.clock.getElapsedTime() - this.animateStartTime;
-  }
-  needPick(type) {
-    const {
-      enableHighlight = true,
-      enableSelect = true
-    } = this.getLayerConfig();
-    let isPick = this.eventNames().indexOf(type) !== -1 || this.eventNames().indexOf("un" + type) !== -1;
-    if ((type === "click" || type === "dblclick") && enableSelect) {
-      isPick = true;
-    }
-    if (type === "mousemove" && (enableHighlight || this.eventNames().indexOf("mouseenter") !== -1 || this.eventNames().indexOf("unmousemove") !== -1 || this.eventNames().indexOf("mouseout") !== -1)) {
-      isPick = true;
-    }
-    return this.isVisible() && isPick;
-  }
-  buildModels() {
-    throw new Error("Method not implemented.");
-  }
-  rebuildModels() {
-    throw new Error("Method not implemented.");
-  }
-  async renderMulPass(multiPassRenderer) {
-    await multiPassRenderer.render();
-  }
-  renderModels(isPicking) {
-    var _a;
-    if (this.getEncodedData() && this.getEncodedData().length > 0) {
-      if (this.layerModelNeedUpdate && this.layerModel) {
-        this.layerModel.buildModels((models) => {
-          this.models = models;
-          this.hooks.beforeRender.call();
-          this.layerModelNeedUpdate = false;
-        });
-      }
-      if ((_a = this == null ? void 0 : this.layerModel) == null ? void 0 : _a.renderUpdate) {
-        this.layerModel.renderUpdate();
-      }
-      this.models.forEach((model) => {
-        model.draw({
-          uniforms: this.layerModel.getUninforms()
-        }, isPicking);
-      });
-    }
-    return this;
-  }
-  updateStyleAttribute(type, field, values, updateOptions) {
-    if (!this.inited) {
-      this.pendingStyleAttributes.push({
-        attributeName: type,
-        attributeField: field,
-        attributeValues: values,
-        updateOptions
-      });
-    } else {
-      this.styleAttributeService.updateStyleAttribute(type, {
-        scale: {
-          field,
-          ...this.splitValuesAndCallbackInAttribute(values, this.getLayerConfig()[field])
-        }
-      }, updateOptions);
-    }
-  }
-  getShaderPickStat() {
-    return this.layerService.getShaderPickStat();
-  }
-  setEarthTime(time) {
-    console.warn("empty fn");
-  }
-  getConfigSchema() {
-    throw new Error("Method not implemented.");
-  }
-  getModelType() {
-    throw new Error("Method not implemented.");
-  }
-  getDefaultConfig() {
-    return {};
-  }
-  reRender() {
-    if (this.inited) {
-      this.layerService.updateLayerRenderList();
-      this.layerService.renderLayers();
-    }
-  }
-  splitValuesAndCallbackInAttribute(valuesOrCallback, defaultValues) {
-    return {
-      values: (0, import_lodash.isFunction)(valuesOrCallback) ? void 0 : valuesOrCallback || defaultValues,
-      callback: (0, import_lodash.isFunction)(valuesOrCallback) ? valuesOrCallback : void 0
-    };
-  }
-};
-__decorateClass([
-  (0, import_l7_core.lazyInject)(import_l7_core.TYPES.IGlobalConfigService)
-], BaseLayer.prototype, "configService", 2);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});