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

package/lib/popup/layerPopup.js

@@ -0,0 +1,200 @@
+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/popup/layerPopup.ts
+var layerPopup_exports = {};
+__export(layerPopup_exports, {
+  LayerPopup: () => LayerPopup,
+  default: () => LayerPopup
+});
+module.exports = __toCommonJS(layerPopup_exports);
+var import_l7_utils = require("@antv/l7-utils");
+var import_lodash = require("lodash");
+var import_popup = __toESM(require("./popup"));
+var LayerPopup = class extends import_popup.default {
+  constructor() {
+    super(...arguments);
+    this.layerConfigMap = /* @__PURE__ */ new WeakMap();
+  }
+  addTo(scene) {
+    super.addTo(scene);
+    this.bindLayerEvent();
+    this.hide();
+    return this;
+  }
+  remove() {
+    super.remove();
+    this.unbindLayerEvent();
+    return this;
+  }
+  setOptions(option) {
+    this.unbindLayerEvent();
+    super.setOptions(option);
+    this.bindLayerEvent();
+    return this;
+  }
+  getDefault(option) {
+    const isClickTrigger = option.trigger === "click";
+    return {
+      ...super.getDefault(option),
+      trigger: "hover",
+      followCursor: !isClickTrigger,
+      lngLat: {
+        lng: 0,
+        lat: 0
+      },
+      offsets: [0, 10],
+      closeButton: false,
+      closeOnClick: false,
+      autoClose: false,
+      closeOnEsc: false
+    };
+  }
+  bindLayerEvent() {
+    const { config, trigger } = this.popupOption;
+    config.forEach((configItem) => {
+      const layer = this.getLayerByConfig(configItem);
+      if (!layer) {
+        return;
+      }
+      const layerInfo = {
+        ...configItem
+      };
+      if (trigger === "hover") {
+        const onMouseMove = this.onLayerMouseMove.bind(this, layer);
+        const onMouseOut = this.onLayerMouseOut.bind(this, layer);
+        layerInfo.onMouseMove = onMouseMove;
+        layerInfo.onMouseOut = onMouseOut;
+        layer == null ? void 0 : layer.on("mousemove", onMouseMove);
+        layer == null ? void 0 : layer.on("mouseout", onMouseOut);
+      } else {
+        const onClick = this.onLayerClick.bind(this, layer);
+        layerInfo.onClick = onClick;
+        layer == null ? void 0 : layer.on("click", onClick);
+      }
+      const source = layer.getSource();
+      const onSourceUpdate = this.onSourceUpdate.bind(this, layer);
+      source == null ? void 0 : source.on("update", onSourceUpdate);
+      layerInfo.onSourceUpdate = onSourceUpdate;
+      this.layerConfigMap.set(layer, layerInfo);
+    });
+  }
+  unbindLayerEvent() {
+    const { config } = this.popupOption;
+    config.forEach((configItem) => {
+      var _a;
+      const layer = this.getLayerByConfig(configItem);
+      const layerInfo = layer && this.layerConfigMap.get(layer);
+      if (!layerInfo) {
+        return;
+      }
+      const { onMouseMove, onMouseOut, onClick, onSourceUpdate } = layerInfo;
+      if (onMouseMove) {
+        layer.off("mousemove", onMouseMove);
+      }
+      if (onMouseOut) {
+        layer.off("mouseout", onMouseOut);
+      }
+      if (onClick) {
+        layer.off("click", onClick);
+      }
+      if (onSourceUpdate) {
+        (_a = layer == null ? void 0 : layer.getSource()) == null ? void 0 : _a.off("update", onSourceUpdate);
+      }
+    });
+  }
+  onLayerMouseMove(layer, e) {
+    if (!this.isSameFeature(layer, e.featureId)) {
+      const frag = this.getLayerInfoFrag(layer, e);
+      this.setDOMContent(frag);
+      this.displayFeatureInfo = {
+        layer,
+        featureId: e.featureId
+      };
+    }
+    if (!this.isShow) {
+      this.show();
+    }
+  }
+  onLayerMouseOut(layer, e) {
+    this.displayFeatureInfo = void 0;
+    if (this.isShow) {
+      this.hide();
+    }
+  }
+  onLayerClick(layer, e) {
+    if (this.isShow && this.isSameFeature(layer, e.featureId)) {
+      this.hide();
+    } else {
+      const frag = this.getLayerInfoFrag(layer, e);
+      this.setDOMContent(frag);
+      this.setLnglat(e.lngLat);
+      this.show();
+      this.displayFeatureInfo = {
+        layer,
+        featureId: e.featureId
+      };
+    }
+  }
+  onSourceUpdate(layer) {
+    var _a;
+    if (((_a = this.displayFeatureInfo) == null ? void 0 : _a.layer) === layer) {
+      this.hide();
+      this.displayFeatureInfo = void 0;
+    }
+  }
+  getLayerInfoFrag(layer, e) {
+    const layerInfo = this.layerConfigMap.get(layer);
+    const frag = document.createDocumentFragment();
+    if (layerInfo) {
+      let feature = e.feature;
+      if (feature.type === "Feature" && "properties" in feature && "geometry" in feature) {
+        feature = feature.properties;
+      }
+      const { fields } = layerInfo;
+      fields == null ? void 0 : fields.forEach((fieldConfig) => {
+        const { field, formatField, formatValue, getValue } = typeof fieldConfig === "string" ? { field: fieldConfig } : fieldConfig;
+        const row = import_l7_utils.DOM.create("div", "l7-layer-popup__row");
+        const value = getValue ? getValue(e.feature) : (0, import_lodash.get)(feature, field);
+        row.innerHTML = `${formatField ? formatField(field) : field}: ${formatValue ? formatValue(value) : value}`;
+        frag.appendChild(row);
+      });
+    }
+    return frag;
+  }
+  getLayerByConfig(config) {
+    const layer = config.layer;
+    if (layer instanceof Object) {
+      return layer;
+    }
+    if (typeof layer === "string") {
+      return this.layerService.getLayer(layer) || this.layerService.getLayerByName(layer);
+    }
+  }
+  isSameFeature(layer, featureId) {
+    const displayFeatureInfo = this.displayFeatureInfo;
+    return displayFeatureInfo && layer === displayFeatureInfo.layer && featureId === displayFeatureInfo.featureId;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LayerPopup
+});

