@duxweb/dvha-pro 1.1.21 → 1.1.22

package/dist/esm/components/spec/spec.js

@@ -1,8 +1,8 @@
-import { defineComponent as K, ref as R, computed as h, watch as j, createVNode as g, mergeProps as P } from "vue";
-import { useI18n as M } from "@duxweb/dvha-core";
-import { useVModel as N } from "@vueuse/core";
+import { defineComponent as k, ref as M, computed as g, watch as N, createVNode as S, mergeProps as R } from "vue";
+import { useI18n as z } from "@duxweb/dvha-core";
+import { useVModel as F } from "@vueuse/core";
 import { NSwitch as O } from "naive-ui";
-import { DuxDynamicData as z } from "../data/dynamicData.js";
+import { DuxDynamicData as I } from "../data/dynamicData.js";
 import "vue-router";
 import "@overlastic/vue";
 import "clsx";
@@ -61,46 +61,46 @@ import "../posterEditor/elements/index.js";
 import "fabric";
 import "../schemaEditor/schemaEditor.js";
 import "dayjs";
-import { DuxSpecEditor as F, createSpecValue as C, createSpec as I } from "./specEditor.js";
+import { DuxSpecEditor as $, createSpecValue as C, createSpec as B } from "./specEditor.js";
 import "@tanstack/vue-query";
 import "pinia";
