@duxweb/dvha-naiveui 1.0.11 → 1.0.13

package/dist/esm/packages/core/dist/esm/hooks/export.js

@@ -0,0 +1,40 @@
+import "../../../../../node_modules/.pnpm/vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { useInfiniteList as d } from "./data.js";
+import { ref as h } from "../../../../../node_modules/.pnpm/@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+import { computed as s } from "../../../../../node_modules/.pnpm/@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+const w = (a) => new Promise((e) => setTimeout(e, a));
+function N(a) {
+  const e = h(!1), f = s(() => {
+    const { onSuccess: n, onProgress: o, interval: l, maxPage: u, ...c } = a;
+    return {
+      ...c,
+      options: {
+        ...c.options,
+        enabled: !1,
+        refetchOnMount: !1,
+        refetchOnWindowFocus: !1,
+        refetchOnReconnect: !1
+      }
+    };
+  }), r = s(() => a.interval || 300), { data: i, isLoading: v, fetchNextPage: g, hasNextPage: m, refetch: p, pagination: t } = d(f.value), P = async () => {
+    var n, o, l;
+    if (!e.value)
+      try {
+        e.value = !0, t.value.page = 1, (n = a.onProgress) == null || n.call(a, t.value), await p();
+        const u = typeof a.maxPage == "function" ? a.maxPage() : a.maxPage || 100;
+        for (; m.value && t.value.page < u; )
+          r.value > 0 && await w(r.value), await g(), (o = a.onProgress) == null || o.call(a, t.value);
+        (l = a.onSuccess) == null || l.call(a, i.value);
+      } finally {
+        e.value = !1;
+      }
+  }, x = s(() => v.value || e.value);
+  return {
+    data: i,
+    isLoading: x,
+    trigger: P
+  };
+}
+export {
+  N as useExport
+};

package/dist/esm/packages/core/dist/esm/hooks/exportCsv.js

@@ -0,0 +1,56 @@
+import { c as f } from "../../../../../_virtual/converter.js";
+import "../../../../../node_modules/.pnpm/vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { useExport as v } from "./export.js";
+import { computed as i } from "../../../../../node_modules/.pnpm/@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+function g(e) {
+  const u = i(() => {
+    const { filename: r, headers: t, csvOptions: l, ...a } = e;
+    return a;
+  }), p = i(() => {
+    const r = e.csvOptions || {}, t = r.quote;
+    return {
+      prependHeader: e.headers !== !1,
+      keys: Array.isArray(e.headers) ? e.headers : void 0,
+      delimiter: {
+        field: r.delimiter || ",",
+        wrap: typeof t == "string" ? t : '"',
+        eol: r.eol || `
+`
+      },
+      excelBOM: r.writeBOM || !1
+    };
+  });
+  return v({
+    ...u.value,
+    onSuccess: async (r) => {
+      var t, l, a, n;
+      if (!(r != null && r.pages)) {
+        (t = e.onError) == null || t.call(e, {
+          message: "No data to export",
+          status: 400
+        });
+        return;
+      }
+      const c = r.pages.flatMap((o) => (o == null ? void 0 : o.data) || []);
+      if (c.length === 0) {
+        (l = e.onError) == null || l.call(e, {
+          message: "No data to export",
+          status: 400
+        });
+        return;
+      }
+      try {
+        const o = await f.json2csv(c, p.value), m = new Blob([o], { type: "text/csv;charset=utf-8;" }), d = URL.createObjectURL(m), s = document.createElement("a");
+        s.href = d, s.download = e.filename || "export.csv", s.style.display = "none", document.body.appendChild(s), s.click(), document.body.removeChild(s), URL.revokeObjectURL(d), (a = e.onSuccess) == null || a.call(e, r);
+      } catch (o) {
+        (n = e.onError) == null || n.call(e, {
+          message: `CSV Export Error: ${o}`,
+          status: 500
+        });
+      }
+    }
+  });
+}
+export {
+  g as useExportCsv
+};

