@shjjs/visual-ui 1.0.0

package/es/utils/mini3d/components/Particles.mjs

@@ -0,0 +1,78 @@
+import { PointsMaterial as m, AdditiveBlending as b, BufferGeometry as x, BufferAttribute as p, Points as v, CanvasTexture as w } from "three";
+class f {
+  /**
+  *
+  * @param {*} base this
+  * @param {*} config
+  */
+  constructor({ time: t }, r = {}) {
+    this.instance = null, this.time = t, this.enable = !0, this.config = Object.assign(
+      {
+        num: 100,
+        // 粒子数量
+        range: 500,
+        // 范围
+        speed: 0.01,
+        renderOrder: 99,
+        dir: "up",
+        // up-上  down-下
+        material: new m({
+          map: f.createTexture(),
+          size: 20,
+          color: 16777215,
+          transparent: !0,
+          opacity: 1,
+          depthTest: !1,
+          vertexColors: !0,
+          blending: b,
+          sizeAttenuation: !0
+          // 指定点的大小是否因相机深度而衰减
+        })
+      },
+      r
+    ), this.create();
+  }
+  create() {
+    const { range: t, speed: r, dir: n, material: d, num: g, renderOrder: l } = this.config, s = [], o = [], h = [];
+    for (let u = 0; u < g; u++) {
+      s.push(
+        Math.random() * t - t / 2,
+        Math.random() * t - t / 2,
+        Math.random() * t - t / 2
+      );
+      const i = n === "up" ? 1 : -1;
+      h.push(Math.random() * i, (0.1 + Math.random()) * i, 0.1 + Math.random() * i);
+      const a = d.color.clone(), c = {};
+      a.getHSL(c), a.setHSL(c.h, c.s, c.l * Math.random()), o.push(a.r, a.g, a.b);
+    }
+    const e = new x();
+    e.setAttribute("position", new p(new Float32Array(s), 3)), e.setAttribute("velocities", new p(new Float32Array(h), 3)), e.setAttribute("color", new p(new Float32Array(o), 3)), this.instance = new v(e, d), this.instance.name = "Particles", this.instance.renderOrder = l;
+  }
+  static createTexture() {
+    const t = document.createElement("canvas");
+    t.width = 1024, t.height = 1024;
+    const r = t.getContext("2d"), n = r.createRadialGradient(512, 512, 0, 512, 512, 512);
+    return n.addColorStop(0, "rgba(255,255,255,1)"), n.addColorStop(1, "rgba(255,255,255,0)"), r.fillStyle = n, r.fillRect(0, 0, 1024, 1024), new w(t);
+  }
+  update(t, r) {
+    if (!this.instance) return !1;
+    const { range: n, speed: d, dir: g } = this.config, l = g === "up" ? 1 : -1, s = this.instance.geometry.getAttribute("position"), o = this.instance.geometry.getAttribute("velocities"), h = s.count;
+    for (let e = 0; e < h; e++) {
+      let u = s.getX(e);
+      s.getY(e);
+      let i = s.getZ(e);
+      const a = o.getX(e), c = o.getY(e);
+      o.getZ(e), u += Math.sin(a * r) * t, i += d * l, i > n / 2 && l === 1 && (i = -n / 2), i < -n / 2 && l == -1 && (i = n / 2), s.setX(e, u), s.setZ(e, i), o.setX(e, a), o.setY(e, c);
+    }
+    s.needsUpdate = !0, o.needsUpdate = !0;
+  }
+  // 设置父级，并运行
+  setParent(t) {
+    t.add(this.instance), this.time.on("tick", (r, n) => {
+      this.enable && this.update(r, n);
+    });
+  }
+}
+export {
+  f as Particles
+};

package/es/utils/mini3d/components/PathLine.mjs