-const $ = "__dux_spec__", y = (r) => `${$}${r}`;
-function L(r = []) {
-  return (r || []).map((o) => {
-    const i = (o.values?.length ? o.values : [C()]).map((a) => ({
-      ...a,
-      id: a.id || C().id
+const L = "__dux_spec__", _ = (o) => `${L}${o}`;
+function W(o = []) {
+  return (o || []).map((s) => {
+    const u = (s.values?.length ? s.values : [C()]).map((m) => ({
+      ...m,
+      id: m.id || C().id
     }));
     return {
-      ...o,
-      id: o.id || I().id,
-      values: i
+      ...s,
+      id: s.id || B().id,
+      values: u
     };
   });
 }
-function W(r) {
-  if (!r.length)
+function X(o) {
+  if (!o.length)
     return [];
-  let o = [{}];
-  return r.forEach((i) => {
-    const a = [];
-    o.forEach((_) => {
-      i.values.forEach((t) => {
-        a.push({
-          ..._,
-          [i.id]: t
+  let s = [{}];
+  return o.forEach((u) => {
+    const m = [];
+    s.forEach((x) => {
+      u.values.forEach((t) => {
+        m.push({
+          ...x,
+          [u.id]: t
         });
       });
-    }), o = a;
-  }), o.map((i) => ({
-    key: r.map((a) => i[a.id]?.id || "").join("__"),
-    map: i
+    }), s = m;
+  }), s.map((u) => ({
+    key: o.map((m) => u[m.id]?.id || "").join("__"),
+    map: u
   }));
 }
-function X(r, o) {
-  return o.map((i) => r[y(i.id)] || "").join("__");
+function q(o, s) {
+  return s.map((u) => o?.__specs?.[u.id]?.id || o?.[_(u.id)] || "").join("__");
 }
-const it = /* @__PURE__ */ K({
+const st = /* @__PURE__ */ k({
   name: "DuxSpec",
   props: {
     columns: {
@@ -113,24 +113,34 @@ const it = /* @__PURE__ */ K({
     imageUploadProps: {
       type: Object,
       default: () => ({})
+    },
+    /**
+     * When enabled, DuxSpec will keep `row.specs` in sync as a plain map:
+     * { [specName]: valueLabel }.
+     *
+     * This lets the backend store/query SKU specs without dealing with editor-only fields.
+     */
+    syncRowSpecs: {
+      type: Boolean,
+      default: !1
     }
   },
   emits: ["update:value", "change"],
-  setup(r, {
-    emit: o,
-    expose: i,
-    slots: a
+  setup(o, {
+    emit: s,
+    expose: u,
+    slots: m
   }) {
     const {
-      t: _
-    } = M(), t = N(r, "value", o, {
-      defaultValue: r.defaultValue || {
+      t: x
+    } = z(), t = F(o, "value", s, {
+      defaultValue: o.defaultValue || {
         specs: [],
         rows: []
       },
       passive: !0,
       deep: !0
-    }), f = R(null), d = () => {
+    }), h = M(null), v = () => {
       if (!t.value) {
         t.value = {
           specs: [],
@@ -142,117 +152,146 @@ const it = /* @__PURE__ */ K({
         status: 1
       });
     };
-    d();
-    const m = () => {
-      r.onUpdateValue?.(t.value), o("change", t.value);
-    }, w = h(() => (d(), (t.value?.specs || []).map((e) => {
-      const n = (e.name || "").trim(), p = (e.values || []).map((c) => ({
-        id: c.id,
-        label: (c.label || "").trim(),
+    v();
+    const f = () => {
+      o.onUpdateValue?.(t.value), s("change", t.value);
+    }, b = g(() => (v(), (t.value?.specs || []).map((e) => {
+      const i = (e.name || "").trim(), a = (e.values || []).map((n) => ({
+        id: n.id,
+        label: (n.label || "").trim(),
         specId: e.id,
-        specName: n
-      })).filter((c) => !!c.label);
+        specName: i
+      })).filter((n) => !!n.label);
       return {
         id: e.id,
-        name: n,
-        values: p
+        name: i,
+        values: a
       };
-    }).filter((e) => e.name && e.values.length))), b = (e) => {
-      if (d(), !e.length) {
-        let s = !1;
-        const u = t.value.rows || [];
-        u.length ? (u.forEach((l) => {
-          typeof l.status > "u" && (l.status = 1, s = !0);
-        }), s && m()) : (t.value.rows = [{
+    }).filter((e) => e.name && e.values.length))), P = (e, i) => {
+      if (!o.syncRowSpecs)
+        return;
+      const a = {};
+      i.forEach((n) => {
+        const c = e?.__specs?.[n.id];
+        c?.label && (a[n.name] = c.label);
+      }), e.specs = a;
+    }, K = (e, i) => {
+      if (!e || typeof e != "object")
+        return;
+      if (e.__specKey && e.__specs) {
+        P(e, i);
+        return;
+      }
+      const a = e.specs;
+      if (!a || typeof a != "object" || Array.isArray(a))
+        return;
+      const n = {}, c = [];
+      i.forEach((d) => {
+        const y = a[d.name];
+        if (!y)
+          return;
+        const r = d.values.find((l) => l.label === y);
+        r && (n[d.id] = r, c.push(r.id), e[_(d.id)] = r.label);
+      }), c.length === i.length && (e.__specKey = c.join("__"), e.__specs = n, P(e, i));
+    }, V = (e) => {
+      if (v(), !e.length) {
+        let r = !1;
+        const l = t.value.rows || [];
+        l.length ? (l.forEach((p) => {
+          typeof p.status > "u" && (p.status = 1, r = !0);
+        }), r && f()) : (t.value.rows = [{
           status: 1
-        }], m());
+        }], f());
         return;
       }
-      const n = t.value.rows || [], p = W(e), c = n, V = /* @__PURE__ */ new Map();
-      c.forEach((s) => {
-        const u = s.__specKey || X(s, e);
-        V.set(u, s);
+      const i = t.value.rows || [];
+      i.forEach((r) => K(r, e));
+      const a = X(e), n = i, c = /* @__PURE__ */ new Map();
+      n.forEach((r) => {
+        const l = r.__specKey || q(r, e);
+        c.set(l, r);
       });
-      let v = p.length !== c.length;
-      const k = p.map((s) => {
-        const u = V.get(s.key), l = u ? {
-          ...u
+      let d = a.length !== n.length;
+      const y = a.map((r) => {
+        const l = c.get(r.key), p = l ? {
+          ...l
         } : {
           status: 1
         };
-        return l.__specKey = s.key, l.__specs = s.map, typeof l.status > "u" && (l.status = 1), e.forEach((x) => {
-          const S = y(x.id);
-          l[S] = s.map[x.id]?.label || "";
-        }), !v && u && e.some((S) => {
-          const E = y(S.id);
-          return u[E] !== l[E];
-        }) && (v = !0), u || (v = !0), l;
+        return p.__specKey = r.key, p.__specs = r.map, typeof p.status > "u" && (p.status = 1), e.forEach((E) => {
+          const w = _(E.id);
+          p[w] = r.map[E.id]?.label || "";
+        }), P(p, e), !d && l && e.some((w) => {
+          const A = _(w.id);
+          return l[A] !== p[A];
+        }) && (d = !0), l || (d = !0), p;
       });
-      v && (t.value.rows = k, m());
+      d && (t.value.rows = y, f());
     };
-    j(w, (e) => {
-      b(e);
+    N(b, (e) => {
+      V(e);
     }, {
       immediate: !0
     });
-    const U = h(() => w.value.map((e) => {
-      const n = y(e.id);
+    const U = g(() => b.value.map((e) => {
+      const i = _(e.id);
       return {
-        key: n,
+        key: i,
         title: e.name,
         width: 160,
-        render: (p) => p?.[n] || p?.__specs?.[e.id]?.label || ""
+        render: (a) => a?.[i] || a?.__specs?.[e.id]?.label || ""
       };
-    })), A = h(() => ({
+    })), j = g(() => ({
       key: "__dux_spec_status",
-      title: _("components.spec.status"),
+      title: x("components.spec.status"),
       width: 120,
       fixed: "right",
       align: "center",
-      render: (e) => g(O, P({
+      render: (e) => S(O, R({
         value: e.status !== 0 && e.status !== !1
       }, {
-        "onUpdate:value": (n) => {
-          e.status = n ? 1 : 0, m();
+        "onUpdate:value": (i) => {
+          e.status = i ? 1 : 0, f();
         }
       }), null)
-    })), D = h(() => [...U.value, ...r.columns || [], A.value]);
-    return i({
+    })), D = g(() => [...U.value, ...o.columns || [], j.value]);
+    return u({
       setPresetSpecs: (e = []) => {
-        if (f.value && f.value.setPresetSpecs) {
-          f.value.setPresetSpecs(e);
+        if (h.value && h.value.setPresetSpecs) {
+          h.value.setPresetSpecs(e);
           return;
         }
-        d(), t.value.specs = L(e), m(), b(w.value);
+        v(), t.value.specs = W(e), f(), V(b.value);
       }
-    }), () => g("div", {
+    }), () => S("div", {
       class: "flex flex-col gap-4"
-    }, [g(F, P({
-      ref: f,
+    }, [S($, R({
+      ref: h,
       value: t.value?.specs,
-      defaultValue: r.defaultValue?.specs,
-      imageUploadProps: r.imageUploadProps
+      defaultValue: o.defaultValue?.specs,
+      imageUploadProps: o.imageUploadProps
     }, {
       "onUpdate:value": (e) => {
-        d(), t.value.specs = e, m();
+        v(), t.value.specs = e, f();
       }
     }), {
-      actions: () => a?.actions?.(),
-      namePrefix: (e) => a?.namePrefix?.(e),
-      valuePrefix: (e) => a?.valuePrefix?.(e)
-    }), g(z, P({
+      actions: () => m?.actions?.(),
+      namePrefix: (e) => m?.namePrefix?.(e),
+      valuePrefix: (e) => m?.valuePrefix?.(e)
+    }), S(I, R({
       value: t.value?.rows || [],
       columns: D.value,
       createAction: !1,
       deleteAction: !1,
-      moveAction: !1
+      moveAction: !1,
+      size: "medium"
     }, {
       "onUpdate:value": (e) => {
-        d(), t.value.rows = e, m();
+        v(), t.value.rows = e, f();
       }
     }), null)]);
   }
 });
 export {
-  it as DuxSpec
+  st as DuxSpec
 };

package/dist/esm/components/stats/realTime.js

@@ -1,11 +1,12 @@
-import { defineComponent as u, computed as s, createVNode as e, Fragment as m } from "vue";
+import { defineComponent as m, computed as s, createVNode as e, Fragment as u } from "vue";
 import { useI18n as d } from "@duxweb/dvha-core";
 import { NScrollbar as c } from "naive-ui";
 import { DuxCard as p } from "../card/card.js";
+import "@vueuse/core";
 import "clsx";
 import { DuxChart as x } from "../chart/echart.js";
 import { DuxStatsNumber as f } from "./number.js";
-const T = /* @__PURE__ */ u({
+const w = /* @__PURE__ */ m({
   name: "DuxStatsRealTime",
   props: {
     title: {
@@ -57,7 +58,7 @@ const T = /* @__PURE__ */ u({
       headerExtra: () => e("div", {
         class: "text-sm text-muted"
       }, [a.subtitle]),
-      default: () => e(m, null, [a.cards.length > 0 && e("div", {
+      default: () => e(u, null, [a.cards.length > 0 && e("div", {
         class: "lg:h-26 bg-muted"
       }, [e(c, {
         xScrollable: !0
@@ -95,5 +96,5 @@ const T = /* @__PURE__ */ u({
   }
 });
 export {
-  T as DuxStatsRealTime
+  w as DuxStatsRealTime
 };

package/dist/esm/components/table/table.js

@@ -1,7 +1,7 @@
-import { defineComponent as f, computed as d, toRef as c, createVNode as i, mergeProps as m } from "vue";
+import { defineComponent as f, computed as m, unref as c, createVNode as r, mergeProps as p } from "vue";
 import { useI18n as b } from "@duxweb/dvha-core";
 import { useWindowSize as g } from "@vueuse/core";
-import { NDataTable as p, NPagination as x } from "naive-ui";
+import { NDataTable as e, NPagination as x } from "naive-ui";
 import "vue-router";
 import "@overlastic/vue";
 import "clsx";
@@ -82,34 +82,34 @@ const Bt = /* @__PURE__ */ f({
       default: !0
     }
   },
-  extends: p,
+  extends: e,
   setup(o, {
-    expose: e
+    expose: n
   }) {
-    const n = d(() => {
+    const a = m(() => {
       const {
         path: t,
         filter: v,
         columns: D,
         pagination: P,
-        ...u
+        ...d
       } = o;
-      return u;
-    }), l = c(o.filter || {}), r = h({
+      return d;
+    }), l = m(() => c(o.filter) || {}), i = h({
       path: o.path,
-      filters: l.value,
+      filters: l,
       columns: o.columns || [],
       pagination: o.pagination
     });
-    e(r);
+    n(i);
     const {
-      width: a
+      width: u
     } = g(), {
       t: s
     } = b();
-    return () => i("div", {
+    return () => r("div", {
       class: "flex flex-col gap-2"
-    }, [i(p, m(n.value, r.table.value, {
+    }, [r(e, p(a.value, i.table.value, {
       class: "flex-1 min-h-0",
       minHeight: 200,
       tableLayout: "fixed",
@@ -118,16 +118,16 @@ const Bt = /* @__PURE__ */ f({
       bordered: !1,
       renderCell: (t) => t == null || t === "" ? "-" : t
     }), {
-      empty: () => i(y, {
+      empty: () => r(y, {
         bordered: !1
       }, null)
-    }), o.pagination && i("div", {
+    }), o.pagination && r("div", {
       class: "flex justify-end p-4 border-t border-muted"
-    }, [i(x, m(r.tablePagination.value, {
-      simple: a.value < 768
+    }, [r(x, p(i.tablePagination.value, {
+      simple: u.value < 768
     }), {
-      prefix: () => i("div", null, [s("components.list.total", {
-        total: r.total.value || 0
+      prefix: () => r("div", null, [s("components.list.total", {
+        total: i.total.value || 0
       })])
     })])]);
   }