package/dist/esm/packages/core/dist/esm/hooks/import.js

@@ -0,0 +1,58 @@
+import "../../../../../node_modules/.pnpm/vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { useCustomMutation as B } from "./data.js";
+import { ref as g } from "../../../../../node_modules/.pnpm/@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+import { computed as i } from "../../../../../node_modules/.pnpm/@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+const P = (e) => new Promise((s) => setTimeout(s, e));
+function C(e) {
+  const s = g(!1), o = g({
+    totalItems: 0,
+    processedItems: 0,
+    totalBatches: 0,
+    processedBatches: 0,
+    percentage: 0
+  }), h = i(() => {
+    const { onComplete: r, onProgress: l, onError: n, interval: u, chunkSize: c, ...p } = e;
+    return p;
+  }), { mutate: d } = B({
+    path: e.path,
+    method: "POST",
+    ...h.value,
+    options: {
+      ...h.value.options
+    }
+  }), f = async (r) => {
+    var l, n, u;
+    if (s.value)
+      return;
+    const c = e.chunkSize || 100, p = e.interval || 100, m = r.length, a = [];
+    for (let t = 0; t < m; t += c)
+      a.push(r.slice(t, t + c));
+    const I = a.length;
+    o.value = {
+      totalItems: m,
+      processedItems: 0,
+      totalBatches: I,
+      processedBatches: 0,
+      percentage: 0
+    }, s.value = !0;
+    try {
+      for (let t = 0; t < a.length; t++) {
+        const v = a[t];
+        await d({
+          payload: v
+        }), o.value.processedBatches = t + 1, o.value.processedItems += v.length, o.value.percentage = Math.round(o.value.processedItems / m * 100), (l = e.onProgress) == null || l.call(e, o.value), t < a.length - 1 && await P(p);
+      }
+      s.value = !1, (n = e.onComplete) == null || n.call(e, o.value);
+    } catch (t) {
+      s.value = !1, (u = e.onError) == null || u.call(e, t);
+    }
+  };
+  return {
+    isLoading: i(() => s.value),
+    progress: i(() => o.value),
+    trigger: f
+  };
+}
+export {
+  C as useImport
+};

package/dist/esm/packages/core/dist/esm/hooks/importCsv.js

@@ -0,0 +1,57 @@
+import { useFileDialog as f } from "../../../../../node_modules/.pnpm/@vueuse_core@13.3.0_vue@3.5.17_typescript@5.8.3_/node_modules/@vueuse/core/index.js";
+import { c as v } from "../../../../../_virtual/converter.js";
+import "../../../../../node_modules/.pnpm/vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { useImport as g } from "./import.js";
+import { computed as n } from "../../../../../node_modules/.pnpm/@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+function y(r) {
+  const c = n(() => {
+    const { csvOptions: e, ...s } = r;
+    return s;
+  }), m = n(() => {
+    const e = r.csvOptions || {};
+    return {
+      delimiter: {
+        field: e.delimiter || ",",
+        wrap: e.wrap || '"',
+        eol: e.eol || `
+`
+      },
+      excelBOM: e.excelBOM || !1,
+      headerFields: e.headerFields,
+      keys: e.keys,
+      trimHeaderFields: e.trimHeaderFields || !1,
+      trimFieldValues: e.trimFieldValues || !1
+    };
+  }), l = g({
+    ...c.value
+  }), o = async (e) => {
+    var s, i;
+    try {
+      const t = await e.text(), a = await v.csv2json(t, m.value);
+      a && a.length > 0 ? await l.trigger(a) : (s = r.onError) == null || s.call(r, {
+        message: "CSV 文件为空或格式不正确",
+        status: 400
+      });
+    } catch (t) {
+      (i = r.onError) == null || i.call(r, {
+        message: `CSV 解析错误: ${t}`,
+        status: 500
+      });
+    }
+  }, { open: p, reset: u, onChange: d } = f({
+    accept: ".csv",
+    multiple: !1
+  });
+  return d((e) => {
+    e && e.length > 0 && o(e[0]);
+  }), {
+    ...l,
+    open: () => {
+      u(), p();
+    },
+    readFile: o
+  };
+}
+export {
+  y as useImportCsv
+};