@@ -0,0 +1,60 @@
+import { isArray as w } from "lodash";
+import { Group as x, MeshBasicMaterial as P, AdditiveBlending as b, Vector3 as l, CatmullRomCurve3 as O, TubeGeometry as j, Mesh as v } from "three";
+class B {
+  constructor({ time: e, geoProjection: d }, s) {
+    this.time = e, this.geoProjection = d, this.instance = new x(), this.instance.name = "PathLine", this.run = !0;
+    const n = {
+      speed: 3e-3,
+      texture: null,
+      radius: 0.1,
+      segments: 32,
+      radialSegments: 8,
+      data: [],
+      renderOrder: 1,
+      material: new P({
+        color: 16777215,
+        transparent: !0,
+        fog: !1,
+        depthTest: !1,
+        blending: b
+      })
+    };
+    this.options = Object.assign({}, n, s), this.init();
+  }
+  // 初始化
+  init() {
+    const { material: e, texture: d, segments: s, radius: n, radialSegments: u, data: f, speed: G, renderOrder: m } = this.options;
+    try {
+      f.map((h) => {
+        const i = [];
+        h.geometry.coordinates.map((a, y) => {
+          y === 0 && (w(a[0][0]) ? a[0].forEach((o) => {
+            const [t, c] = this.geoProjection(o);
+            (t !== void 0 || t !== NaN) && i.push(new l(t, -c, 0));
+          }) : a.forEach((o) => {
+            const [t, c] = this.geoProjection(o);
+            (t !== void 0 || t !== NaN) && i.push(new l(t, -c, 0));
+          }));
+        });
+        const p = new O(i), g = new j(p, s, n, u, !1), r = new v(g, e);
+        r.position.set(0, 0, 0), r.renderOrder = m, this.instance.add(r);
+      });
+    } catch {
+    }
+  }
+  // 获取实例
+  getInstance() {
+    return this.instance;
+  }
+  // 设置父级
+  setParent(e) {
+    e.add(this.instance);
+  }
+  // 设置隐藏显示
+  setVisible(e) {
+    this.instance.visible = e, this.run = e;
+  }
+}
+export {
+  B as PathLine
+};

package/es/utils/mini3d/components/Plane.mjs

@@ -0,0 +1,34 @@
+import { Vector3 as o, MeshBasicMaterial as n, PlaneGeometry as a, Mesh as h } from "three";
+class r {
+  constructor({ time: s }, e) {
+    this.time = s, this.options = Object.assign(
+      {},
+      {
+        width: 10,
+        scale: 1,
+        position: new o(0, 0, 0),
+        needRotate: !1,
+        rotateSpeed: 1e-3,
+        material: new n({
+          transparent: !0,
+          opacity: 1,
+          depthTest: !0
+        })
+      },
+      e
+    );
+    const i = new a(this.options.width, this.options.width), t = new h(i, this.options.material);
+    t.rotateX(-Math.PI / 2), t.position.copy(this.options.position), t.scale.set(this.options.scale, this.options.scale, this.options.scale), this.instance = t;
+  }
+  setParent(s) {
+    s.add(this.instance), this.time.on("tick", () => {
+      this.update();
+    });
+  }
+  update() {
+    this.options.needRotate && (this.instance.rotation.z += this.options.rotateSpeed);
+  }
+}
+export {
+  r as Plane
+};

package/es/utils/mini3d/components/ToastLoading.mjs

@@ -0,0 +1,26 @@
+class i {
+  constructor() {
+    this.toastNode = null, this.init();
+  }
+  init() {
+    if (this.toastNode)
+      return !1;
+    this.toastNode = document.createElement("div"), this.toastNode.classList.add("fixed-loading"), this.toastNode.id = "fixed-loading", this.toastNode.innerHTML = `
+    <div class="page-loading-container">
+      <div class="page-loading"></div>
+    </div>
+  `, this.toastNode.style.visibility = "hidden", document.body.appendChild(this.toastNode);
+  }
+  show() {
+    this.toastNode.style.visibility = "visible";
+  }
+  hide() {
+    this.toastNode && (this.toastNode.style.visibility = "hidden");
+  }
+  destroy() {
+    this.toastNode && document.body.removeChild(this.toastNode);
+  }
+}
+export {
+  i as ToastLoading
+};

package/es/utils/mini3d/core/Camera.mjs

