@ued_fpi/data-visual 1.4.29 → 1.4.31

package/dist/lib/wgms/src/runtime/ScreenRenderer.vue.js

@@ -0,0 +1,124 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const index = require('../registry/index.js');
+const adapter = require('./adapter.js');
+
+const _hoisted_1 = {
+  key: 1,
+  class: "dv-wgms-screen-renderer-missing"
+};
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "ScreenRenderer",
+  props: {
+    schema: { default: () => ({ widgets: [] }) }
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const componentRefs = /* @__PURE__ */ new Map();
+    const timerMap = /* @__PURE__ */ new Map();
+    const setWidgetRef = (id, instance) => {
+      if (!instance) {
+        componentRefs.delete(id);
+        return;
+      }
+      componentRefs.set(id, instance);
+    };
+    const clearTimers = () => {
+      timerMap.forEach((timer) => clearInterval(timer));
+      timerMap.clear();
+    };
+    const invokeReload = (widget) => {
+      const refInstance = componentRefs.get(widget.id);
+      const entry = index.getWgmsComponentById(widget.componentId);
+      const methodName = entry?.meta.adapter?.reloadMethod || "reload";
+      const method = refInstance?.[methodName];
+      if (typeof method === "function")
+        method();
+    };
+    const toCssValue = (value) => {
+      if (value === void 0)
+        return void 0;
+      return typeof value === "number" ? `${value}px` : value;
+    };
+    const normalizedWidgets = vue.computed(() => {
+      return (props.schema.widgets || []).map((widget) => {
+        const entry = index.getWgmsComponentById(widget.componentId);
+        const layoutStyle = {
+          ...widget.layout?.style || {}
+        };
+        if (widget.layout) {
+          if (widget.layout.x !== void 0)
+            layoutStyle.left = toCssValue(widget.layout.x) || "";
+          if (widget.layout.y !== void 0)
+            layoutStyle.top = toCssValue(widget.layout.y) || "";
+          if (widget.layout.w !== void 0)
+            layoutStyle.width = toCssValue(widget.layout.w) || "";
+          if (widget.layout.h !== void 0)
+            layoutStyle.height = toCssValue(widget.layout.h) || "";
+        }
+        if ("left" in layoutStyle || "top" in layoutStyle)
+          layoutStyle.position = "absolute";
+        return {
+          id: widget.id,
+          componentId: widget.componentId,
+          component: entry?.component,
+          componentProps: entry ? adapter.adaptStandardProps(entry.meta, widget.props) : widget.props?.componentProps || {},
+          refreshInterval: widget.props?.refreshInterval,
+          layoutStyle
+        };
+      });
+    });
+    const containerStyle = vue.computed(() => {
+      return {
+        position: "relative",
+        width: "100%",
+        height: "100%",
+        ...props.schema.style || {}
+      };
+    });
+    vue.watch(normalizedWidgets, (widgets) => {
+      clearTimers();
+      widgets.forEach((widget) => {
+        if (!widget.refreshInterval || widget.refreshInterval <= 0)
+          return;
+        const timer = setInterval(() => {
+          const rawWidget = props.schema.widgets.find((item) => item.id === widget.id);
+          rawWidget && invokeReload(rawWidget);
+        }, widget.refreshInterval);
+        timerMap.set(widget.id, timer);
+      });
+    }, { immediate: true, deep: true });
+    vue.onBeforeUnmount(() => {
+      clearTimers();
+    });
+    __expose({
+      reload: () => {
+        props.schema.widgets.forEach(invokeReload);
+      }
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: "dv-wgms-screen-renderer",
+        style: vue.normalizeStyle(containerStyle.value)
+      }, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(normalizedWidgets.value, (widget) => {
+          return vue.openBlock(), vue.createElementBlock("div", {
+            key: widget.id,
+            class: "dv-wgms-screen-renderer-item",
+            style: vue.normalizeStyle(widget.layoutStyle)
+          }, [
+            widget.component ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(widget.component), vue.mergeProps({ key: 0 }, widget.componentProps, {
+              ref_for: true,
+              ref: (el) => setWidgetRef(widget.id, el)
+            }), null, 16)) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, " Missing component: " + vue.toDisplayString(widget.componentId), 1))
+          ], 4);
+        }), 128))
+      ], 4);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/wgms/src/runtime/ScreenRenderer.vue2.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+/* unplugin-vue-components disabled */const ScreenRenderer_vue_vue_type_style_index_0_lang = '';
+
+exports.default = ScreenRenderer_vue_vue_type_style_index_0_lang;

package/dist/lib/wgms/src/runtime/ScreenRenderer.vue3.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const ScreenRenderer_vue_vue_type_script_setup_true_lang = require('./ScreenRenderer.vue.js');
+require('./ScreenRenderer.vue2.js');
+
+
+
+exports.default = ScreenRenderer_vue_vue_type_script_setup_true_lang.default;

package/dist/lib/wgms/src/runtime/adapter.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const adaptStandardProps = (meta, input) => {
+  const result = {
+    ...input?.componentProps || {}
+  };
+  if (input?.title !== void 0 && result.title === void 0)
+    result.title = input.title;
+  if (input?.theme !== void 0 && result.theme === void 0)
+    result.theme = input.theme;
+  const adapter = meta.adapter;
+  if (!adapter)
+    return result;
+  const query = {
+    ...input?.dataSource?.params || {},
+    ...input?.query || {}
+  };
+  if (adapter.queryProp && Object.keys(query).length) {
+    const existing = result[adapter.queryProp];
+    result[adapter.queryProp] = {
+      ...typeof existing === "object" && existing ? existing : {},
+      ...query
+    };
+  }
+  const payload = input?.componentData ?? input?.dataSource?.data;
+  if (adapter.dataProp && payload !== void 0)
+    result[adapter.dataProp] = payload;
+  const lazy = input?.lazy ?? input?.dataSource?.lazy;
+  if (adapter.lazyProp && typeof lazy === "boolean")
+    result[adapter.lazyProp] = lazy;
+  return result;
+};
+
+exports.adaptStandardProps = adaptStandardProps;