package/dist/esm/packages/core/dist/esm/hooks/json/index.js

@@ -0,0 +1,22 @@
+import { vForAdaptor as a } from "./vFor.js";
+import { vIfAdaptor as t } from "./vIf.js";
+import { vModelAdaptor as p } from "./vModel.js";
+import { vOnAdaptor as d } from "./vOn.js";
+import { vShowAdaptor as s } from "./vShow.js";
+import { vTextAdaptor as A } from "./vText.js";
+[
+  t,
+  s,
+  a,
+  p,
+  d,
+  A
+].sort((o, r) => r.priority - o.priority);
+export {
+  a as vForAdaptor,
+  t as vIfAdaptor,
+  p as vModelAdaptor,
+  d as vOnAdaptor,
+  s as vShowAdaptor,
+  A as vTextAdaptor
+};

package/dist/esm/packages/core/dist/esm/hooks/json/utils/contextManager.js

@@ -0,0 +1,31 @@
+function c(t) {
+  return t._context || {};
+}
+function r(t, e) {
+  return Object.keys(e).length === 0 ? t : {
+    ...t,
+    _context: e
+  };
+}
+function s(t) {
+  const { _context: e, ...n } = t;
+  return n;
+}
+function a(t, e = {}) {
+  const n = { ...t };
+  return e.cleanKeys && e.cleanKeys.forEach((o) => delete n[o]), {
+    props: n,
+    skip: e.skip,
+    nodes: e.nodes
+  };
+}
+function u(t, e, n) {
+  return typeof t == "string" ? !!n(t, e) : !!t;
+}
+export {
+  s as cleanProps,
+  a as createAdaptorResult,
+  u as evaluateCondition,
+  c as extractContext,
+  r as injectContext
+};

package/dist/esm/packages/core/dist/esm/hooks/json/utils/expressionParser.js