@@ -0,0 +1,26 @@
+import { PerspectiveCamera as i } from "three";
+import { OrbitControls as o } from "three/examples/jsm/controls/OrbitControls";
+class l {
+  constructor({ sizes: s, scene: t, canvas: e }, n = {}) {
+    this.sizes = s, this.scene = t, this.canvas = e, this.option = n, this.setInstance(), this.setControls(this.option.orbitControls);
+  }
+  setInstance() {
+    const s = this.sizes.width / this.sizes.height;
+    this.instance = new i(45, s, 0.1, 2e3), this.instance.position.set(10, 10, 10), this.scene.add(this.instance);
+  }
+  setControls(s) {
+    this.controls || (this.controls = new o(this.instance, this.canvas)), this.controls && (s === void 0 ? (this.controls.enableZoom = !0, this.controls.minDistance = 50, this.controls.maxDistance = 300, this.controls.zoomSpeed = 1, this.controls.enablePan = !0, this.controls.panSpeed = 1, this.controls.minPolarAngle = 0 * Math.PI / 180, this.controls.maxPolarAngle = 75 * Math.PI / 180, this.controls.enableDamping = !0) : (this.controls.enableZoom = s.enableZoom, this.controls.minDistance = s.minDistance, this.controls.maxDistance = s.maxDistance, this.controls.zoomSpeed = s.zoomSpeed, this.controls.enablePan = s.enablePan, this.controls.panSpeed = s.panSpeed, this.controls.minPolarAngle = s.minPolarAngle * Math.PI / 180, this.controls.maxPolarAngle = s.maxPolarAngle * Math.PI / 180, this.controls.enableDamping = s.enableDamping), this.controls.update());
+  }
+  resize() {
+    this.instance.aspect = this.sizes.width / this.sizes.height, this.instance.updateProjectionMatrix();
+  }
+  update() {
+    this.controls.update();
+  }
+  destroy() {
+    this.controls.dispose();
+  }
+}
+export {
+  l as Camera
+};

package/es/utils/mini3d/core/Renderer.mjs

@@ -0,0 +1,25 @@
+import { WebGLRenderer as a } from "three";
+class o {
+  constructor({ canvas: s, sizes: e, scene: i, camera: t, postprocessing: n, composer: h }) {
+    this.canvas = s, this.sizes = e, this.scene = i, this.camera = t, this.postprocessing = n, this.composer = h, this.setInstance();
+  }
+  setInstance() {
+    this.instance = new a({
+      alpha: !0,
+      antialias: !0,
+      canvas: this.canvas
+    }), this.instance.setSize(this.sizes.width, this.sizes.height), this.instance.setPixelRatio(this.sizes.pixelRatio);
+  }
+  resize() {
+    this.instance.setSize(this.sizes.width, this.sizes.height), this.instance.setPixelRatio(this.sizes.pixelRatio);
+  }
+  update() {
+    this.postprocessing && this.composer ? this.composer.render() : this.instance.render(this.scene, this.camera.instance);
+  }
+  destroy() {
+    this.instance.dispose(), this.instance.forceContextLoss();
+  }
+}
+export {
+  o as Renderer
+};

package/es/utils/mini3d/core/index.d.ts

@@ -0,0 +1,7 @@
+export declare class Mini3d {
+    // Add type declarations for Mini3d class members here
+    // For example:
+    // SomeProperty: number;
+    // SomeMethod(param: string): void;
+    scene: any
+}

package/es/utils/mini3d/core/index.mjs

