vlite3 1.5.1 → 1.5.4

package/components/Kanban/Kanban.vue2.js

@@ -1,6 +1,7 @@
-import { defineComponent as G, ref as K, watch as U, openBlock as C, createElementBlock as P, normalizeClass as j, Fragment as q, renderList as w, createBlock as z, withCtx as v, renderSlot as g, mergeProps as h } from "vue";
-import F from "./KanbanBoard.vue.js";
-const T = /* @__PURE__ */ G({
+import { defineComponent as G, ref as p, watch as S, openBlock as D, createElementBlock as B, normalizeClass as U, Fragment as V, renderList as q, createBlock as z, withCtx as g, renderSlot as C, mergeProps as h } from "vue";
+import E from "./KanbanBoard.vue.js";
+import { groupKanbanRawData as R } from "./groupKanbanData.js";
+const Q = /* @__PURE__ */ G({
   __name: "Kanban",
   props: {
     columns: {},
@@ -11,6 +12,11 @@ const T = /* @__PURE__ */ G({
     rawData: {},
     groupKey: { default: "status" },
     positionKey: { default: "position" },
+    emptyColumnId: {},
+    unmappedColumnId: {},
+    includeOrphanColumns: { type: Boolean, default: !0 },
+    emptyColumnTitle: {},
+    unmappedColumnTitle: {},
     boardClass: {},
     headerClass: {},
     bodyClass: {},
@@ -21,108 +27,123 @@ const T = /* @__PURE__ */ G({
     onItemMoved: {}
   },
   emits: ["change", "move", "update:data", "item-move-failed"],
-  setup(l, { emit: B }) {
-    const s = l, c = B, u = K({}), d = K({}), p = K(!1);
-    U(
-      [() => s.data, () => s.rawData],
-      ([e, a]) => {
-        if (!p.value)
-          if (a && Array.isArray(a)) {
-            const o = {};
-            s.columns.forEach((t) => o[t.id] = []), a.forEach((t) => {
-              const i = t[s.groupKey];
-              o[i] ? o[i].push({ ...t }) : o[i] = [{ ...t }];
-            }), Object.keys(o).forEach((t) => {
-              o[t].sort((i, r) => (i[s.positionKey] || 0) - (r[s.positionKey] || 0));
-            }), d.value = o;
-          } else e && (d.value = { ...e });
+  setup(i, { emit: T }) {
+    const t = i, c = T, r = p({}), d = p({}), f = p([]), y = p(!1), A = (e) => {
+      const o = R(
+        e,
+        t.columns,
+        t.groupKey,
+        t.positionKey,
+        {
+          emptyColumnId: t.emptyColumnId,
+          unmappedColumnId: t.unmappedColumnId,
+          includeOrphanColumns: t.includeOrphanColumns,
+          emptyColumnTitle: t.emptyColumnTitle,
+          unmappedColumnTitle: t.unmappedColumnTitle
+        }
+      );
+      d.value = o.grouped, f.value = o.columns;
+    };
+    S(
+      [
+        () => t.data,
+        () => t.rawData,
+        () => t.columns,
+        () => t.groupKey,
+        () => t.positionKey,
+        () => t.emptyColumnId,
+        () => t.unmappedColumnId,
+        () => t.includeOrphanColumns
+      ],
+      ([e, o]) => {
+        y.value || (o && Array.isArray(o) ? A(o) : e ? (d.value = { ...e }, f.value = [...t.columns || []]) : (d.value = {}, f.value = [...t.columns || []]));
       },
       { immediate: !0, deep: !0 }
     );
-    const A = (e, a) => {
-      let o = 0, t = 0;
-      return a > 0 && (o = Number(e[a - 1]?.[s.positionKey]) || 0), a < e.length - 1 && (t = Number(e[a + 1]?.[s.positionKey]) || 0), o === 0 && t === 0 ? 1024 : o === 0 ? t / 2 : t === 0 ? o + 1024 : (o + t) / 2;
-    }, E = (e) => {
-      p.value = !0;
+    const O = (e, o) => {
+      let n = 0, a = 0;
+      return o > 0 && (n = Number(e[o - 1]?.[t.positionKey]) || 0), o < e.length - 1 && (a = Number(e[o + 1]?.[t.positionKey]) || 0), n === 0 && a === 0 ? 1024 : n === 0 ? a / 2 : a === 0 ? n + 1024 : (n + a) / 2;
+    }, $ = (e) => {
+      y.value = !0;
       try {
-        const a = s.itemKey, o = { ...d.value }, t = [...o[e.toColumnId] || []];
-        let i = t.find((n) => n?.[a] === e.itemId) || e.item;
-        const r = t.findIndex((n) => n?.[a] === e.itemId);
-        if (r >= 0)
-          i = t.splice(r, 1)[0];
+        const o = t.itemKey, n = { ...d.value }, a = [...n[e.toColumnId] || []];
+        let u = a.find((l) => l?.[o] === e.itemId) || e.item;
+        const s = a.findIndex((l) => l?.[o] === e.itemId);
+        if (s >= 0)
+          u = a.splice(s, 1)[0];
         else if (e.fromColumnId === e.toColumnId) {
-          const n = t.findIndex((m) => m?.[a] === e.itemId);
-          n >= 0 && (i = t.splice(n, 1)[0]);
+          const l = a.findIndex((m) => m?.[o] === e.itemId);
+          l >= 0 && (u = a.splice(l, 1)[0]);
         }
-        if (!i) return;
-        if (i[s.positionKey] = e.previousPosition, i[s.groupKey] = e.previousGroupValue, e.fromColumnId === e.toColumnId) {
-          const n = Math.min(Math.max(e.oldIndex, 0), t.length);
-          t.splice(n, 0, i), o[e.toColumnId] = t;
+        if (!u) return;
+        if (u[t.positionKey] = e.previousPosition, u[t.groupKey] = e.previousGroupValue, e.fromColumnId === e.toColumnId) {
+          const l = Math.min(Math.max(e.oldIndex, 0), a.length);
+          a.splice(l, 0, u), n[e.toColumnId] = a;
         } else {
-          o[e.toColumnId] = t;
-          const n = [...o[e.fromColumnId] || []], m = n.findIndex((f) => f?.[a] === e.itemId);
-          m >= 0 && n.splice(m, 1);
-          const I = Math.min(Math.max(e.oldIndex, 0), n.length);
-          n.splice(I, 0, i), o[e.fromColumnId] = n;
+          n[e.toColumnId] = a;
+          const l = [...n[e.fromColumnId] || []], m = l.findIndex((v) => v?.[o] === e.itemId);
+          m >= 0 && l.splice(m, 1);
+          const b = Math.min(Math.max(e.oldIndex, 0), l.length);
+          l.splice(b, 0, u), n[e.fromColumnId] = l;
         }
-        d.value = o, s.data && c("update:data", { ...o });
+        d.value = n, t.data && c("update:data", { ...n });
       } finally {
         queueMicrotask(() => {
-          p.value = !1;
+          y.value = !1;
         });
       }
-    }, k = async (e, a, o, t) => {
-      const i = d.value[e];
-      if (!i) return;
-      const r = i[a];
-      if (!r) return;
-      const n = r[s.itemKey], m = r[s.positionKey], I = r[s.groupKey], f = A(i, a);
-      r[s.positionKey] = f, r[s.groupKey] = e;
-      const y = () => E({
-        itemId: n,
-        item: r,
-        fromColumnId: o,
+    }, k = async (e, o, n, a) => {
+      const u = d.value[e];
+      if (!u) return;
+      const s = u[o];
+      if (!s) return;
+      const l = s[t.itemKey], m = s[t.positionKey], b = s[t.groupKey], v = O(u, o);
+      s[t.positionKey] = v, s[t.groupKey] = e;
+      const K = () => $({
+        itemId: l,
+        item: s,
+        fromColumnId: n,
         toColumnId: e,
-        oldIndex: t,
+        oldIndex: a,
         previousPosition: m,
-        previousGroupValue: I
-      }), V = {
-        fromColumnId: o,
-        oldIndex: t,
-        newIndex: a,
+        previousGroupValue: b
+      }), F = {
+        fromColumnId: n,
+        oldIndex: a,
+        newIndex: o,
         previousPosition: m,
-        revert: y
+        revert: K
       };
       c("move", {
-        itemId: n,
-        item: r,
-        fromColumnId: o,
+        itemId: l,
+        item: s,
+        fromColumnId: n,
         toColumnId: e,
-        oldIndex: t,
-        newIndex: a
+        oldIndex: a,
+        newIndex: o
       });
-      const D = s.onItemMoved;
-      if (D)
+      const M = t.onItemMoved;
+      if (M)
         try {
-          await D(n, e, f, r, V) === !1 && y();
-        } catch (M) {
-          y(), c("item-move-failed", {
-            itemId: n,
+          await M(l, e, v, s, F) === !1 && K();
+        } catch (P) {
+          K(), c("item-move-failed", {
+            itemId: l,
             toColumnId: e,
-            fromColumnId: o,
-            newPosition: f,
-            item: r,
-            error: M
+            fromColumnId: n,
+            newPosition: v,
+            item: s,
+            error: P
           });
         }
-    }, b = (e) => s.columns.find((a) => a.id === e)?.disabled === !0, $ = (e) => {
+    }, I = (e) => f.value.find((o) => o.id === e)?.disabled === !0, w = (e) => {
       if (c("change", e), e.type === "remove")
-        u.value.remove = { columnId: e.columnId, event: e.event };
+        r.value.remove = { columnId: e.columnId, event: e.event };
       else if (e.type === "add")
-        u.value.add = { columnId: e.columnId, event: e.event };
+        r.value.add = { columnId: e.columnId, event: e.event };
       else if (e.type === "update") {
-        if (b(e.columnId)) {
-          u.value = {};
+        if (I(e.columnId)) {
+          r.value = {};
           return;
         }
         k(
@@ -132,58 +153,58 @@ const T = /* @__PURE__ */ G({
           e.event.oldIndex
         );
       }
-      if (u.value.remove && u.value.add) {
-        const { remove: a, add: o } = u.value;
-        if (b(a.columnId) || b(o.columnId)) {
-          u.value = {};
+      if (r.value.remove && r.value.add) {
+        const { remove: o, add: n } = r.value;
+        if (I(o.columnId) || I(n.columnId)) {
+          r.value = {};
           return;
         }
         k(
+          n.columnId,
+          n.event.newIndex,
           o.columnId,
-          o.event.newIndex,
-          a.columnId,
-          a.event.oldIndex
-        ), u.value = {};
+          o.event.oldIndex
+        ), r.value = {};
       }
       setTimeout(() => {
-        u.value = {};
+        r.value = {};
       }, 100);
-    }, L = (e, a) => {
-      d.value[e] = a, s.data && c("update:data", { ...s.data, [e]: a });
-    }, N = (e) => d.value[e] || [];
-    return (e, a) => (C(), P("div", {
-      class: j([
+    }, L = (e, o) => {
+      d.value[e] = o, t.data && c("update:data", { ...t.data, [e]: o });
+    }, N = (e) => d.value[e] || d.value[String(e)] || [];
+    return (e, o) => (D(), B("div", {
+      class: U([
         "flex gap-4 scrollbar-thin overflow-x-auto p-1 scrollbar-thin-x scrollable-container",
-        s.class
+        t.class
       ])
     }, [
-      (C(!0), P(q, null, w(l.columns, (o) => (C(), z(F, {
-        key: o.id,
-        column: o,
-        group: l.group,
-        "item-key": l.itemKey,
-        "load-data": l.loadData,
-        "column-data": N(o.id),
-        "board-class": l.boardClass,
-        "header-class": l.headerClass,
-        "body-class": l.bodyClass,
-        "draggable-class": l.draggableClass,
-        "ghost-class": l.ghostClass,
-        "is-item-disabled": l.isItemDisabled,
-        onChange: $,
-        "onUpdate:columnData": (t) => L(o.id, t)
+      (D(!0), B(V, null, q(f.value, (n) => (D(), z(E, {
+        key: n.id,
+        column: n,
+        group: i.group,
+        "item-key": i.itemKey,
+        "load-data": i.loadData,
+        "column-data": N(n.id),
+        "board-class": i.boardClass,
+        "header-class": i.headerClass,
+        "body-class": i.bodyClass,
+        "draggable-class": i.draggableClass,
+        "ghost-class": i.ghostClass,
+        "is-item-disabled": i.isItemDisabled,
+        onChange: w,
+        "onUpdate:columnData": (a) => L(n.id, a)
       }, {
-        header: v((t) => [
-          g(e.$slots, "column-header", h({ ref_for: !0 }, t), void 0, !0)
+        header: g((a) => [
+          C(e.$slots, "column-header", h({ ref_for: !0 }, a), void 0, !0)
         ]),
-        "prepend-item": v((t) => [
-          g(e.$slots, "prepend-item", h({ ref_for: !0 }, t), void 0, !0)
+        "prepend-item": g((a) => [
+          C(e.$slots, "prepend-item", h({ ref_for: !0 }, a), void 0, !0)
         ]),
-        item: v((t) => [
-          g(e.$slots, "item", h({ ref_for: !0 }, t), void 0, !0)
+        item: g((a) => [
+          C(e.$slots, "item", h({ ref_for: !0 }, a), void 0, !0)
         ]),
-        "append-item": v((t) => [
-          g(e.$slots, "append-item", h({ ref_for: !0 }, t), void 0, !0)
+        "append-item": g((a) => [
+          C(e.$slots, "append-item", h({ ref_for: !0 }, a), void 0, !0)
         ]),
         _: 3
       }, 8, ["column", "group", "item-key", "load-data", "column-data", "board-class", "header-class", "body-class", "draggable-class", "ghost-class", "is-item-disabled", "onUpdate:columnData"]))), 128))
@@ -191,5 +212,5 @@ const T = /* @__PURE__ */ G({
   }
 });
 export {
-  T as default
+  Q as default
 };

package/components/Kanban/groupKanbanData.d.ts

@@ -0,0 +1,36 @@
+import { KanbanColumn } from './types';
+/** Sentinel column id used when a group value is null/blank and no `emptyColumnId` is provided. */
+export declare const KANBAN_EMPTY_GROUP_KEY = "__kanban_empty__";
+/** Sentinel column id used when a group value is unmatched and orphans are collapsed. */
+export declare const KANBAN_UNMAPPED_GROUP_KEY = "__kanban_unmapped__";
+export interface GroupKanbanRawDataOptions {
+    /** Column id that receives null / blank group values. */
+    emptyColumnId?: string | number;
+    /** Column id that receives values that do not match any configured column. */
+    unmappedColumnId?: string | number;
+    /**
+     * When true (default), append columns for orphan group keys so cards never
+     * disappear from the board when `unmappedColumnId` is not provided.
+     */
+    includeOrphanColumns?: boolean;
+    emptyColumnTitle?: string;
+    unmappedColumnTitle?: string;
+}
+export interface GroupKanbanRawDataResult {
+    grouped: Record<string, any[]>;
+    columns: KanbanColumn[];
+}
+/**
+ * One consistent resolver for column ids and item group values.
+ * Trims strings and maps null/undefined to `''`.
+ */
+export declare function resolveKanbanGroupKey(value: unknown): string;
+/**
+ * Group a flat `rawData` array into column buckets.
+ *
+ * - Column ids and item values are matched via {@link resolveKanbanGroupKey}
+ *   (trim + case-insensitive).
+ * - Empty values land in `emptyColumnId` (or an auto empty column).
+ * - Unmatched values land in `unmappedColumnId`, or become orphan columns.
+ */
+export declare function groupKanbanRawData(rawData: any[] | null | undefined, columns: KanbanColumn[] | null | undefined, groupKey: string, positionKey: string, options?: GroupKanbanRawDataOptions): GroupKanbanRawDataResult;

package/components/Kanban/groupKanbanData.js

@@ -0,0 +1,72 @@
+const A = "__kanban_empty__", w = "__kanban_unmapped__";
+function I(s) {
+  return s == null ? "" : String(s).trim();
+}
+const i = (s) => I(s).toLowerCase();
+function K(s, _, S, g, u = {}) {
+  const m = Array.isArray(_) ? _ : [], p = u.includeOrphanColumns !== !1, o = u.emptyColumnId != null ? u.emptyColumnId : p ? A : void 0, c = u.unmappedColumnId, d = /* @__PURE__ */ new Map();
+  for (const e of m) {
+    const t = i(e.id);
+    d.has(t) || d.set(t, e.id);
+  }
+  const r = {};
+  for (const e of m)
+    r[String(e.id)] = [];
+  const y = /* @__PURE__ */ new Set();
+  let C = !1, h = !1;
+  for (const e of s || []) {
+    const t = I(e?.[S]);
+    let n;
+    if (t) {
+      const f = d.get(t.toLowerCase());
+      if (f !== void 0)
+        n = f;
+      else if (c != null)
+        n = c, d.has(i(n)) || (h = !0);
+      else if (p)
+        n = t, y.add(n);
+      else
+        continue;
+    } else {
+      if (o == null) continue;
+      n = o, d.has(i(n)) || (C = !0);
+    }
+    const a = String(n);
+    r[a] || (r[a] = []), r[a].push({ ...e });
+  }
+  for (const e of Object.keys(r))
+    r[e].sort((t, n) => {
+      const a = (Number(t?.[g]) || 0) - (Number(n?.[g]) || 0);
+      if (a !== 0) return a;
+      const f = new Date(n?.createdAt || 0).getTime() - new Date(t?.createdAt || 0).getTime();
+      return f !== 0 ? f : String(n?.id || "").localeCompare(String(t?.id || ""));
+    });
+  const l = [...m];
+  if (C && o != null && l.push({
+    id: o,
+    title: u.emptyColumnTitle || "Unmapped"
+  }), h && c != null && l.push({
+    id: c,
+    title: u.unmappedColumnTitle || "Unmapped"
+  }), p && c == null)
+    for (const e of y)
+      l.some(
+        (n) => i(n.id) === i(e)
+      ) || l.push({
+        id: e,
+        title: String(e)
+      });
+  if (o === A && !r[String(o)]?.length && !m.some((e) => i(e.id) === i(o))) {
+    const e = l.findIndex(
+      (t) => i(t.id) === i(o)
+    );
+    e >= 0 && l.splice(e, 1), delete r[String(o)];
+  }
+  return { grouped: r, columns: l };
+}
+export {
+  A as KANBAN_EMPTY_GROUP_KEY,
+  w as KANBAN_UNMAPPED_GROUP_KEY,
+  K as groupKanbanRawData,
+  I as resolveKanbanGroupKey
+};

package/components/Kanban/index.d.ts

@@ -2,3 +2,4 @@ export { default as Kanban } from './Kanban.vue';
 export { default as KanbanBoard } from './KanbanBoard.vue';
 export * from './types';
 export * from './useKanbanBoard';
+export * from './groupKanbanData';

package/components/Kanban/types.d.ts

@@ -77,6 +77,23 @@ export interface KanbanProps {
     rawData?: any[];
     groupKey?: string;
     positionKey?: string;
+    /**
+     * Column id that receives items whose group value is null / blank.
+     * When omitted, an auto "Unmapped" empty column is used (if orphans are enabled).
+     */
+    emptyColumnId?: string | number;
+    /**
+     * Column id that receives items whose group value does not match any column.
+     * Prefer providing this (plus a matching column) for a single Unmapped lane.
+     */
+    unmappedColumnId?: string | number;
+    /**
+     * When true (default), append columns for unmatched group values so cards
+     * never silently disappear after a `groupKey` / `columns` change.
+     */
+    includeOrphanColumns?: boolean;
+    emptyColumnTitle?: string;
+    unmappedColumnTitle?: string;
     boardClass?: string;
     headerClass?: string;
     bodyClass?: string;

package/components/NavbarCommandPalette.vue.js

@@ -3,7 +3,7 @@ import L from "./Icon.vue.js";
 import v from "./Modal.vue.js";
 import N from "./CommandPalette/CommandPaletteContent.vue.js";
 import { $t as U } from "../utils/i18n.js";
-/* empty css                                       */
+/* empty css                                      */
 const V = { class: "block truncate -text-fs-1.5" }, S = { class: "ms-auto inline-flex items-center gap-0.5 px-1.5 py-0.5 rounded text-[10px] font-mono font-medium border border-border/80 bg-background text-muted-foreground ms-1" }, A = /* @__PURE__ */ x({
   __name: "NavbarCommandPalette",
   props: {

package/components/PanZoomViewport/PanZoomViewport.vue.d.ts

@@ -151,10 +151,10 @@ declare const __VLS_component: import('vue').DefineComponent<PanZoomViewportProp
     disabled: boolean;
     modelValue: PanZoomViewportTransform;
     contentClass: string;
+    zoomStep: number;
     minScale: number;
     maxScale: number;
     keyboard: boolean;
-    zoomStep: number;
     wheelZoomSpeed: number;
     keyboardPanStep: number;
     fitPadding: number;

package/components/RichTextEditor/RichTextEditor.vue.js

@@ -1,9 +1,9 @@
 import { defineComponent as te, ref as v, shallowRef as ne, watch as oe, computed as h, onMounted as le, onUnmounted as ae, openBlock as C, createElementBlock as L, normalizeClass as re, toDisplayString as I, createCommentVNode as U, createElementVNode as w, createVNode as q, unref as a, normalizeStyle as ie } from "vue";
 /* empty css                         */
-import se from "./RichTextToolbar.vue2.js";
-/* empty css                    */
-import de from "./RichTextLinkPopover.vue2.js";
-/* empty css                        */
+import se from "./RichTextToolbar.vue.js";
+/* empty css                     */
+import de from "./RichTextLinkPopover.vue.js";
+/* empty css                         */
 import { useRichTextImageUpload as ue } from "./composables/useRichTextImageUpload.js";
 import { useRichTextLinks as ce } from "./composables/useRichTextLinks.js";
 const fe = ["aria-labelledby", "aria-describedby"], me = ["id", "for"], ve = { class: "rte-wrapper" }, ye = { class: "rte-body-wrap" }, ge = ["id", "contenteditable", "aria-label", "aria-readonly", "aria-disabled", "aria-invalid"], be = ["id"], Se = /* @__PURE__ */ te({

package/components/RichTextEditor/RichTextLinkPopover.vue3.js

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

package/components/RichTextEditor/RichTextToolbar.vue3.js

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