@@ -0,0 +1,135 @@
+import p from "../../../../../../../node_modules/.pnpm/jsep@1.4.0/node_modules/jsep/dist/jsep.js";
+import "../../../../../../../node_modules/.pnpm/vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { unref as u } from "../../../../../../../node_modules/.pnpm/@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+p.addIdentifierChar("$");
+p.addIdentifierChar("@");
+function d(t) {
+  try {
+    return p(t);
+  } catch (n) {
+    return console.warn(`Expression parsing failed: ${t}`, n), null;
+  }
+}
+function m(t, n) {
+  const s = d(t);
+  if (s)
+    return o(s, n);
+}
+function o(t, n) {
+  var s, l;
+  if (!(!t || typeof t != "object"))
+    switch (t.type) {
+      case "Literal":
+        return t.value;
+      case "Identifier":
+        return y(n, t.name);
+      case "MemberExpression": {
+        const e = o(t.object, n);
+        if (e == null)
+          return;
+        const r = t.computed ? o(t.property, n) : (s = t.property) == null ? void 0 : s.name, a = u(e);
+        return a == null ? void 0 : a[r];
+      }
+      case "BinaryExpression": {
+        const e = o(t.left, n), r = o(t.right, n), a = {
+          "+": () => e + r,
+          "-": () => e - r,
+          "*": () => e * r,
+          "/": () => e / r,
+          "%": () => e % r,
+          "==": () => e === r,
+          "===": () => e === r,
+          "!=": () => e !== r,
+          "!==": () => e !== r,
+          "<": () => e < r,
+          ">": () => e > r,
+          "<=": () => e <= r,
+          ">=": () => e >= r
+        };
+        return ((l = a[t.operator]) == null ? void 0 : l.call(a)) ?? void 0;
+      }
+      case "LogicalExpression": {
+        const e = o(t.left, n);
+        return t.operator === "&&" ? e && o(t.right, n) : t.operator === "||" ? e || o(t.right, n) : t.operator === "??" ? e ?? o(t.right, n) : void 0;
+      }
+      case "UnaryExpression": {
+        const e = o(t.argument, n);
+        return t.operator === "!" ? !e : t.operator === "-" ? -e : t.operator === "+" ? +e : void 0;
+      }
+      case "ConditionalExpression": {
+        const e = o(t.test, n);
+        return o(e ? t.consequent : t.alternate, n);
+      }
+      case "CallExpression": {
+        const e = o(t.callee, n), r = u(e);
+        if (typeof r != "function") {
+          console.warn("Attempting to call non-function value:", r);
+          return;
+        }
+        const a = Array.isArray(t.arguments) ? t.arguments.map((i) => {
+          const c = o(i, n);
+          return u(c);
+        }) : [];
+        try {
+          let i;
+          if (t.callee.type === "MemberExpression") {
+            const c = o(t.callee.object, n);
+            i = u(c);
+          }
+          return r.apply(i, a);
+        } catch (i) {
+          console.warn("Function call error:", i);
+          return;
+        }
+      }
+      case "ArrayExpression":
+        return Array.isArray(t.elements) ? t.elements.map((e) => {
+          if (!e)
+            return;
+          const r = o(e, n);
+          return u(r);
+        }) : [];
+      default:
+        console.warn(`Unsupported expression type: ${t.type}`);
+        return;
+    }
+}
+function y(t, n) {
+  if (!(!n || !t))
+    try {
+      return n.split(".").reduce((s, l) => {
+        if (s == null)
+          return;
+        const e = u(s);
+        return e == null ? void 0 : e[l];
+      }, t);
+    } catch {
+      return;
+    }
+}
+function E(t, n) {
+  const s = t.trim(), l = s.match(/^\((\w+),\s*(\w+)\) in (.+)$/);
+  if (l) {
+    const [, r, a, i] = l, c = m(i, n), f = u(c);
+    return {
+      items: Array.isArray(f) ? f : [],
+      itemName: r,
+      indexName: a
+    };
+  }
+  const e = s.match(/^(\w+) in (.+)$/);
+  if (e) {
+    const [, r, a] = e, i = m(a, n), c = u(i);
+    return {
+      items: Array.isArray(c) ? c : [],
+      itemName: r,
+      indexName: "index"
+    };
+  }
+  throw new Error(`Invalid v-for expression: ${t}`);
+}
+export {
+  m as evaluateExpression,
+  d as parseExpression,
+  E as parseVForExpression
+};

package/dist/esm/packages/core/dist/esm/hooks/json/vFor.js

@@ -0,0 +1,57 @@
+import { extractContext as d, injectContext as u, cleanProps as v } from "./utils/contextManager.js";
+import { parseVForExpression as x } from "./utils/expressionParser.js";
+const A = {
+  name: "v-for",
+  priority: 90,
+  process(r, i) {
+    var n, a;
+    const e = ((n = r.attrs) == null ? void 0 : n["v-for"]) || ((a = r.attrs) == null ? void 0 : a.vFor);
+    if (!e)
+      return null;
+    const o = { ...r.attrs };
+    delete o["v-for"], delete o.vFor;
+    const m = d(i);
+    let t;
+    try {
+      if (Array.isArray(e))
+        t = {
+          items: e,
+          itemName: "item",
+          indexName: "index"
+        };
+      else if (typeof e == "object" && e.list)
+        t = {
+          items: Array.isArray(e.list) ? e.list : [],
+          itemName: e.item || "item",
+          indexName: e.index || "index"
+        };
+      else if (typeof e == "string")
+        t = x(e, m);
+      else
+        return console.warn("Unsupported v-for format:", e), null;
+    } catch (s) {
+      return console.warn("v-for parsing failed:", s), null;
+    }
+    const p = t.items.map((s, l) => {
+      const c = {
+        [t.itemName]: s,
+        [t.indexName]: l
+      }, f = { ...m, ...c };
+      return {
+        ...r,
+        attrs: {
+          ...o,
+          key: `${t.itemName}_${l}`,
+          ...u({}, f)
+        }
+      };
+    });
+    return {
+      props: v(i),
+      nodes: p
+    };
+  }
+};
+export {
+  A as vForAdaptor
+};