@@ -0,0 +1,71 @@
+var c = Object.defineProperty;
+var h = (i, r, e) => r in i ? c(i, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[r] = e;
+var n = (i, r, e) => h(i, typeof r != "symbol" ? r + "" : r, e);
+import { Scene as m, AxesHelper as d, Mesh as p } from "three";
+import { geoMercator as f } from "d3-geo";
+import { Renderer as g } from "./Renderer.mjs";
+import { Camera as l } from "./Camera.mjs";
+import { EventEmitter as u } from "../utils/EventEmitter.mjs";
+import { Sizes as y } from "../utils/Sizes.mjs";
+import { Time as j } from "../utils/Time.mjs";
+import "three/examples/jsm/loaders/GLTFLoader";
+import "three/examples/jsm/loaders/DRACOLoader.js";
+class A extends u {
+  constructor(e, t = {}, s = {}) {
+    super();
+    n(this, "geoProjection", (e) => {
+      const { geoProjectionCenter: t, geoProjectionScale: s, geoProjectionTranslate: o } = this.config;
+      return f().center(t).scale(s).translate(o)(e);
+    });
+    this.canvas = e, this.scene = new m(), this.sizes = new y(this), this.time = new j(this), this.camera = new l(this, s), this.renderer = new g(this);
+    const o = {
+      geoProjectionCenter: [0, 0],
+      geoProjectionScale: 120,
+      geoProjectionTranslate: [0, 0]
+    };
+    this.config = Object.assign({}, o, t), this.sizes.on("resize", () => {
+      this.resize();
+    }), this.time.on("tick", (a) => {
+      this.update(a);
+    });
+  }
+  setCss3dVisible(e, t) {
+    e && (this[e].visible = t, this[e].children.map((s) => {
+      t ? s.show() : s.hide();
+    }));
+  }
+  /**
+  * 设置AxesHelper
+  * @param {*} size 尺寸
+  * @returns
+  */
+  setAxesHelper(e = 250) {
+    if (!e)
+      return !1;
+    const t = new d(e);
+    this.scene.add(t);
+  }
+  resize() {
+    this.camera.resize(), this.renderer.resize();
+  }
+  update(e) {
+    this.camera.update(e), this.renderer.update(e);
+  }
+  destroy() {
+    try {
+      this.sizes.destroy(), this.time.destroy(), this.camera.destroy(), this.renderer.destroy(), this.scene.traverse((e) => {
+        if (e instanceof p) {
+          e.geometry.dispose();
+          for (const t in e.material) {
+            const s = e.material[t];
+            s && typeof s.dispose == "function" && s.dispose();
+          }
+        }
+      }), this.canvas.parentNode.removeChild(this.canvas);
+    } catch {
+    }
+  }
+}
+export {
+  A as Mini3d
+};

package/es/utils/mini3d/utils/CreateHistory.mjs

@@ -0,0 +1,32 @@
+class h {
+  constructor() {
+    this.past = [], this.future = [], this.present = void 0;
+  }
+  gotoState(t) {
+    const s = [...this.past, this.present, ...this.future];
+    this.present = s[t], this.past = s.slice(0, t), this.future = s.slice(t + 1, s.length);
+  }
+  // 获取当前状态index
+  getIndex() {
+    return this.past.length;
+  }
+  // 保存当前状态
+  push(t) {
+    this.present && this.past.push(this.present), this.present = t;
+  }
+  // 后退
+  undo() {
+    this.past.length !== 0 && this.gotoState(this.getIndex() - 1);
+  }
+  // 前进
+  redo() {
+    this.future.length !== 0 && this.gotoState(this.getIndex() + 1);
+  }
+  // 清空
+  empty() {
+    this.past = [], this.future = [], this.present = void 0;
+  }
+}
+export {
+  h as createHistory
+};

package/es/utils/mini3d/utils/EventEmitter.mjs

@@ -0,0 +1,28 @@
+class c {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  on(t, s) {
+    let e = this.events.get(t);
+    e || (e = /* @__PURE__ */ new Set(), this.events.set(t, e)), e.add(s);
+  }
+  off(t, s) {
+    const e = this.events.get(t);
+    e && (s ? e.delete(s) : this.events.delete(t));
+  }
+  emit(t, ...s) {
+    const e = this.events.get(t);
+    e && e.forEach((i) => {
+      i(...s);
+    });
+  }
+  once(t, s) {
+    const e = (...i) => {
+      s(...i), this.off(t, e);
+    };
+    this.on(t, e);
+  }
+}
+export {
+  c as EventEmitter
+};

package/es/utils/mini3d/utils/Resource.mjs

@@ -0,0 +1,113 @@
+import { TextureLoader as d, Loader as h } from "three";
+import { GLTFLoader as c } from "three/examples/jsm/loaders/GLTFLoader";
+import "three/examples/jsm/loaders/DRACOLoader.js";
+import { EventEmitter as l } from "./EventEmitter.mjs";
+const n = {
+  GLTFLoader: "GLTF",
+  TextureLoader: "Texture",
+  FontLoader: "Font",
+  MMDLoader: "MMD",
+  MTLLoader: "MTL",
+  OBJLoader: "OBJ",
+  PCDLoader: "PCD",
+  FileLoader: "File",
+  ImageLoader: "Image",
+  ObjectLoader: "Object",
+  MaterialLoader: "Material",
+  CubeTextureLoader: "CubeTexture",
+  RGBELoader: "RGBELoader",
+  FBXLoader: "FBX"
+}, u = Object.values(n);
+class y extends l {
+  constructor({ dracoPath: e } = {}) {
+    super(), this.itemsLoaded = 0, this.itemsTotal = 0, this.assets = [], this.loaders = {}, this.initDefaultLoader();
+  }
+  /**
+  * 默认加载GLTFLoader, TextureLoader
+  */
+  initDefaultLoader() {
+    [
+      { loader: c, name: "GLTFLoader" },
+      { loader: d, name: "TextureLoader" }
+    ].map((e) => this.addLoader(e.loader, e.name));
+  }
+  addLoader(e, t = "") {
+    if (e.name && n[t]) {
+      if (!this.loaders[t]) {
+        const o = new e(this.manager), a = t;
+        o instanceof h && (this.loaders[n[a]] = o);
+      }
+    } else
+      throw new Error("请配置正确的加载器");
+  }
+  loadItem(e) {
+    return new Promise((t, r) => {
+      if (!this.loaders[e.type])
+        throw new Error(`资源${e.path}没有配置加载器`);
+      this.loaders[e.type].load(
+        e.path,
+        (o) => {
+          this.itemsLoaded++, this.emit("onProgress", e.path, this.itemsLoaded, this.itemsTotal), t({ ...e, data: o });
+        },
+        null,
+        (o) => {
+          this.emit("onError", o), t({ ...e, data: null });
+        }
+      );
+    });
+  }
+  loadAll(e) {
+    return this.itemsLoaded = 0, this.itemsTotal = 0, new Promise((t, r) => {
+      const o = this.matchType(e), a = [];
+      this.itemsTotal = o.length, o.map((s) => {
+        try {
+          const i = this.loadItem(s);
+          a.push(i);
+        } catch {
+        }
+      }), Promise.all(a).then((s) => {
+        this.assets = s, this.emit("onLoad"), t(s);
+      }).catch((s) => {
+        this.emit("onError", s), r(s);
+      });
+    });
+  }
+  matchType(e) {
+    return this.assets = e.map((t) => ({
+      type: u.includes(t.type) ? t.type : "",
+      path: t.path,
+      name: t.name,
+      data: null
+    })).filter((t) => {
+      if (!t.type)
+        throw new Error(`资源${t.path},type不正确`);
+      return t.type;
+    }), this.assets;
+  }
+  getResource(e) {
+    const t = this.assets.find((r) => r.name === e);
+    if (!t)
+      throw new Error(`资源${e}不存在`);
+    return t.data;
+  }
+  getResource3(e) {
+    const t = this.assets.find((r) => r.name === e);
+    if (!t)
+      throw new Error(`资源${e}不存在`);
+    return t;
+  }
+  getResource2(e, t) {
+    const r = this.assets.find((o) => o.name === e);
+    if (!r)
+      throw new Error(`资源${e}不存在`);
+    return t !== void 0 && r.path !== t && this.loadItem({ type: r.type, name: r.name, path: t }).then((o) => {
+      r.data = o;
+    }), r.data;
+  }
+  destroy() {
+    this.off("onProgress"), this.off("onLoad"), this.off("onError"), this.assets = [];
+  }
+}
+export {
+  y as Resource
+};

package/es/utils/mini3d/utils/Sizes.mjs

@@ -0,0 +1,17 @@
+import { EventEmitter as t } from "./EventEmitter.mjs";
+class h extends t {
+  constructor({ canvas: i }) {
+    super(), this.canvas = i, this.pixelRatio = 0, this.init(), window.addEventListener("resize", () => {
+      this.init(), this.emit("resize");
+    });
+  }
+  init() {
+    this.width = this.canvas.offsetWidth, this.height = this.canvas.offsetHeight, this.pixelRatio = this.pixelRatio || Math.min(window.devicePixelRatio, 2);
+  }
+  destroy() {
+    this.off("resize");
+  }
+}
+export {
+  h as Sizes
+};

package/es/utils/mini3d/utils/Time.mjs

@@ -0,0 +1,25 @@
+import * as s from "three";
+import { EventEmitter as r } from "./EventEmitter.mjs";
+class n extends r {
+  constructor() {
+    super(), this.start = Date.now(), this.current = this.start, this.elapsed = 0, this.delta = 16, this.clock = new s.Clock(), this.timer = window.requestAnimationFrame(() => {
+      this.tick();
+    });
+  }
+  tick() {
+    const t = Date.now();
+    this.delta = t - this.current, this.current = t, this.elapsed = this.current - this.start;
+    const i = this.clock.getDelta(), e = this.clock.getElapsedTime();
+    if (this.emit("tick", i, e), this.stop)
+      return window.cancelAnimationFrame(this.timer), !1;
+    this.timer = window.requestAnimationFrame(() => {
+      this.tick();
+    });
+  }
+  destroy() {
+    this.stop = !0, this.off("tick");
+  }
+}
+export {
+  n as Time
+};

package/es/utils/mini3d/utils/utils.mjs

@@ -0,0 +1,45 @@
+import { Vector3 as m, Box3 as a } from "three";
+function u(r = 10, o = 62) {
+  const n = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split(""), t = [];
+  let e;
+  if (o = o || n.length, r)
+    for (e = 0; e < r; e++) t[e] = n[0 | Math.random() * o];
+  else {
+    let s;
+    for (t[8] = t[13] = t[18] = t[23] = "-", t[14] = "4", e = 0; e < 36; e++)
+      t[e] || (s = 0 | Math.random() * 16, t[e] = n[e == 19 ? s & 3 | 8 : s]);
+  }
+  return t.join("");
+}
+function y(r) {
+  const o = new m(), n = new a();
+  n.expandByObject(r);
+  const t = new m();
+  n.getSize(t);
+  const e = new m();
+  n.getCenter(e);
+  const s = {
+    box3: n,
+    boxSize: t,
+    center: e
+  };
+  if (r.geometry) {
+    r.geometry.computeBoundingBox(), r.geometry.computeBoundingSphere();
+    const { max: c, min: i } = r.geometry.boundingBox;
+    o.x = c.x - i.x, o.y = c.y - i.y, o.z = c.z - i.z, s.size = o;
+  }
+  return s;
+}
+const g = (r) => {
+  const o = JSON.parse(r), n = o.features;
+  for (let t = 0; t < n.length; t++) {
+    const e = n[t];
+    e.geometry.type === "Polygon" && (e.geometry.coordinates = [e.geometry.coordinates]);
+  }
+  return o;
+};
+export {
+  y as getBoundBox,
+  g as transfromMapGeoJSON,
+  u as uuid
+};

package/es/utils/parseDataset.d.ts

@@ -0,0 +1,4 @@
+export declare const parseDataset: (keyData: any[], dimensionsData?: string[]) => {
+    dimensions: string[];
+    source: unknown[];
+};

package/es/utils/parseDataset.mjs

@@ -0,0 +1,19 @@
+import { isArray as n, cloneDeep as u } from "lodash";
+const y = (o, l) => {
+  const e = {};
+  n(o) ? o.forEach((t) => {
+    const a = t.key;
+    n(t.data) && t.data.forEach((r) => {
+      const s = r.category, c = r.value;
+      e[s] || (e[s] = { category: s }), e[s][a] ? e[s][a] += c : e[s][a] = c;
+    });
+  }) : e.key = {};
+  const f = Object.values(e);
+  return {
+    dimensions: l || Object.keys(f[0]),
+    source: Object.values(u(e))
+  };
+};
+export {
+  y as parseDataset
+};

package/es/utils/parseOtherData.d.ts

@@ -0,0 +1 @@
+export declare const parseOtherData: (keyData: any[], basicOption: any) => any;

package/es/utils/parseOtherData.mjs

@@ -0,0 +1,10 @@
+import { cloneDeep as e, isArray as i } from "lodash";
+const f = (r, t) => {
+  const s = e(t);
+  return r && i(r) && r.forEach((p, o) => {
+    r[o] ? s.series[o].data = r[o].data : s.series[o].data = [];
+  }), s;
+};
+export {
+  f as parseOtherData
+};

package/es/utils/shj/component-refs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 注册组件Ref
+ * @param layerId
+ * @returns
+ */
+export declare const registerComponentRef: (layerId: string) => (el: any) => void;

package/es/utils/shj/component-refs.mjs

@@ -0,0 +1,10 @@
+import { isArray as i } from "lodash";
+const s = (n) => (o) => {
+  if (window.SHJComponentRefs && i(window.SHJComponentRefs) && o && n) {
+    const e = window.SHJComponentRefs.find((f) => f.layerId === n);
+    e ? e.ref = o : window.SHJComponentRefs.push({ layerId: n, ref: o });
+  }
+};
+export {
+  s as registerComponentRef
+};

package/es/utils/typescript.d.ts

@@ -0,0 +1,5 @@
+import type { AppContext, Plugin } from 'vue';
+export type SFCWithInstall<T> = T & Plugin;
+export type SFCInstallWithContext<T> = SFCWithInstall<T> & {
+    _context: AppContext | null;
+};

package/lib/_virtual/_plugin-vue_export-helper.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const u=(e,o)=>{const t=e.__vccOpts||e;for(const[r,s]of o)t[r]=s;return t};exports.default=u;

package/lib/components/chart-bar-basic/index.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const t=require("./index.vue.js"),r=require("../../utils/install.js"),e=r.withInstall(t.default);exports.ZvChartBarBasic=e;exports.default=e;