@shjjs/visual-ui 1.0.13 → 1.0.15

package/es/commons/core/earth/utils/interface.d.ts

@@ -0,0 +1,134 @@
+import * as THREE from 'three';
+export interface BorderParameter {
+    color: number | undefined;
+    lineWidth: number;
+    opacity: number;
+    wakeline?: boolean;
+    wakelineNumber?: number;
+    wakelineColors?: Array<string>;
+}
+export interface SceneParameter {
+    isBackground: boolean;
+    background: string;
+    fog: boolean;
+    fogColor: string;
+    fogNear: number;
+    fogFar: number;
+    stats: boolean;
+    statsType: number;
+}
+export interface AmbientLightParameter {
+    color: string;
+    intensity?: number;
+}
+export interface DirectionalLightParameter {
+    x: number;
+    y: number;
+    z: number;
+    color: string;
+    intensity?: number;
+}
+export interface GridHelperParameter {
+    show: boolean;
+    width: number;
+    height: number;
+    color: string;
+}
+export interface AxesHelperParameter {
+    show: boolean;
+    size: number;
+}
+export interface SceneInterface {
+    /**
+     * Camera 场景
+     * @default null
+     */
+    scene: THREE.Scene;
+    /**
+     * Camera 相机
+     * @default null
+     */
+    camera: THREE.Camera;
+    /**
+     * Camera WebGL渲染器
+     * @default null
+     */
+    webGlRenderer: THREE.WebGLRenderer;
+    /**
+     * stats 性能监听器
+     * @default null
+     */
+    stats: any;
+    /**
+     * 创建场景
+     * @param sceneParameter 场景参数
+     * @returns 场景
+     */
+    createScene(sceneParameter: SceneParameter): THREE.Scene;
+    /**
+     * 创建相机
+     * @param element 容器
+     * @returns 相机
+     */
+    createCamera(element: HTMLElement): THREE.Camera;
+    /**
+     * 创建WebGL渲染器
+     * @param element 容器
+     * @returns WebGL渲染器
+     */
+    createWebGLRenderer(element: HTMLElement): THREE.WebGLRenderer;
+    /**
+     * 创建环境光
+     * @param option 参数
+     * @returns 环境光
+     */
+    createAmbientLight(option: AmbientLightParameter): THREE.AmbientLight;
+    /**
+     * 创建平行光
+     * @param option 参数
+     * @returns 平行光
+     */
+    createDirectionalLight(option: DirectionalLightParameter): THREE.DirectionalLight;
+    /**
+     * 创建Grid辅助线
+     * @returns GridHelper
+     */
+    createGridHelper(option: GridHelperParameter): THREE.GridHelper;
+    /**
+     * 创建Axes辅助线
+     * @returns AxesHelper
+     */
+    createAxesHelper(option: AxesHelperParameter): THREE.AxesHelper;
+    /**
+     * 创建性能监测器
+     * @param sceneParameter 场景参数
+     */
+    createStats(sceneParameter: SceneParameter): any;
+    /**
+     * 添加物体
+     * @param object Object3D
+     * @returns void
+     */
+    add(...object: THREE.Object3D[] | undefined): void;
+    /**
+     * 重置大小
+     * @returns void
+     */
+    resize(): void;
+    /**
+     * 渲染器
+     * @returns void
+     */
+    render(): void;
+    /**
+     * 销毁实例
+     * @returns void
+     */
+    dispose(): void;
+    /**
+     * 容器发生改变时
+     * @param element
+     * @returns void
+     */
+    onWindowResize(element: HTMLElement): void;
+}

package/es/commons/core/earth/utils/label.d.ts

