vlite3 1.4.37 → 1.4.39

package/components/StatusChip/StatusChip.vue.js

@@ -1,8 +1,9 @@
-import { defineComponent as u, computed as a, openBlock as c, createBlock as f, unref as p, normalizeClass as m } from "vue";
+import { defineComponent as u, computed as l, openBlock as c, createBlock as f, unref as p, normalizeClass as m } from "vue";
 import d from "../Chip/Chip.vue.js";
+/* empty css                */
 import { resolveStatus as v } from "./status-map.js";
 import { $t as b } from "../../utils/i18n.js";
-import { useVLiteConfig as I } from "../../core/config.js";
+import { useVLiteConfig as h } from "../../core/config.js";
 const S = /* @__PURE__ */ u({
   __name: "StatusChip",
   props: {
@@ -13,14 +14,14 @@ const S = /* @__PURE__ */ u({
     size: { default: "small" },
     class: { default: "" }
   },
-  setup(l) {
-    const e = l, s = I(), n = a(() => s?.components?.statusChip), i = a(() => e.hideIcon !== null ? e.hideIcon : n.value?.hideIcon ?? !1), t = a(() => v(e.status, n.value?.customStatuses)), r = a(() => e.labelI18n ? b(e.labelI18n) : t.value.label ? t.value.label : e.label ? e.label : e.status.replace(/[_\-]+/g, " ").replace(/\b\w/g, (o) => o.toUpperCase()));
-    return (o, g) => (c(), f(p(d), {
+  setup(a) {
+    const e = a, s = h(), n = l(() => s?.components?.statusChip), i = l(() => e.hideIcon !== null ? e.hideIcon : n.value?.hideIcon ?? !1), t = l(() => v(e.status, n.value?.customStatuses)), r = l(() => e.labelI18n ? b(e.labelI18n) : t.value.label ? t.value.label : e.label ? e.label : e.status.replace(/[_\-]+/g, " ").replace(/\b\w/g, (o) => o.toUpperCase()));
+    return (o, I) => (c(), f(p(d), {
       text: r.value,
       variant: t.value.variant,
       icon: i.value ? void 0 : t.value.icon,
-      size: l.size,
-      class: m(e.class)
+      size: a.size,
+      class: m(["status-chip", "scrollbar-hide", e.class].filter(Boolean).join(" "))
     }, null, 8, ["text", "variant", "icon", "size", "class"]));
   }
 });

package/components/StatusChip/StatusChip.vue3.js

@@ -0,0 +1,5 @@
+import o from "./StatusChip.vue.js";
+/* empty css                */
+export {
+  o as default
+};

package/components/Timeline/TimelineItem.vue.js

@@ -1,6 +1,7 @@
 import { defineComponent as P, computed as b, openBlock as n, createElementBlock as l, normalizeClass as o, createElementVNode as i, createVNode as y, createCommentVNode as c, renderSlot as a, toDisplayString as d, createBlock as g, resolveDynamicComponent as I, normalizeProps as $, mergeProps as L } from "vue";
 import h from "./TimelineIndicator.vue.js";
 import B from "../StatusChip/StatusChip.vue.js";
+/* empty css                            */
 import { $t as r } from "../../utils/i18n.js";
 const C = { class: "flex flex-col items-center shrink-0 mr-4 w-9" }, T = { class: "flex flex-col gap-1" }, V = { class: "flex justify-between items-start gap-4" }, D = { class: "text-sm font-semibold text-foreground leading-none" }, N = {
   key: 0,
@@ -18,7 +19,7 @@ const C = { class: "flex flex-col items-center shrink-0 mr-4 w-9" }, T = { class
   key: 0,
   class: "hidden sm:block flex-1 h-0.5 bg-border ml-2",
   "aria-hidden": "true"
-}, M = /* @__PURE__ */ P({
+}, O = /* @__PURE__ */ P({
   __name: "TimelineItem",
   props: {
     step: {},
@@ -152,5 +153,5 @@ const C = { class: "flex flex-col items-center shrink-0 mr-4 w-9" }, T = { class
   }
 });
 export {
-  M as default
+  O as default
 };

package/components/TreeConnectors/TreeConnectors.vue.d.ts

@@ -19,8 +19,8 @@ interface Props extends TreeConnectorInput {
     bleedY?: boolean;
 }
 declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
-    ancestorLastFlags: boolean[];
     hasToggle: boolean;
+    ancestorLastFlags: boolean[];
     lineClass: string;
     bleedY: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;

package/components/TreeConnectors/TreeConnectors.vue.js

@@ -1,22 +1,24 @@
-import { defineComponent as r, computed as i, openBlock as s, createElementBlock as a, normalizeClass as o, Fragment as d, renderList as c, normalizeStyle as g } from "vue";
-import { buildTreeConnectorSegments as p } from "./geometry.js";
-const h = /* @__PURE__ */ r({
+import { defineComponent as m, computed as u, openBlock as s, createElementBlock as l, normalizeClass as i, Fragment as c, renderList as f, isMemoSame as g, normalizeStyle as S } from "vue";
+import { EMPTY_ANCESTOR_LAST_FLAGS as b, buildTreeConnectorSegments as y } from "./geometry.js";
+const x = /* @__PURE__ */ m({
   __name: "TreeConnectors",
   props: {
     lineClass: { default: "bg-muted-foreground/35 dark:bg-muted-foreground/25!" },
     bleedY: { type: Boolean, default: !1 },
     depth: {},
     isLastSibling: { type: Boolean },
-    ancestorLastFlags: { default: () => [] },
+    ancestorLastFlags: { default: () => b },
     hasToggle: { type: Boolean, default: !1 },
     indent: {},
     toggleSize: {},
     baseInset: {},
-    contentGap: {}
+    contentGap: {},
+    leafHasSpacer: { type: Boolean },
+    leafInset: {}
   },
-  setup(t) {
-    const e = t, l = i(
-      () => p({
+  setup(n) {
+    const e = n, p = u(
+      () => y({
         depth: e.depth,
         isLastSibling: e.isLastSibling,
         ancestorLastFlags: e.ancestorLastFlags,
@@ -24,21 +26,28 @@ const h = /* @__PURE__ */ r({
         indent: e.indent,
         toggleSize: e.toggleSize,
         baseInset: e.baseInset,
-        contentGap: e.contentGap
+        contentGap: e.contentGap,
+        leafHasSpacer: e.leafHasSpacer,
+        leafInset: e.leafInset
       })
     );
-    return (u, m) => (s(), a("span", {
-      class: o(["tree-connectors pointer-events-none absolute inset-x-0", t.bleedY ? "-inset-y-px z-[1]" : "inset-y-0 overflow-hidden"]),
+    return (L, d) => (s(), l("span", {
+      class: i(["tree-connectors pointer-events-none absolute inset-x-0", n.bleedY ? "-inset-y-px z-[1]" : "inset-y-0 overflow-hidden"]),
       "aria-hidden": "true"
     }, [
-      (s(!0), a(d, null, c(l.value, (n) => (s(), a("span", {
-        key: n.key,
-        class: o(["absolute", [n.orientation === "vertical" ? "w-px" : "h-px", t.lineClass]]),
-        style: g(n.style)
-      }, null, 6))), 128))
+      (s(!0), l(c, null, f(p.value, (t, C, T, a) => {
+        const o = [t, n.lineClass];
+        if (a && a.key === t.key && g(a, o)) return a;
+        const r = (s(), l("span", {
+          key: t.key,
+          class: i(["absolute", [t.orientation === "vertical" ? "w-px" : "h-px", n.lineClass]]),
+          style: S(t.style)
+        }, null, 6));
+        return r.memo = o, r;
+      }, d, 0), 128))
     ], 2));
   }
 });
 export {
-  h as default
+  x as default
 };

package/components/TreeConnectors/geometry.d.ts

@@ -2,11 +2,16 @@ import { CSSProperties } from 'vue';
 /** Horizontal indent (px) added per depth level. Mirrors DataTable's `treeIndent`. */
 export declare const DEFAULT_TREE_INDENT = 20;
 /** Width (px) of the expand/collapse toggle. Rails are centred on it. */
-export declare const DEFAULT_TOGGLE_SIZE = 24;
+export declare const DEFAULT_TOGGLE_SIZE = 20;
 /** Default leading space (px) before the depth-0 toggle (keeps it off the edge). */
-export declare const DEFAULT_TREE_LEADING = 5;
+export declare const DEFAULT_TREE_LEADING = 10;
 /** Default gap (px) between the toggle and the row content (icon/label). */
-export declare const DEFAULT_TREE_CONTENT_GAP = 5;
+export declare const DEFAULT_TREE_CONTENT_GAP = 10;
+/**
+ * Default extra left inset (px) for leaf rows that don't reserve a toggle slot,
+ * so their icon isn't flush against the table's left edge.
+ */
+export declare const DEFAULT_TREE_LEAF_INSET = 5;
 export type TreeConnectorOrientation = 'vertical' | 'horizontal';
 export type TreeConnectorRole = 'trunk' | 'elbow' | 'branch';
 /** Inline styles for a connector segment (Vue `:style` / CSSProperties-compatible). */
@@ -48,11 +53,29 @@ export interface TreeConnectorInput {
      * as the content is pushed right.
      */
     contentGap?: number;
+    /**
+     * Whether leaf rows keep an empty toggle-sized spacer before their content.
+     * `true` (default): the branch reaches into that spacer toward the icon.
+     * `false`: the leaf icon is left-aligned into the toggle slot, so the branch
+     * stops just before it — exactly like an expandable row's chevron.
+     */
+    leafHasSpacer?: boolean;
+    /**
+     * Extra left inset (px) applied to a leaf row's icon when it doesn't reserve a
+     * toggle slot (`leafHasSpacer: false`). The branch extends to match, so leaf
+     * icons keep breathing room from the table edge without losing their connector.
+     */
+    leafInset?: number;
 }
 /** Horizontal centre (px) of the vertical rail for a given tree depth. */
 export declare function railX(level: number, indent: number, toggleSize: number): number;
 /** @deprecated Renamed to {@link railX}. Kept as an alias for compatibility. */
 export declare const guideX: typeof railX;
+/** Shared empty flags array — stable reference for root rows / v-memo. */
+export declare const EMPTY_ANCESTOR_LAST_FLAGS: readonly boolean[];
+export declare function stabilizeAncestorLastFlags(flags: readonly boolean[]): boolean[];
+/** Append one flag onto a (preferably already-stable) ancestor list, with caching. */
+export declare function appendAncestorLastFlag(flags: readonly boolean[], isLastSibling: boolean): boolean[];
 /**
  * Compute every connector segment for a single tree row.
  *
@@ -60,5 +83,8 @@ export declare const guideX: typeof railX;
  * node on the row's own path at depth `k + 1` still has a following sibling —
  * i.e. `ancestorLastFlags[k + 1] === false`. That single rule keeps vertical
  * lines running through descendants and stops them exactly at the final child.
+ *
+ * Results are cached by geometry inputs so identical tree shapes reuse the same
+ * `markRaw` segment objects (helps v-memo / avoids proxy churn).
  */
 export declare function buildTreeConnectorSegments(input: TreeConnectorInput): TreeConnectorSegment[];

package/components/TreeConnectors/geometry.js

@@ -1,55 +1,137 @@
-const A = 20, F = 24, h = 5, p = 5;
-function N(o, e, s) {
-  return o * e + s / 2;
+import { markRaw as c } from "vue";
+const I = 20, C = 20, w = 10, H = 10, O = 5, i = 0.5, N = 2, y = 5, G = 512;
+function R(n, e, o) {
+  return n * e + o / 2;
 }
-const E = (o) => `${o}px`;
-function R(o) {
+const f = (n) => `${n}px`, k = Object.freeze([]), S = /* @__PURE__ */ new Map();
+function x(n) {
+  if (!n.length) return k;
+  let e = "";
+  for (let a = 0; a < n.length; a++)
+    e += n[a] ? "1" : "0";
+  const o = S.get(e);
+  if (o) return o;
+  const s = c(n.slice());
+  return S.set(e, s), s;
+}
+function v(n, e) {
+  return x([...n, e]);
+}
+const E = /* @__PURE__ */ new Map();
+function D(n) {
+  const {
+    depth: e,
+    isLastSibling: o,
+    hasToggle: s,
+    indent: a,
+    toggleSize: r,
+    baseInset: h,
+    contentGap: l,
+    leafHasSpacer: g,
+    leafInset: p,
+    flagsKey: u
+  } = n;
+  return [
+    e,
+    o ? 1 : 0,
+    s ? 1 : 0,
+    a,
+    r,
+    h,
+    l,
+    g ? 1 : 0,
+    p,
+    u
+  ].join("|");
+}
+function M(n, e) {
+  if (E.size >= G) {
+    const s = E.keys().next().value;
+    s !== void 0 && E.delete(s);
+  }
+  const o = c(e);
+  return E.set(n, o), o;
+}
+function U(n) {
   const {
     depth: e,
-    isLastSibling: s,
-    ancestorLastFlags: T,
-    hasToggle: c = !1,
-    indent: a = 20,
-    toggleSize: _ = 24,
-    baseInset: i = 0,
-    contentGap: I = 0
-  } = o, n = [];
-  if (!Number.isFinite(e) || e < 0) return n;
-  const l = (t) => i + N(t, a, _);
+    isLastSibling: o,
+    ancestorLastFlags: s,
+    hasToggle: a = !1,
+    indent: r = I,
+    toggleSize: h = C,
+    baseInset: l = 0,
+    contentGap: g = 0,
+    leafHasSpacer: p = !0,
+    leafInset: u = 0
+  } = n;
+  if (!Number.isFinite(e) || e < 0) return [];
+  let b = "";
+  for (let t = 0; t < s.length; t++)
+    b += s[t] ? "1" : "0";
+  const d = D({
+    depth: e,
+    isLastSibling: o,
+    hasToggle: a,
+    indent: r,
+    toggleSize: h,
+    baseInset: l,
+    contentGap: g,
+    leafHasSpacer: p,
+    leafInset: u,
+    flagsKey: b
+  }), m = E.get(d);
+  if (m) return m;
+  const T = [], _ = (t) => l + R(t, r, h);
   for (let t = 0; t <= e - 2; t++)
-    T[t + 1] === !1 && n.push({
-      key: `trunk-${t}`,
-      orientation: "vertical",
-      role: "trunk",
-      style: { left: E(l(t) - 0.5), top: "0", bottom: "0" }
-    });
+    s[t + 1] === !1 && T.push(
+      c({
+        key: `trunk-${t}`,
+        orientation: "vertical",
+        role: "trunk",
+        style: c({ left: f(_(t) - i), top: "0", bottom: "0" })
+      })
+    );
   if (e >= 1) {
-    const t = l(e - 1);
-    n.push({
-      key: `elbow-${e}`,
-      orientation: "vertical",
-      role: "elbow",
-      style: s ? { left: E(t - 0.5), top: "0", height: "50%" } : { left: E(t - 0.5), top: "0", bottom: "0" }
-    });
-    const r = i + e * a, L = c ? Math.max(t + 5, r - 2) : l(e) + I;
-    n.push({
-      key: `branch-${e}`,
-      orientation: "horizontal",
-      role: "branch",
-      style: {
-        left: E(t - 0.5),
-        top: `calc(50% - ${0.5}px)`,
-        width: E(Math.max(0, L - t))
-      }
-    });
+    const t = _(e - 1);
+    T.push(
+      c({
+        key: `elbow-${e}`,
+        orientation: "vertical",
+        role: "elbow",
+        style: c(
+          o ? { left: f(t - i), top: "0", height: "50%" } : { left: f(t - i), top: "0", bottom: "0" }
+        )
+      })
+    );
+    const A = l + e * r;
+    let L;
+    a ? L = A - N : p ? L = _(e) + g : L = A + u - N;
+    const F = Math.max(t + y, L);
+    T.push(
+      c({
+        key: `branch-${e}`,
+        orientation: "horizontal",
+        role: "branch",
+        style: c({
+          left: f(t - i),
+          top: `calc(50% - ${i}px)`,
+          width: f(Math.max(0, F - t))
+        })
+      })
+    );
   }
-  return n;
+  return M(d, T);
 }
 export {
-  F as DEFAULT_TOGGLE_SIZE,
-  p as DEFAULT_TREE_CONTENT_GAP,
-  A as DEFAULT_TREE_INDENT,
-  h as DEFAULT_TREE_LEADING,
-  R as buildTreeConnectorSegments,
-  N as railX
+  C as DEFAULT_TOGGLE_SIZE,
+  H as DEFAULT_TREE_CONTENT_GAP,
+  I as DEFAULT_TREE_INDENT,
+  w as DEFAULT_TREE_LEADING,
+  O as DEFAULT_TREE_LEAF_INSET,
+  k as EMPTY_ANCESTOR_LAST_FLAGS,
+  v as appendAncestorLastFlag,
+  U as buildTreeConnectorSegments,
+  R as railX,
+  x as stabilizeAncestorLastFlags
 };

package/components/TreeConnectors/index.d.ts

@@ -1,3 +1,3 @@
 export { default as TreeConnectors } from './TreeConnectors.vue';
-export { buildTreeConnectorSegments, railX, guideX, DEFAULT_TREE_INDENT, DEFAULT_TOGGLE_SIZE, DEFAULT_TREE_LEADING, DEFAULT_TREE_CONTENT_GAP, } from './geometry';
+export { buildTreeConnectorSegments, railX, guideX, stabilizeAncestorLastFlags, appendAncestorLastFlag, EMPTY_ANCESTOR_LAST_FLAGS, DEFAULT_TREE_INDENT, DEFAULT_TOGGLE_SIZE, DEFAULT_TREE_LEADING, DEFAULT_TREE_CONTENT_GAP, DEFAULT_TREE_LEAF_INSET, } from './geometry';
 export type { TreeConnectorInput, TreeConnectorSegment, TreeConnectorStyle, TreeConnectorOrientation, TreeConnectorRole, } from './geometry';