package/dist/esm/packages/core/dist/esm/hooks/json/vIf.js

@@ -0,0 +1,17 @@
+import { extractContext as v, createAdaptorResult as l, evaluateCondition as i } from "./utils/contextManager.js";
+import { evaluateExpression as a } from "./utils/expressionParser.js";
+const p = {
+  name: "v-if",
+  priority: 100,
+  process(r, o) {
+    const e = r.attrs || {}, s = v(o);
+    let t;
+    return e["v-if"] !== void 0 ? t = i(e["v-if"], s, a) : e["v-else-if"] !== void 0 ? t = i(e["v-else-if"], s, a) : e["v-else"] !== void 0 && (t = !0), t === void 0 ? null : l(o, {
+      skip: !t,
+      cleanKeys: ["v-if", "v-else-if", "v-else"]
+    });
+  }
+};
+export {
+  p as vIfAdaptor
+};

package/dist/esm/packages/core/dist/esm/hooks/json/vModel.js

@@ -0,0 +1,79 @@
+import "../../../../../../node_modules/.pnpm/vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { toRef as c } from "../../../../../../node_modules/.pnpm/@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+const b = {
+  name: "v-model",
+  priority: 70,
+  process(e, l) {
+    const r = {}, t = {};
+    let o = !1;
+    return Object.entries(l).forEach(([n, u]) => {
+      if (n.startsWith("v-model") || n.startsWith("vModel")) {
+        o = !0;
+        const [s, ...m] = n.split(".");
+        let a;
+        s === "v-model" || s === "vModel" ? a = "modelValue" : s.startsWith("v-model:") ? a = s.slice(8) : s.startsWith("vModel:") ? a = s.slice(7) : a = "modelValue";
+        try {
+          const { modelValue: d, updateFn: p } = f(u, m);
+          r[a] = d, r[`onUpdate:${a}`] = p;
+        } catch (d) {
+          console.error(`v-model binding error (${a}):`, d);
+        }
+      } else
+        t[n] = u;
+    }), o ? { props: { ...t, ...r } } : null;
+  }
+};
+function f(e, l) {
+  if (Array.isArray(e) && e.length === 2 && typeof e[0] == "function" && typeof e[1] == "function") {
+    const [t, o] = e;
+    return {
+      modelValue: t(),
+      updateFn: (n) => {
+        o(i(n, l));
+      }
+    };
+  }
+  if (Array.isArray(e) && e.length === 2) {
+    const [t, o] = e;
+    if (!t || typeof o != "string")
+      throw new Error("Invalid v-model binding format: [obj, prop] expected");
+    const n = c(t, o);
+    return {
+      modelValue: n.value,
+      updateFn: (u) => {
+        n.value = i(u, l);
+      }
+    };
+  }
+  const r = c(e);
+  return r === e && typeof e != "object" ? {
+    modelValue: e,
+    updateFn: () => {
+      console.warn("v-model: Cannot update non-reactive value. Please use ref, [obj, prop], or [getter, setter] format.");
+    }
+  } : {
+    modelValue: r.value,
+    updateFn: (t) => {
+      r.value = i(t, l);
+    }
+  };
+}
+function i(e, l) {
+  return l.reduce((r, t) => {
+    switch (t) {
+      case "trim":
+        return typeof r == "string" ? r.trim() : r;
+      case "number": {
+        const o = Number(r);
+        return Number.isNaN(o) ? r : o;
+      }
+      case "lazy":
+        return r;
+      default:
+        return console.warn(`Unknown v-model modifier: ${t}`), r;
+    }
+  }, e);
+}
+export {
+  b as vModelAdaptor
+};