package/lib/popup/popup.js

@@ -0,0 +1,388 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/popup/popup.ts
+var popup_exports = {};
+__export(popup_exports, {
+  Popup: () => Popup,
+  default: () => Popup
+});
+module.exports = __toCommonJS(popup_exports);
+var import_l7_core = require("@antv/l7-core");
+var import_l7_utils = require("@antv/l7-utils");
+var import_eventemitter3 = require("eventemitter3");
+var import_icon = require("../utils/icon");
+var Popup = class extends import_eventemitter3.EventEmitter {
+  constructor(cfg) {
+    super();
+    this.isShow = true;
+    this.onMouseMove = (e) => {
+      const container = this.mapsService.getMapContainer();
+      const { left = 0, top = 0 } = (container == null ? void 0 : container.getBoundingClientRect()) ?? {};
+      this.setPopupPosition(e.clientX - left, e.clientY - top);
+    };
+    this.updateLngLatPosition = () => {
+      if (!this.mapsService || this.popupOption.followCursor) {
+        return;
+      }
+      const { lng, lat } = this.lngLat;
+      const { x, y } = this.mapsService.lngLatToContainer([lng, lat]);
+      this.setPopupPosition(x, y);
+    };
+    this.onKeyDown = (e) => {
+      if (e.keyCode === 27) {
+        this.remove();
+      }
+    };
+    this.onCloseButtonClick = (e) => {
+      if (e.stopPropagation) {
+        e.stopPropagation();
+      }
+      this.remove();
+    };
+    this.update = () => {
+      const hasPosition = !!this.lngLat;
+      const {
+        className,
+        style,
+        maxWidth,
+        anchor,
+        stopPropagation
+      } = this.popupOption;
+      if (!this.mapsService || !hasPosition || !this.content) {
+        return;
+      }
+      const popupContainer = this.mapsService.getMarkerContainer();
+      if (!this.container && popupContainer) {
+        this.container = import_l7_utils.DOM.create("div", `l7-popup ${className ?? ""} ${!this.isShow ? "l7-popup-hide" : ""}`, popupContainer);
+        if (style) {
+          this.container.setAttribute("style", style);
+        }
+        this.tip = import_l7_utils.DOM.create("div", "l7-popup-tip", this.container);
+        this.container.appendChild(this.content);
+        if (stopPropagation) {
+          ["mousemove", "mousedown", "mouseup", "click", "dblclick"].forEach((type) => {
+            this.container.addEventListener(type, (e) => {
+              e.stopPropagation();
+            });
+          });
+        }
+        this.container.style.whiteSpace = "nowrap";
+      }
+      if (maxWidth && this.container.style.maxWidth !== maxWidth) {
+        this.container.style.maxWidth = maxWidth;
+      }
+      this.updateLngLatPosition();
+      import_l7_utils.DOM.setTransform(this.container, `${import_l7_utils.anchorTranslate[anchor]}`);
+      (0, import_l7_utils.applyAnchorClass)(this.container, anchor, "popup");
+    };
+    this.popupOption = {
+      ...this.getDefault(cfg ?? {}),
+      ...cfg
+    };
+    const { lngLat } = this.popupOption;
+    if (lngLat) {
+      this.lngLat = lngLat;
+    }
+  }
+  get lngLat() {
+    return this.popupOption.lngLat ?? {
+      lng: 0,
+      lat: 0
+    };
+  }
+  set lngLat(newLngLat) {
+    this.popupOption.lngLat = newLngLat;
+  }
+  getIsShow() {
+    return this.isShow;
+  }
+  addTo(scene) {
+    this.mapsService = scene.get(import_l7_core.TYPES.IMapService);
+    this.sceneService = scene.get(import_l7_core.TYPES.ISceneService);
+    this.layerService = scene.get(import_l7_core.TYPES.ILayerService);
+    this.mapsService.on("camerachange", this.update);
+    this.mapsService.on("viewchange", this.update);
+    this.scene = scene;
+    this.update();
+    this.updateCloseOnClick();
+    this.updateCloseOnEsc();
+    this.updateFollowCursor();
+    const { html, text } = this.popupOption;
+    if (html) {
+      this.setHTML(html);
+    } else if (text) {
+      this.setText(text);
+    }
+    this.emit("open");
+    return this;
+  }
+  remove() {
+    if (!this.isOpen()) {
+      return;
+    }
+    if (this.content) {
+      import_l7_utils.DOM.remove(this.content);
+    }
+    if (this.container) {
+      import_l7_utils.DOM.remove(this.container);
+      delete this.container;
+    }
+    if (this.mapsService) {
+      this.mapsService.off("camerachange", this.update);
+      this.mapsService.off("viewchange", this.update);
+      this.updateCloseOnClick(true);
+      this.updateCloseOnEsc(true);
+      this.updateFollowCursor(true);
+      delete this.mapsService;
+    }
+    this.emit("close");
+    return this;
+  }
+  getOptions() {
+    return this.popupOption;
+  }
+  setOptions(option) {
+    this.popupOption = {
+      ...this.popupOption,
+      ...option
+    };
+    if (this.checkUpdateOption(option, [
+      "closeButton",
+      "closeButtonOffsets",
+      "maxWidth",
+      "anchor",
+      "stopPropagation",
+      "className",
+      "style",
+      "lngLat",
+      "offsets",
+      "title"
+    ])) {
+      if (this.container) {
+        import_l7_utils.DOM.remove(this.container);
+        this.container = void 0;
+      }
+      if (this.popupOption.html) {
+        this.setHTML(this.popupOption.html);
+      } else if (this.popupOption.text) {
+        this.setText(this.popupOption.text);
+      }
+    }
+    if (this.checkUpdateOption(option, ["closeOnEsc"])) {
+      this.updateCloseOnEsc();
+    }
+    if (this.checkUpdateOption(option, ["closeOnClick"])) {
+      this.updateCloseOnClick();
+    }
+    if (this.checkUpdateOption(option, ["followCursor"])) {
+      this.updateFollowCursor();
+    }
+    if (this.checkUpdateOption(option, ["html"]) && option.html) {
+      this.setHTML(option.html);
+    } else if (this.checkUpdateOption(option, ["text"]) && option.text) {
+      this.setText(option.text);
+    }
+    if (this.checkUpdateOption(option, ["lngLat"]) && option.lngLat) {
+      this.setLnglat(option.lngLat);
+    }
+    return this;
+  }
+  open() {
+    this.addTo(this.scene);
+    return this;
+  }
+  close() {
+    this.remove();
+    return this;
+  }
+  show() {
+    if (this.isShow) {
+      return;
+    }
+    if (this.container) {
+      import_l7_utils.DOM.removeClass(this.container, "l7-popup-hide");
+    }
+    this.isShow = true;
+    this.emit("show");
+    return this;
+  }
+  hide() {
+    if (!this.isShow) {
+      return;
+    }
+    if (this.container) {
+      import_l7_utils.DOM.addClass(this.container, "l7-popup-hide");
+    }
+    this.isShow = false;
+    this.emit("hide");
+    return this;
+  }
+  setHTML(html) {
+    this.popupOption.html = html;
+    return this.setDOMContent(this.getPopupHTMLFragment(html));
+  }
+  setText(text) {
+    this.popupOption.text = text;
+    return this.setDOMContent(window.document.createTextNode(text));
+  }
+  panToPopup() {
+    const { lng, lat } = this.lngLat;
+    if (this.popupOption.autoPan) {
+      this.mapsService.panTo([lng, lat]);
+    }
+    return this;
+  }
+  setLngLat(lngLat) {
+    return this.setLnglat(lngLat);
+  }
+  setLnglat(lngLat) {
+    this.lngLat = lngLat;
+    if (Array.isArray(lngLat)) {
+      this.lngLat = {
+        lng: lngLat[0],
+        lat: lngLat[1]
+      };
+    }
+    if (this.mapsService) {
+      this.mapsService.off("camerachange", this.update);
+      this.mapsService.off("viewchange", this.update);
+      this.mapsService.on("camerachange", this.update);
+      this.mapsService.on("viewchange", this.update);
+    }
+    this.update();
+    if (this.popupOption.autoPan) {
+      setTimeout(() => {
+        this.panToPopup();
+      }, 0);
+    }
+    return this;
+  }
+  getLnglat() {
+    return this.lngLat;
+  }
+  setMaxWidth(maxWidth) {
+    this.popupOption.maxWidth = maxWidth;
+    this.update();
+    return this;
+  }
+  isOpen() {
+    return !!this.mapsService;
+  }
+  getDefault(option) {
+    return {
+      closeButton: true,
+      closeOnClick: true,
+      maxWidth: "240px",
+      offsets: [0, 0],
+      anchor: import_l7_utils.anchorType.BOTTOM,
+      stopPropagation: true,
+      autoPan: false,
+      autoClose: true,
+      closeOnEsc: false,
+      followCursor: false
+    };
+  }
+  setDOMContent(htmlNode) {
+    this.createContent();
+    this.contentPanel.appendChild(htmlNode);
+    this.update();
+    return this;
+  }
+  updateCloseOnClick(onlyClear) {
+    this.mapsService.off("click", this.onCloseButtonClick);
+    if (this.popupOption.closeOnClick && !onlyClear) {
+      this.mapsService.on("click", this.onCloseButtonClick);
+    }
+  }
+  updateCloseOnEsc(onlyClear) {
+    window.removeEventListener("keydown", this.onKeyDown);
+    if (this.popupOption.closeOnEsc && !onlyClear) {
+      window.addEventListener("keydown", this.onKeyDown);
+    }
+  }
+  updateFollowCursor(onlyClear) {
+    const container = this.mapsService.getContainer();
+    container.removeEventListener("mousemove", this.onMouseMove);
+    if (this.popupOption.followCursor && !onlyClear) {
+      container.addEventListener("mousemove", this.onMouseMove);
+    }
+  }
+  createContent() {
+    var _a;
+    if (this.content) {
+      import_l7_utils.DOM.remove(this.content);
+    }
+    this.content = import_l7_utils.DOM.create("div", "l7-popup-content", this.container);
+    if (this.popupOption.title) {
+      this.contentTitle = import_l7_utils.DOM.create("div", "l7-popup-content__title", this.content);
+      (_a = this.contentTitle) == null ? void 0 : _a.append(this.getPopupHTMLFragment(this.popupOption.title));
+    } else {
+      this.contentTitle = void 0;
+    }
+    if (this.popupOption.closeButton) {
+      const closeButton = (0, import_icon.createL7Icon)("l7-icon-guanbi");
+      import_l7_utils.DOM.addClass(closeButton, "l7-popup-close-button");
+      this.content.appendChild(closeButton);
+      if (this.popupOption.closeButtonOffsets) {
+        closeButton.style.right = this.popupOption.closeButtonOffsets[0] + "px";
+        closeButton.style.top = this.popupOption.closeButtonOffsets[1] + "px";
+      }
+      closeButton.setAttribute("aria-label", "Close popup");
+      closeButton.addEventListener("click", this.onCloseButtonClick);
+      this.closeButton = closeButton;
+    } else {
+      this.closeButton = void 0;
+    }
+    this.contentPanel = import_l7_utils.DOM.create("div", "l7-popup-content__panel", this.content);
+  }
+  setPopupPosition(left, top) {
+    if (this.container) {
+      const { offsets } = this.popupOption;
+      this.container.style.left = left + offsets[0] + "px";
+      this.container.style.top = top - offsets[1] + "px";
+    }
+  }
+  checkUpdateOption(option, keys) {
+    return keys.some((key) => key in option);
+  }
+  getPopupHTMLFragment(html) {
+    const frag = window.document.createDocumentFragment();
+    const temp = window.document.createElement("body");
+    let child;
+    if (typeof html === "string") {
+      temp.innerHTML = html;
+    } else if (Array.isArray(html)) {
+      temp.append(...html);
+    } else if (html instanceof HTMLElement) {
+      temp.append(html);
+    }
+    while (true) {
+      child = temp.firstChild;
+      if (!child) {
+        break;
+      }
+      frag.appendChild(child);
+    }
+    return frag;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Popup
+});

