vlite3 1.4.31 → 1.4.33

package/components/Kanban/Kanban.vue2.js

@@ -1,6 +1,6 @@
-import { defineComponent as D, ref as b, watch as k, openBlock as v, createElementBlock as h, normalizeClass as B, Fragment as w, renderList as P, createBlock as E, withCtx as i, renderSlot as m, mergeProps as c } from "vue";
-import $ from "./KanbanBoard.vue.js";
-const U = /* @__PURE__ */ D({
+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({
   __name: "Kanban",
   props: {
     columns: {},
@@ -17,109 +17,173 @@ const U = /* @__PURE__ */ D({
     draggableClass: {},
     ghostClass: {},
     class: { default: "h-full w-full" },
-    isItemDisabled: {}
+    isItemDisabled: {},
+    onItemMoved: {}
   },
-  emits: ["change", "move", "update:data", "item-moved"],
-  setup(s, { emit: I }) {
-    const o = s, d = I, r = b({}), u = b({});
-    k(
-      [() => o.data, () => o.rawData],
-      ([e, n]) => {
-        if (n && Array.isArray(n)) {
-          const t = {};
-          o.columns.forEach((a) => t[a.id] = []), n.forEach((a) => {
-            const l = a[o.groupKey];
-            t[l] ? t[l].push({ ...a }) : t[l] = [{ ...a }];
-          }), Object.keys(t).forEach((a) => {
-            t[a].sort((l, x) => (l[o.positionKey] || 0) - (x[o.positionKey] || 0));
-          }), u.value = t;
-        } else e && (u.value = { ...e });
+  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 });
       },
       { immediate: !0, deep: !0 }
     );
-    const C = (e, n) => {
-      let t = 0, a = 0;
-      return n > 0 && (t = Number(e[n - 1]?.[o.positionKey]) || 0), n < e.length - 1 && (a = Number(e[n + 1]?.[o.positionKey]) || 0), t === 0 && a === 0 ? 1024 : t === 0 ? a / 2 : a === 0 ? t + 1024 : (t + a) / 2;
-    }, g = (e, n) => {
-      const t = u.value[e];
-      if (!t) return;
-      const a = t[n];
-      if (!a) return;
-      const l = C(t, n);
-      a[o.positionKey] = l, a[o.groupKey] = e, d("item-moved", a[o.itemKey], e, l, a);
-    }, f = (e) => o.columns.find((n) => n.id === e)?.disabled === !0, K = (e) => {
-      if (d("change", e), e.type === "remove")
-        r.value.remove = { columnId: e.columnId, event: e.event };
+    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;
+      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];
+        else if (e.fromColumnId === e.toColumnId) {
+          const n = t.findIndex((m) => m?.[a] === e.itemId);
+          n >= 0 && (i = t.splice(n, 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;
+        } 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;
+        }
+        d.value = o, s.data && c("update:data", { ...o });
+      } finally {
+        queueMicrotask(() => {
+          p.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,
+        toColumnId: e,
+        oldIndex: t,
+        previousPosition: m,
+        previousGroupValue: I
+      }), V = {
+        fromColumnId: o,
+        oldIndex: t,
+        newIndex: a,
+        previousPosition: m,
+        revert: y
+      };
+      c("move", {
+        itemId: n,
+        item: r,
+        fromColumnId: o,
+        toColumnId: e,
+        oldIndex: t,
+        newIndex: a
+      });
+      const D = s.onItemMoved;
+      if (D)
+        try {
+          await D(n, e, f, r, V) === !1 && y();
+        } catch (M) {
+          y(), c("item-move-failed", {
+            itemId: n,
+            toColumnId: e,
+            fromColumnId: o,
+            newPosition: f,
+            item: r,
+            error: M
+          });
+        }
+    }, b = (e) => s.columns.find((a) => a.id === e)?.disabled === !0, $ = (e) => {
+      if (c("change", e), e.type === "remove")
+        u.value.remove = { columnId: e.columnId, event: e.event };
       else if (e.type === "add")
-        r.value.add = { columnId: e.columnId, event: e.event };
+        u.value.add = { columnId: e.columnId, event: e.event };
       else if (e.type === "update") {
-        if (f(e.columnId)) {
-          r.value = {};
+        if (b(e.columnId)) {
+          u.value = {};
           return;
         }
-        g(e.columnId, e.event.newIndex), d("move", {
-          itemId: e.event.data?.[o.itemKey] || e.event.item?._underlying_vm_?.[o.itemKey],
-          item: e.event.data,
-          fromColumnId: e.columnId,
-          toColumnId: e.columnId,
-          oldIndex: e.event.oldIndex,
-          newIndex: e.event.newIndex
-        });
+        k(
+          e.columnId,
+          e.event.newIndex,
+          e.columnId,
+          e.event.oldIndex
+        );
       }
-      if (r.value.remove && r.value.add) {
-        const { remove: n, add: t } = r.value;
-        if (f(n.columnId) || f(t.columnId)) {
-          r.value = {};
+      if (u.value.remove && u.value.add) {
+        const { remove: a, add: o } = u.value;
+        if (b(a.columnId) || b(o.columnId)) {
+          u.value = {};
           return;
         }
-        g(t.columnId, t.event.newIndex), d("move", {
-          itemId: t.event.data?.[o.itemKey],
-          item: t.event.data,
-          fromColumnId: n.columnId,
-          toColumnId: t.columnId,
-          oldIndex: n.event.oldIndex,
-          newIndex: t.event.newIndex
-        }), r.value = {};
+        k(
+          o.columnId,
+          o.event.newIndex,
+          a.columnId,
+          a.event.oldIndex
+        ), u.value = {};
       }
       setTimeout(() => {
-        r.value = {};
+        u.value = {};
       }, 100);
-    }, p = (e, n) => {
-      u.value[e] = n, o.data && d("update:data", { ...o.data, [e]: n });
-    }, y = (e) => u.value[e] || [];
-    return (e, n) => (v(), h("div", {
-      class: B([
+    }, 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([
         "flex gap-4 scrollbar-thin overflow-x-auto p-1 scrollbar-thin-x scrollable-container",
-        o.class
+        s.class
       ])
     }, [
-      (v(!0), h(w, null, P(s.columns, (t) => (v(), E($, {
-        key: t.id,
-        column: t,
-        group: s.group,
-        "item-key": s.itemKey,
-        "load-data": s.loadData,
-        "column-data": y(t.id),
-        "board-class": s.boardClass,
-        "header-class": s.headerClass,
-        "body-class": s.bodyClass,
-        "draggable-class": s.draggableClass,
-        "ghost-class": s.ghostClass,
-        "is-item-disabled": s.isItemDisabled,
-        onChange: K,
-        "onUpdate:columnData": (a) => p(t.id, a)
+      (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)
       }, {
-        header: i((a) => [
-          m(e.$slots, "column-header", c({ ref_for: !0 }, a), void 0, !0)
+        header: v((t) => [
+          g(e.$slots, "column-header", h({ ref_for: !0 }, t), void 0, !0)
         ]),
-        "prepend-item": i((a) => [
-          m(e.$slots, "prepend-item", c({ ref_for: !0 }, a), void 0, !0)
+        "prepend-item": v((t) => [
+          g(e.$slots, "prepend-item", h({ ref_for: !0 }, t), void 0, !0)
         ]),
-        item: i((a) => [
-          m(e.$slots, "item", c({ ref_for: !0 }, a), void 0, !0)
+        item: v((t) => [
+          g(e.$slots, "item", h({ ref_for: !0 }, t), void 0, !0)
         ]),
-        "append-item": i((a) => [
-          m(e.$slots, "append-item", c({ ref_for: !0 }, a), void 0, !0)
+        "append-item": v((t) => [
+          g(e.$slots, "append-item", h({ ref_for: !0 }, t), 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))
@@ -127,5 +191,5 @@ const U = /* @__PURE__ */ D({
   }
 });
 export {
-  U as default
+  T as default
 };

package/components/Kanban/types.d.ts

@@ -38,6 +38,36 @@ export interface KanbanMoveEvent {
     oldIndex: number;
     newIndex: number;
 }
+/**
+ * Extra context passed as the 5th argument to `onItemMoved` / `@item-moved`.
+ * `revert()` restores the card to its pre-drop column and index immediately.
+ */
+export interface KanbanItemMovedMeta {
+    fromColumnId: string | number;
+    oldIndex: number;
+    newIndex: number;
+    previousPosition: any;
+    /** Imperative escape hatch — usually unnecessary; the board auto-reverts on reject/false. */
+    revert: () => void;
+}
+/**
+ * Async move handler. Return a Promise that settles when the server confirms.
+ *
+ * - resolve / return `void` | `true` → keep the optimistic placement
+ * - return `false` → auto-revert the card to its previous column/index
+ * - reject / throw → auto-revert (same as `false`)
+ *
+ * Bound via `:on-item-moved` or `@item-moved` (both map to this prop).
+ */
+export type KanbanItemMovedHandler = (itemId: string | number, toColumnId: string | number, newPosition: number, item: any, meta: KanbanItemMovedMeta) => void | boolean | Promise<void | boolean>;
+export interface KanbanItemMoveFailedPayload {
+    itemId: string | number;
+    toColumnId: string | number;
+    fromColumnId: string | number;
+    newPosition: number;
+    item: any;
+    error: unknown;
+}
 export interface KanbanProps {
     columns: KanbanColumn[];
     group?: string;
@@ -61,4 +91,11 @@ export interface KanbanProps {
      * Example: :is-item-disabled="(item) => item.locked === true"
      */
     isItemDisabled?: (item: any) => boolean;
+    /**
+     * Called after an optimistic drop. Await a mutation here — if it rejects
+     * (or returns `false`), the board automatically moves the card back.
+     *
+     * Use `@item-moved` or `:on-item-moved` — both bind this prop.
+     */
+    onItemMoved?: KanbanItemMovedHandler;
 }

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: "ml-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 ml-1" }, A = /* @__PURE__ */ x({
   __name: "NavbarCommandPalette",
   props: {

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

@@ -0,0 +1,189 @@
+import { PanZoomViewportActionOptions, PanZoomViewportAlignment, PanZoomViewportChangeMeta, PanZoomViewportFitOptions, PanZoomViewportPanOptions, PanZoomViewportProps, PanZoomViewportSize, PanZoomViewportTransform, PanZoomViewportZoomAvailability, PanZoomViewportZoomOptions } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            transform: PanZoomViewportTransform;
+            viewportSize: PanZoomViewportSize;
+            contentSize: PanZoomViewportSize;
+            ready: boolean;
+            panning: boolean;
+            canZoomIn: boolean;
+            canZoomOut: boolean;
+        }): any;
+    };
+    refs: {
+        viewportRef: HTMLDivElement;
+        contentRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<PanZoomViewportProps, {
+    zoomIn: (options
+    /**
+     * Generic transform-only viewport for arbitrary slotted content.
+     *
+     * Gesture deltas arrive in visual/client pixels while the transform is written
+     * in this element's local CSS pixels. Every client-space operation therefore
+     * normalizes through getBoundingClientRect() / layout size so nested ancestor
+     * transforms and non-unity browser pixel ratios do not distort navigation.
+     *
+     * Performance (docs/6-performance.md): DOM nodes and replace-only geometry use
+     * shallowRef; translate/scale is painted directly onto the content layer each
+     * rAF; layout style objects keep stable identity when unchanged; both layers
+     * use will-change + contain; observers/frames/timers are cleared on unmount.
+     */
+    ?: PanZoomViewportZoomOptions) => void;
+    zoomOut: (options
+    /**
+     * Generic transform-only viewport for arbitrary slotted content.
+     *
+     * Gesture deltas arrive in visual/client pixels while the transform is written
+     * in this element's local CSS pixels. Every client-space operation therefore
+     * normalizes through getBoundingClientRect() / layout size so nested ancestor
+     * transforms and non-unity browser pixel ratios do not distort navigation.
+     *
+     * Performance (docs/6-performance.md): DOM nodes and replace-only geometry use
+     * shallowRef; translate/scale is painted directly onto the content layer each
+     * rAF; layout style objects keep stable identity when unchanged; both layers
+     * use will-change + contain; observers/frames/timers are cleared on unmount.
+     */
+    ?: PanZoomViewportZoomOptions) => void;
+    setScale: (scale: number, options
+    /**
+     * Generic transform-only viewport for arbitrary slotted content.
+     *
+     * Gesture deltas arrive in visual/client pixels while the transform is written
+     * in this element's local CSS pixels. Every client-space operation therefore
+     * normalizes through getBoundingClientRect() / layout size so nested ancestor
+     * transforms and non-unity browser pixel ratios do not distort navigation.
+     *
+     * Performance (docs/6-performance.md): DOM nodes and replace-only geometry use
+     * shallowRef; translate/scale is painted directly onto the content layer each
+     * rAF; layout style objects keep stable identity when unchanged; both layers
+     * use will-change + contain; observers/frames/timers are cleared on unmount.
+     */
+    ?: PanZoomViewportZoomOptions) => void;
+    setTransform: (transform: PanZoomViewportTransform, options
+    /**
+     * Generic transform-only viewport for arbitrary slotted content.
+     *
+     * Gesture deltas arrive in visual/client pixels while the transform is written
+     * in this element's local CSS pixels. Every client-space operation therefore
+     * normalizes through getBoundingClientRect() / layout size so nested ancestor
+     * transforms and non-unity browser pixel ratios do not distort navigation.
+     *
+     * Performance (docs/6-performance.md): DOM nodes and replace-only geometry use
+     * shallowRef; translate/scale is painted directly onto the content layer each
+     * rAF; layout style objects keep stable identity when unchanged; both layers
+     * use will-change + contain; observers/frames/timers are cleared on unmount.
+     */
+    ?: PanZoomViewportActionOptions) => void;
+    panBy: (deltaX: number, deltaY: number, options
+    /**
+     * Generic transform-only viewport for arbitrary slotted content.
+     *
+     * Gesture deltas arrive in visual/client pixels while the transform is written
+     * in this element's local CSS pixels. Every client-space operation therefore
+     * normalizes through getBoundingClientRect() / layout size so nested ancestor
+     * transforms and non-unity browser pixel ratios do not distort navigation.
+     *
+     * Performance (docs/6-performance.md): DOM nodes and replace-only geometry use
+     * shallowRef; translate/scale is painted directly onto the content layer each
+     * rAF; layout style objects keep stable identity when unchanged; both layers
+     * use will-change + contain; observers/frames/timers are cleared on unmount.
+     */
+    ?: PanZoomViewportPanOptions) => void;
+    reset: (options
+    /**
+     * Generic transform-only viewport for arbitrary slotted content.
+     *
+     * Gesture deltas arrive in visual/client pixels while the transform is written
+     * in this element's local CSS pixels. Every client-space operation therefore
+     * normalizes through getBoundingClientRect() / layout size so nested ancestor
+     * transforms and non-unity browser pixel ratios do not distort navigation.
+     *
+     * Performance (docs/6-performance.md): DOM nodes and replace-only geometry use
+     * shallowRef; translate/scale is painted directly onto the content layer each
+     * rAF; layout style objects keep stable identity when unchanged; both layers
+     * use will-change + contain; observers/frames/timers are cleared on unmount.
+     */
+    ?: PanZoomViewportActionOptions) => void;
+    fitToContent: (options
+    /**
+     * Generic transform-only viewport for arbitrary slotted content.
+     *
+     * Gesture deltas arrive in visual/client pixels while the transform is written
+     * in this element's local CSS pixels. Every client-space operation therefore
+     * normalizes through getBoundingClientRect() / layout size so nested ancestor
+     * transforms and non-unity browser pixel ratios do not distort navigation.
+     *
+     * Performance (docs/6-performance.md): DOM nodes and replace-only geometry use
+     * shallowRef; translate/scale is painted directly onto the content layer each
+     * rAF; layout style objects keep stable identity when unchanged; both layers
+     * use will-change + contain; observers/frames/timers are cleared on unmount.
+     */
+    ?: PanZoomViewportFitOptions) => boolean;
+    canZoomIn: () => boolean;
+    canZoomOut: () => boolean;
+    focus: () => void;
+    getViewportElement: () => HTMLElement | null;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: PanZoomViewportTransform, meta: PanZoomViewportChangeMeta) => any;
+    "update:modelValue": (value: PanZoomViewportTransform) => any;
+    "update:ready": (value: boolean) => any;
+    "update:viewportSize": (value: PanZoomViewportSize) => any;
+    "update:contentSize": (value: PanZoomViewportSize) => any;
+    "pan-start": () => any;
+    "pan-end": () => any;
+    "zoom-availability-change": (value: PanZoomViewportZoomAvailability) => any;
+}, string, import('vue').PublicProps, Readonly<PanZoomViewportProps> & Readonly<{
+    onChange?: (value: PanZoomViewportTransform, meta: PanZoomViewportChangeMeta) => any;
+    "onUpdate:modelValue"?: (value: PanZoomViewportTransform) => any;
+    "onUpdate:ready"?: (value: boolean) => any;
+    "onUpdate:viewportSize"?: (value: PanZoomViewportSize) => any;
+    "onUpdate:contentSize"?: (value: PanZoomViewportSize) => any;
+    "onPan-start"?: () => any;
+    "onPan-end"?: () => any;
+    "onZoom-availability-change"?: (value: PanZoomViewportZoomAvailability) => any;
+}>, {
+    disabled: boolean;
+    modelValue: PanZoomViewportTransform;
+    contentClass: string;
+    minScale: number;
+    maxScale: number;
+    keyboard: boolean;
+    zoomStep: number;
+    wheelZoomSpeed: number;
+    keyboardPanStep: number;
+    fitPadding: number;
+    fitMode: import('./types').PanZoomViewportFitMode;
+    fitAlignX: PanZoomViewportAlignment;
+    fitAlignY: PanZoomViewportAlignment;
+    initialFit: boolean;
+    autoFitOnResize: boolean;
+    zoomEnabled: boolean;
+    zoomInEnabled: boolean;
+    zoomOutEnabled: boolean;
+    panEnabled: boolean;
+    pointerPanEnabled: boolean;
+    wheelPanEnabled: boolean;
+    keyboardPanEnabled: boolean;
+    horizontalPanEnabled: boolean;
+    verticalPanEnabled: boolean;
+    panOnWheel: boolean;
+    wheelZoomMode: import('./types').PanZoomViewportWheelZoomMode;
+    panOnPrimaryDrag: boolean;
+    ariaLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    viewportRef: HTMLDivElement;
+    contentRef: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/PanZoomViewport/PanZoomViewport.vue.js

@@ -0,0 +1,7 @@
+import o from "./PanZoomViewport.vue2.js";
+/* empty css                     */
+import t from "../../_virtual/_plugin-vue_export-helper.js";
+const a = /* @__PURE__ */ t(o, [["__scopeId", "data-v-9dc36c93"]]);
+export {
+  a as default
+};