@@ -0,0 +1,4 @@
+import { CSS2DRenderer, CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer';
+declare function tag2D(name: any): CSS2DObject;
+declare function labelRenderer(container: any): CSS2DRenderer;
+export { tag2D, labelRenderer };

package/es/commons/core/earth/utils/label.mjs

@@ -0,0 +1,15 @@
+import { CSS2DObject as o, CSS2DRenderer as s } from "three/examples/jsm/renderers/CSS2DRenderer";
+function d(t) {
+  const e = document.createElement("div");
+  e.innerHTML = t, e.classList.add("tag");
+  const n = new o(e);
+  return e.style.pointerEvents = "none", n;
+}
+function r(t) {
+  const e = new s();
+  return e.setSize(t.offsetWidth, t.offsetHeight), e.domElement.style.position = "absolute", e.domElement.style.top = "0px", e.domElement.style.left = "0px", e.domElement.style.pointerEvents = "none", t.appendChild(e.domElement), e;
+}
+export {
+  r as labelRenderer,
+  d as tag2D
+};

package/es/commons/core/earth/utils/line2.d.ts

@@ -0,0 +1,3 @@
+import { Line2 } from 'three/examples/jsm/lines/Line2';
+import { BorderParameter } from './interface';
+export declare const DrawLine: (lines: any, option: BorderParameter) => Line2;

package/es/commons/core/earth/utils/line2.mjs

@@ -0,0 +1,21 @@
+import { Line2 as s } from "three/examples/jsm/lines/Line2";
+import { LineGeometry as c } from "three/examples/jsm/lines/LineGeometry";
+import { LineMaterial as m } from "three/examples/jsm/lines/LineMaterial";
+const u = (o, e) => {
+  const r = [];
+  o.forEach(({ x: n, y: a, z: l }) => r.push(n, a, l));
+  const t = new c();
+  t.setPositions(r);
+  const i = new m({
+    transparent: !0,
+    color: e.color,
+    linewidth: e.lineWidth * 0.01,
+    opacity: e.opacity,
+    worldUnits: !0,
+    alphaToCoverage: !0
+  });
+  return new s(t, i);
+};
+export {
+  u as DrawLine
+};

package/es/commons/core/earth/utils/scene.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from 'three';
+import { CSS2DRenderer } from 'three/examples/jsm/renderers/CSS2DRenderer';
+import { SceneInterface, SceneParameter, AmbientLightParameter, GridHelperParameter, AxesHelperParameter, DirectionalLightParameter } from './interface';
+export declare class Scene implements SceneInterface {
+    stats: any;
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera;
+    webGlRenderer: THREE.WebGLRenderer;
+    labelRenderer: CSS2DRenderer;
+    element: HTMLElement;
+    animationFrameId: number;
+    textures: any;
+    constructor(element: HTMLElement, sceneParameter: SceneParameter);
+    createScene(sceneParameter: SceneParameter): THREE.Scene;
+    createCamera(element: HTMLElement): THREE.PerspectiveCamera;
+    createWebGLRenderer(element: HTMLElement): THREE.WebGLRenderer;
+    createAmbientLight(option: AmbientLightParameter): THREE.AmbientLight;
+    createDirectionalLight(option: DirectionalLightParameter): THREE.DirectionalLight;
+    createGridHelper(option: GridHelperParameter): THREE.GridHelper | undefined;
+    createAxesHelper(option: AxesHelperParameter): THREE.AxesHelper | undefined;
+    createStats(sceneParameter: SceneParameter): any;
+    resize(): void;
+    render(): void;
+    add(...object: THREE.Object3D[] | undefined): void;
+    dispose(): void;
+    onWindowResize(element: HTMLElement): void;
+    loadTextures(texturePaths: any, callback: any): void;
+}

package/es/commons/core/earth/utils/scene.mjs

@@ -0,0 +1,120 @@
+var d = Object.defineProperty;
+var c = (s, e, t) => e in s ? d(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var i = (s, e, t) => c(s, typeof e != "symbol" ? e + "" : e, t);
+import * as r from "three";
+import f from "stats.js";
+import { labelRenderer as m } from "./label.mjs";
+class b {
+  constructor(e, t) {
+    i(this, "stats");
+    i(this, "scene");
+    i(this, "camera");
+    i(this, "webGlRenderer");
+    i(this, "labelRenderer");
+    i(this, "element");
+    i(this, "animationFrameId", 0);
+    i(this, "textures", {});
+    this.element = e, this.scene = this.createScene(t), this.stats = this.createStats(t), this.camera = this.createCamera(this.element), this.webGlRenderer = this.createWebGLRenderer(this.element), window.addEventListener("resize", () => this.onWindowResize(this.element));
+  }
+  createScene(e) {
+    const t = new r.Scene();
+    return e.isBackground ? t.background = new r.Color(e.background) : t.background = null, e.fog && (t.fog = new r.Fog(e.fogColor, e.fogNear, e.fogFar)), t;
+  }
+  createCamera(e) {
+    const t = new r.PerspectiveCamera(45, e.offsetWidth / e.offsetHeight, 0.1, 1e4);
+    return t.position.set(10, 10, 10), t.lookAt(0, 0, 0), t;
+  }
+  createWebGLRenderer(e) {
+    const t = new r.WebGLRenderer({
+      preserveDrawingBuffer: !0,
+      // 开启缓冲区保护
+      antialias: !0,
+      alpha: !0
+    });
+    return t.setClearAlpha(0), t.setPixelRatio(window.devicePixelRatio), t.autoClear = !1, t.clearColor(), t.setSize(e.offsetWidth, e.offsetHeight), e.appendChild(t.domElement), this.labelRenderer = m(e), t;
+  }
+  createAmbientLight(e) {
+    return new r.AmbientLight(
+      new r.Color(e.color),
+      e.intensity
+    );
+  }
+  createDirectionalLight(e) {
+    const t = new r.DirectionalLight(
+      new r.Color(e.color),
+      e.intensity
+    );
+    return t.position.set(
+      e.x,
+      e.y,
+      e.z
+    ), t.lookAt(0, 0, 0), t;
+  }
+  createGridHelper(e) {
+    if (e.show)
+      return new r.GridHelper(
+        e.width,
+        e.height,
+        new r.Color(e.color),
+        new r.Color(e.color)
+      );
+  }
+  createAxesHelper(e) {
+    if (e.show)
+      return new r.AxesHelper(e.size);
+  }
+  createStats(e) {
+    if (e.stats) {
+      const t = new f();
+      return t.domElement.style.position = "absolute", t.domElement.style.top = "5px", t.domElement.style.left = "5px", t.showPanel(e.statsType), this.element.appendChild(t.dom), t;
+    }
+    return null;
+  }
+  resize() {
+    this.webGlRenderer.setSize(this.element.offsetWidth, this.element.offsetHeight), this.camera.aspect = this.element.offsetWidth / this.element.offsetHeight, this.camera.updateProjectionMatrix();
+  }
+  render() {
+    this.animationFrameId = requestAnimationFrame(() => {
+      this.stats && this.stats.update(), this.render(), this.webGlRenderer.clear(), this.webGlRenderer.render(this.scene, this.camera);
+    });
+  }
+  add(...e) {
+    e.forEach((t) => {
+      t && this.scene.add(t);
+    });
+  }
+  dispose() {
+    try {
+      cancelAnimationFrame(this.animationFrameId), this.element.innerHTML = "", this.camera.clear(), this.webGlRenderer.forceContextLoss(), this.webGlRenderer.dispose(), this.scene.clear();
+    } catch {
+    }
+  }
+  onWindowResize(e) {
+    const t = e.offsetWidth, o = e.offsetHeight;
+    this.webGlRenderer.setSize(t, o), this.camera.aspect = t / o, this.camera.updateProjectionMatrix();
+  }
+  loadTextures(e, t) {
+    const o = new r.TextureLoader();
+    let n = 0;
+    const a = () => {
+      if (n < e.length) {
+        const l = e[n].value;
+        l ? o.load(
+          l,
+          (h) => {
+            this.textures[e[n].key] = h, n++, a();
+          },
+          void 0,
+          function(h) {
+            n++, a();
+          }
+        ) : (n++, a());
+      } else
+        t(this.textures);
+    };
+    a();
+  }
+}
+export {
+  b as Scene
+};

package/es/commons/core/useChart.d.ts

@@ -0,0 +1,15 @@
+import * as echarts from 'echarts';
+export interface IUseChart {
+    basicOption: any;
+    useEvents: any[];
+    customRenderData: Function;
+    emit: any;
+}
+export declare const useChart: ({ basicOption, useEvents, customRenderData, emit }: IUseChart) => {
+    id: string;
+    status: import("vue").Ref<boolean>;
+    chart: import("vue").ShallowRef<echarts.ECharts>;
+    setOption: (optionParams: any, type?: any) => void;
+    renderChart: import("lodash").DebouncedFunc<(option: echarts.EChartsOption) => void>;
+    renderData: Function;
+};

package/es/commons/core/useChart.mjs

@@ -0,0 +1,115 @@
+import { ref as m, shallowRef as L, onMounted as P, onBeforeUnmount as Z } from "vue";
+import { useResizeObserver as I } from "@vueuse/core";
+import { debounce as O, cloneDeep as S, isArray as n } from "lodash";
+import b from "is-electron";
+import * as f from "echarts";
+import { nanoid as k } from "nanoid";
+import { HoverLoop as V } from "../utils/hoverLoop.mjs";
+import "echarts-wordcloud";
+import "echarts-liquidfill";
+const D = (l) => {
+  const e = [];
+  l.geo && (n(l.geo) ? e.push(...l.geo.map((r) => r.map)) : e.push(l.geo.map)), l.series && n(l.series) && l.series.forEach((r) => {
+    r.map && e.push(r.map);
+  });
+  const d = e.map((r) => {
+    if (r === "customize")
+      if (n(l.geo)) {
+        const c = JSON.parse(l.geo.find((h) => h.map === "customize").geoData);
+        return f.registerMap(r, c);
+      } else {
+        const c = JSON.parse(l.geo.geoData);
+        return f.registerMap(r, c);
+      }
+    else
+      return fetch((b() ? "gismap/" : "/gismap/") + r + ".json").then((c) => c.json()).then((c) => {
+        f.registerMap(r, c);
+      }).catch((c) => {
+      });
+  });
+  return Promise.all(d);
+}, M = async (l) => {
+  l.bmap && await import(
+    /* @vite-ignore */
+    "echarts/extension/bmap/bmap"
+  );
+}, A = ({ basicOption: l, useEvents: e, customRenderData: d, emit: r }) => {
+  const c = k(), h = m(!0), t = L(null), v = d, u = m(null), i = m(null), y = (s, g) => {
+    try {
+      t.value || (t.value = f.init(document.getElementById(c), null, { renderer: g || "svg" }));
+      const o = S(s);
+      if (o) {
+        if (t.value.setOption(o, !0), o.hoverLoop)
+          if (i.value && clearInterval(i.value), u.value && u.value.closeSwitchTooltip(), o.hoverLoop.type === "方式二") {
+            let a = 0;
+            o.dataset && o.dataset.source && (a = o.dataset.source.length), o.series[0] && o.series[0].data && (a = o.series[0].data.length);
+            const J = o.dataZoom[0].endValue, H = o.dataZoom[0].startValue, w = () => {
+              i.value = setInterval(() => {
+                o.dataZoom[0].endValue > a - 2 ? (o.dataZoom[0].endValue = J, o.dataZoom[0].startValue = H) : (o.dataZoom[0].endValue = o.dataZoom[0].endValue + 1, o.dataZoom[0].startValue = o.dataZoom[0].startValue + 1), t.value.setOption(o);
+              }, o.hoverLoop.delay2);
+            };
+            t.value.on("mousemove", function() {
+              i.value && clearInterval(i.value);
+            }), t.value.on("mouseout", function() {
+              i.value && clearInterval(i.value), w();
+            }), w();
+          } else o.hoverLoop.type === "方式一" && (t.value.on("mousemove", function() {
+            u.value && u.value.closeSwitchTooltip();
+          }), t.value.on("mouseout", function() {
+            u.value && u.value.closeSwitchTooltip(), u.value = new V(t.value, o);
+          }), u.value = new V(t.value, o));
+        else
+          i.value && clearInterval(i.value), u.value && u.value.closeSwitchTooltip();
+        t.value.on("click", (a) => {
+          e && n(e) && e.length > 0 && (r("chart-click", a), window.SHJParseEvent(e, "chart-click", a));
+        }), t.value.on("dblclick", (a) => {
+          e && n(e) && e.length > 0 && (r("chart-dblclick", a), window.SHJParseEvent(e, "chart-dblclick", a));
+        }), t.value.on("mousedown", (a) => {
+          e && n(e) && e.length > 0 && (r("chart-mousedown", a), window.SHJParseEvent(e, "chart-mousedown", a));
+        }), t.value.on("mouseup", (a) => {
+          e && n(e) && e.length > 0 && (r("chart-mouseup", a), window.SHJParseEvent(e, "chart-mouseup", a));
+        }), t.value.on("mouseover", (a) => {
+          e && n(e) && e.length > 0 && (r("chart-mouseover", a), window.SHJParseEvent(e, "chart-mouseover", a));
+        }), t.value.on("mouseout", (a) => {
+          e && n(e) && e.length > 0 && (r("chart-mouseout", a), window.SHJParseEvent(e, "chart-mouseout", a));
+        }), t.value.on("contextmenu", (a) => {
+          e && n(e) && e.length > 0 && (r("chart-contextmenu", a), window.SHJParseEvent(e, "chart-contextmenu", a));
+        }), h.value = !1;
+      }
+    } catch {
+      try {
+        t.value.dispose();
+      } catch {
+      }
+      t.value = null;
+    }
+  }, p = O((s) => {
+    h.value = !0, s = S(s), D(s).then(() => {
+      M(s).then(() => {
+        v(s);
+      });
+    }).catch((g) => {
+    });
+  }, 100);
+  return P(() => {
+    p(l), I(document.getElementById(c), (s) => {
+      t.value && t.value.resize();
+    });
+  }), Z(() => {
+    u.value && u.value.closeSwitchTooltip(), i.value && clearInterval(i.value);
+    try {
+      t.value && t.value.dispose();
+    } catch {
+    }
+  }), {
+    id: c,
+    status: h,
+    chart: t,
+    setOption: y,
+    renderChart: p,
+    renderData: v
+  };
+};
+export {
+  A as useChart
+};

package/es/commons/utils/babylon/ColorConvert.d.ts

@@ -0,0 +1,3 @@
+import { Color3, Color4 } from '@babylonjs/core';
+export declare const hex2Color3: (colorValue: string, def: Color3) => Color3;
+export declare const hex2Color4: (colorValue: string, def: Color4) => Color4;

package/es/commons/utils/babylon/ColorConvert.mjs

@@ -0,0 +1,21 @@
+import { Color4 as f, Color3 as o } from "@babylonjs/core";
+import { hex2rgb as i } from "@swiftcarrot/color-fns";
+const p = (t, n) => {
+  if (t && t.startsWith("#")) {
+    const { r, g: s, b: e } = i(t);
+    return new o(r / 255, s / 255, e / 255);
+  }
+  return n;
+}, x = (t, n) => {
+  if (t && t.startsWith("#")) {
+    let r = 1;
+    t.length === 9 && (r = parseInt(t.slice(7, 9), 16) / 255);
+    const { r: s, g: e, b: h } = i(t);
+    return new f(s / 255, e / 255, h / 255, r);
+  }
+  return n;
+};
+export {
+  p as hex2Color3,
+  x as hex2Color4
+};

package/es/commons/utils/clickOutSide.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    beforeMount(el: any, binding: any): void;
+    unmounted(el: any): void;
+};
+export default _default;

package/es/commons/utils/clickOutSide.mjs

@@ -0,0 +1,13 @@
+const i = {
+  beforeMount(t, c) {
+    t.clickOutsideEvent = (e) => {
+      t === e.target || t.contains(e.target) || c.value(e);
+    }, document.addEventListener("click", t.clickOutsideEvent);
+  },
+  unmounted(t) {
+    document.removeEventListener("click", t.clickOutsideEvent);
+  }
+};
+export {
+  i as default
+};

package/es/commons/utils/cloneSeries.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 支持多系列`series` 仅支持单series描述单图形的图表，类似基础柱状图
+ * @param data
+ * @param series
+ * @returns
+ */
+export declare const cloneSeries: (data: any[], series: any) => any;

package/es/commons/utils/cloneSeries.mjs

@@ -0,0 +1,12 @@
+import { cloneDeep as c } from "lodash";
+const p = (n, o) => {
+  if (n !== void 0) {
+    const e = n.length - o.length;
+    for (let t = 0; t < e; t++)
+      o.push(c(o[0]));
+  }
+  return o;
+};
+export {
+  p as cloneSeries
+};

package/es/commons/utils/hoverLoop.d.ts

@@ -0,0 +1,10 @@
+export declare class HoverLoop {
+    private myChart;
+    private option;
+    timer: any;
+    currentIndex: number;
+    currentSeriesIndex: number;
+    constructor(myChart: any, option: any);
+    switchTooltip(myChart: any, option: any): void;
+    closeSwitchTooltip(): void;
+}

package/es/commons/utils/hoverLoop.mjs

@@ -0,0 +1,43 @@
+var h = Object.defineProperty;
+var d = (s, t, e) => t in s ? h(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var i = (s, t, e) => d(s, typeof t != "symbol" ? t + "" : t, e);
+class n {
+  constructor(t, e) {
+    i(this, "timer");
+    i(this, "currentIndex", -1);
+    i(this, "currentSeriesIndex", -1);
+    this.myChart = t, this.option = e, this.timer = setInterval(() => {
+      this.switchTooltip(this.myChart, this.option);
+    }, e.hoverLoop.delay);
+  }
+  switchTooltip(t, e) {
+    try {
+      if (e.dataset && e.dataset.source || e.series[0].data) {
+        t.dispatchAction({
+          type: "downplay",
+          seriesIndex: this.currentSeriesIndex,
+          dataIndex: this.currentIndex
+        }), this.currentSeriesIndex = (this.currentSeriesIndex + 1) % e.series.length;
+        let r = 0;
+        e.dataset && e.dataset.source && (r = e.dataset.source.length), e.series[this.currentSeriesIndex] && e.series[this.currentSeriesIndex].data && (r = e.series[this.currentSeriesIndex].data.length), this.currentSeriesIndex === 0 && (this.currentIndex = (this.currentIndex + 1) % r), e.hoverLoop.highlight && t && t.dispatchAction({
+          type: "highlight",
+          seriesIndex: this.currentSeriesIndex,
+          dataIndex: this.currentIndex
+        }), e.hoverLoop.showTip && t && t.dispatchAction({
+          type: "showTip",
+          seriesIndex: this.currentSeriesIndex,
+          dataIndex: this.currentIndex
+        });
+      } else
+        this.closeSwitchTooltip();
+    } catch {
+      this.closeSwitchTooltip();
+    }
+  }
+  closeSwitchTooltip() {
+    clearInterval(this.timer), this.timer = void 0;
+  }
+}
+export {
+  n as HoverLoop
+};

package/es/commons/utils/imgPreloader.d.ts

@@ -0,0 +1 @@
+export declare const imgsPreloader: (imgs: string[]) => Promise<boolean[]>;

package/es/commons/utils/imgPreloader.mjs

@@ -0,0 +1,16 @@
+const t = (e) => new Promise((r, o) => {
+  const n = new Image();
+  n.onload = () => {
+    r(!0);
+  }, n.onerror = (s) => {
+    o(s);
+  }, n.src = e;
+}), a = (e) => {
+  const r = [];
+  return e.forEach((o) => {
+    r.push(t(o));
+  }), Promise.all(r);
+};
+export {
+  a as imgsPreloader
+};

package/es/commons/utils/install.d.ts

@@ -0,0 +1,2 @@
+import type { SFCWithInstall } from './typescript';
+export declare const withInstall: <T, E extends Record<string, any>>(main: T, extra?: E) => SFCWithInstall<T> & E;

package/es/commons/utils/install.mjs

@@ -0,0 +1,7 @@
+const c = (t, n) => (t.install = (e) => {
+  for (const o of [t, ...Object.values({})])
+    e.component(o.name, o);
+}, t);
+export {
+  c as withInstall
+};

package/es/commons/utils/json2css.d.ts

@@ -0,0 +1,3 @@
+export declare function jsonToCssStyle(styleJson: Object, pd?: string): Object;
+export declare function camelCaseToDash(str: any): any;
+export declare const autoInstallFont: (fontFamily: string) => void;

package/es/commons/utils/json2css.mjs

@@ -0,0 +1,31 @@
+import { isObject as i, isNumber as r } from "lodash";
+function d(t, c) {
+  const e = {};
+  for (const s in t)
+    if (!i(t[s])) {
+      const n = a(s);
+      ["fontSize", "width", "height", "borderWidth", "borderRadius", "gap", "-webkit-text-stroke-width", "letterSpacing", "maxHeight", "marginRight"].includes(s) && r(t[s]) ? e[(c ? `--${c}-` : "") + n] = `${t[s]}px` : e[(c ? `--${c}-` : "") + n] = t[s];
+    }
+  return e;
+}
+function a(t) {
+  return t.replace(/([a-zA-Z])(?=[A-Z])/g, "$1-").toLowerCase();
+}
+const h = (t) => {
+  if (t && t.startsWith("SHJ-")) {
+    let c = !1;
+    if (document.fonts.forEach((e) => {
+      e.family === t && (c = !0);
+    }), !c) {
+      const e = t.slice(4, t.lastIndexOf("-")), s = e.slice(0, e.lastIndexOf("-")), n = t.slice(t.lastIndexOf("-") + 1, t.length), o = new FontFace(t, `url(https://lganv-1304359499.cos.ap-beijing.myqcloud.com/lg_cos_static/fonts/${s}/${e}.${n})`);
+      document.fonts.add(o), o.load().then(() => {
+      }).catch(() => {
+      });
+    }
+  }
+};
+export {
+  h as autoInstallFont,
+  a as camelCaseToDash,
+  d as jsonToCssStyle
+};

package/es/commons/utils/parseDataset.d.ts

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