package/lib/utils/anchor.js

@@ -0,0 +1,63 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/anchor.ts
+var anchor_exports = {};
+__export(anchor_exports, {
+  anchorTranslate: () => anchorTranslate,
+  anchorType: () => anchorType,
+  applyAnchorClass: () => applyAnchorClass
+});
+module.exports = __toCommonJS(anchor_exports);
+var anchorType = /* @__PURE__ */ ((anchorType2) => {
+  anchorType2["CENTER"] = "center";
+  anchorType2["TOP"] = "top";
+  anchorType2["TOP-LEFT"] = "top-left";
+  anchorType2["TOP-RIGHT"] = "top-right";
+  anchorType2["BOTTOM"] = "bottom";
+  anchorType2["BOTTOM-LEFT"] = "bottom-left";
+  anchorType2["LEFT"] = "left";
+  anchorType2["RIGHT"] = "right";
+  return anchorType2;
+})(anchorType || {});
+var anchorTranslate = {
+  center: "translate(-50%,-50%)",
+  top: "translate(-50%,0)",
+  "top-left": "translate(0,0)",
+  "top-right": "translate(-100%,0)",
+  bottom: "translate(-50%,-100%)",
+  "bottom-left": "translate(0,-100%)",
+  "bottom-right": "translate(-100%,-100%)",
+  left: "translate(0,-50%)",
+  right: "translate(-100%,-50%)"
+};
+function applyAnchorClass(element, anchor, prefix) {
+  const classList = element.classList;
+  for (const key in anchorTranslate) {
+    if (anchorTranslate.hasOwnProperty(key)) {
+      classList.remove(`l7-${prefix}-anchor-${key}`);
+    }
+  }
+  classList.add(`l7-${prefix}-anchor-${anchor}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  anchorTranslate,
+  anchorType,
+  applyAnchorClass
+});

package/lib/utils/icon.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/icon.ts
+var icon_exports = {};
+__export(icon_exports, {
+  createL7Icon: () => createL7Icon
+});
+module.exports = __toCommonJS(icon_exports);
+var createL7Icon = (className) => {
+  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  svg.classList.add("l7-iconfont");
+  svg.setAttribute("aria-hidden", "true");
+  const use = document.createElementNS("http://www.w3.org/2000/svg", "use");
+  use.setAttributeNS("http://www.w3.org/1999/xlink", "href", `#${className}`);
+  svg.appendChild(use);
+  return svg;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createL7Icon
+});