package/dist/esm/packages/core/dist/esm/hooks/json/vOn.js

@@ -0,0 +1,32 @@
+const y = {
+  name: "v-on",
+  priority: 60,
+  process($, p) {
+    const l = {}, o = {};
+    let r = !1;
+    return Object.entries(p).forEach(([e, t]) => {
+      if (e.startsWith("@") || e.startsWith("v-on:")) {
+        r = !0;
+        const u = e.startsWith("@") ? e.slice(1) : e.slice(5), [s, ...a] = u.split(".");
+        if (!s) {
+          console.warn(`Invalid event name: ${e}`);
+          return;
+        }
+        const v = `on${s.charAt(0).toUpperCase()}${s.slice(1)}`, f = (n, ...h) => {
+          var c, i;
+          a.includes("prevent") && ((c = n.preventDefault) == null || c.call(n)), a.includes("stop") && ((i = n.stopPropagation) == null || i.call(n));
+          try {
+            typeof t == "function" ? t(n, ...h) : console.warn(`Invalid event handler type: ${typeof t}`);
+          } catch (d) {
+            console.error(`Event handler execution error (${s}):`, d);
+          }
+        };
+        l[v] = f;
+      } else
+        o[e] = t;
+    }), r ? { props: { ...o, ...l } } : null;
+  }
+};
+export {
+  y as vOnAdaptor
+};

package/dist/esm/packages/core/dist/esm/hooks/json/vShow.js

@@ -0,0 +1,24 @@
+import { extractContext as p, evaluateCondition as v } from "./utils/contextManager.js";
+import { evaluateExpression as d } from "./utils/expressionParser.js";
+const m = {
+  name: "v-show",
+  priority: 95,
+  process(i, t) {
+    var e;
+    const s = (e = i.attrs) == null ? void 0 : e["v-show"];
+    if (s === void 0)
+      return null;
+    const a = p(t), r = v(s, a, d), o = { ...t };
+    delete o["v-show"];
+    const n = o.style || {}, l = typeof n == "object" ? { ...n, display: r ? void 0 : "none" } : { display: r ? void 0 : "none" };
+    return {
+      props: {
+        ...o,
+        style: l
+      }
+    };
+  }
+};
+export {
+  m as vShowAdaptor
+};

package/dist/esm/packages/core/dist/esm/hooks/json/vText.js

@@ -0,0 +1,54 @@
+import { evaluateExpression as u } from "./utils/expressionParser.js";
+function l(t) {
+  return typeof t == "string" && /\{\{.+?\}\}/.test(t);
+}
+function f(t, c) {
+  return l(t) ? t.replace(/\{\{([^}]+)\}\}/g, (s, n) => {
+    try {
+      const r = u(n.trim(), c);
+      return String(r ?? "");
+    } catch (r) {
+      return console.warn(`Interpolation expression evaluation failed: ${n}`, r), s;
+    }
+  }) : t;
+}
+const h = {
+  name: "v-text",
+  priority: 50,
+  process(t, c) {
+    const s = c._context || {};
+    let n = !1, r = !1;
+    const i = {};
+    Object.entries(c).forEach(([e, o]) => {
+      if (typeof o == "string" && l(o)) {
+        const p = f(o, s);
+        p !== o ? (i[e] = p, n = !0) : i[e] = o;
+      } else
+        i[e] = o;
+    });
+    let a = t.children;
+    if (typeof t.children == "string" && l(t.children)) {
+      const e = f(t.children, s);
+      e !== t.children && (a = e, n = !0, r = !0);
+    }
+    if (!n)
+      return null;
+    if (r) {
+      const e = {
+        ...t,
+        attrs: t.attrs,
+        children: a
+      };
+      return {
+        props: i,
+        nodes: [e]
+      };
+    }
+    return {
+      props: i
+    };
+  }
+};
+export {
+  h as vTextAdaptor
+};