@oneflowui/ui 0.4.2 → 0.4.4

package/dist/composables/useColumnResize.js

@@ -0,0 +1,58 @@
+import { ref as o, onUnmounted as b, readonly as a } from "vue";
+function E(u) {
+  const d = u.minWidth ?? 60, m = o(!1), v = o(null), i = o(/* @__PURE__ */ new Map()), f = o(0), h = o(!1);
+  let n = null, y = "", W = "";
+  function X(e) {
+    if (i.value.has(e))
+      return i.value.get(e);
+    const t = u.columns.value.find((s) => s.key === e);
+    return !t || t.width === "fill" ? 200 : t.width ?? 200;
+  }
+  function w(e) {
+    var r;
+    if (!n) return;
+    const t = e.clientX - n.startX, s = Math.max(d, n.initialWidth + t), l = new Map(i.value);
+    l.set(n.colKey, s), i.value = l, f.value = e.clientX, (r = u.onResize) == null || r.call(u, n.colKey, s);
+  }
+  function z() {
+    n && (document.body.style.cursor = y, document.body.style.userSelect = W, document.removeEventListener("mousemove", w), document.removeEventListener("mouseup", z), m.value = !1, v.value = null, h.value = !1, n = null);
+  }
+  function R(e, t) {
+    e.preventDefault(), e.stopPropagation(), n = {
+      colKey: t,
+      startX: e.clientX,
+      initialWidth: X(t)
+    }, m.value = !0, v.value = t, f.value = e.clientX, h.value = !0, y = document.body.style.cursor, W = document.body.style.userSelect, document.body.style.cursor = "col-resize", document.body.style.userSelect = "none", document.addEventListener("mousemove", w), document.addEventListener("mouseup", z);
+  }
+  function g(e) {
+    return X(e);
+  }
+  function C(e, t) {
+    var r;
+    if (!t) return;
+    const s = t.querySelectorAll(`[data-col-key="${e}"]`);
+    let l = d;
+    if (s.forEach((c) => {
+      const M = c.firstElementChild;
+      M && (l = Math.max(l, M.scrollWidth + 24));
+    }), l > d) {
+      const c = new Map(i.value);
+      c.set(e, l), i.value = c, (r = u.onResize) == null || r.call(u, e, l);
+    }
+  }
+  return b(() => {
+    n && z();
+  }), {
+    startResize: R,
+    isResizing: a(m),
+    resizingColumn: a(v),
+    columnWidthOverrides: a(i),
+    resolvedWidth: g,
+    autoFitColumn: C,
+    resizeIndicatorX: a(f),
+    showResizeIndicator: a(h)
+  };
+}
+export {
+  E as useColumnResize
+};

package/dist/composables/useDraftRows.d.ts

@@ -0,0 +1,33 @@
+import { Ref } from 'vue';
+import { CellValue, DataRecord, TableSchema } from '../types';
+export interface UseDraftRowsOptions {
+    schema: Ref<TableSchema | undefined>;
+    groupFieldId?: Ref<string | undefined>;
+}
+export declare function useDraftRows(options: UseDraftRowsOptions): {
+    drafts: Readonly<Ref<ReadonlyMap<string, {
+        readonly draftId: string;
+        readonly fields: {
+            readonly [x: string]: string | number | boolean | readonly string[] | null;
+        };
+        readonly dirtyFields: ReadonlySet<string>;
+        readonly validationErrors: ReadonlyMap<string, string>;
+        readonly groupFieldValue?: string | number | boolean | readonly string[] | null | undefined;
+    }>, ReadonlyMap<string, {
+        readonly draftId: string;
+        readonly fields: {
+            readonly [x: string]: string | number | boolean | readonly string[] | null;
+        };
+        readonly dirtyFields: ReadonlySet<string>;
+        readonly validationErrors: ReadonlyMap<string, string>;
+        readonly groupFieldValue?: string | number | boolean | readonly string[] | null | undefined;
+    }>>>;
+    addDraft: (groupFieldValue?: CellValue) => string;
+    updateDraftField: (draftId: string, fieldId: string, value: CellValue) => void;
+    removeDraft: (draftId: string) => void;
+    commitDraft: (draftId: string) => DataRecord | null;
+    commitAll: () => DataRecord[];
+    discardAll: () => void;
+    isDraft: (rowId: string) => boolean;
+    getDraftErrors: (draftId: string) => Map<string, string>;
+};

package/dist/composables/useDraftRows.js

@@ -0,0 +1,103 @@
+import { ref as E, readonly as h } from "vue";
+let g = 0;
+function _() {
+  return `__draft__${++g}__${Date.now()}`;
+}
+function y(l) {
+  const n = E(/* @__PURE__ */ new Map());
+  function d(t) {
+    var i;
+    const e = _(), o = {}, r = l.schema.value;
+    if (r)
+      for (const D of r.fields)
+        o[D.id] = null;
+    const a = (i = l.groupFieldId) == null ? void 0 : i.value;
+    a && t !== void 0 && (o[a] = t);
+    const s = new Map(n.value);
+    return s.set(e, {
+      draftId: e,
+      fields: o,
+      dirtyFields: /* @__PURE__ */ new Set(),
+      validationErrors: /* @__PURE__ */ new Map(),
+      groupFieldValue: t
+    }), n.value = s, e;
+  }
+  function c(t, e, o) {
+    const r = n.value.get(t);
+    if (!r) return;
+    const a = new Map(n.value), s = {
+      ...r,
+      fields: { ...r.fields, [e]: o },
+      dirtyFields: /* @__PURE__ */ new Set([...r.dirtyFields, e])
+    };
+    if (r.validationErrors.has(e)) {
+      const i = new Map(r.validationErrors);
+      i.delete(e), s.validationErrors = i;
+    }
+    a.set(t, s), n.value = a;
+  }
+  function f(t) {
+    const e = new Map(n.value);
+    e.delete(t), n.value = e;
+  }
+  function v(t) {
+    const e = n.value.get(t);
+    if (!e) return null;
+    const o = u(e);
+    if (o.size > 0) {
+      const a = new Map(n.value);
+      return a.set(t, { ...e, validationErrors: o }), n.value = a, null;
+    }
+    const r = {
+      id: t,
+      // Consumer should replace with server-generated id
+      fields: { ...e.fields }
+    };
+    return f(t), r;
+  }
+  function w() {
+    const t = [], e = /* @__PURE__ */ new Map();
+    for (const [o, r] of n.value) {
+      const a = u(r);
+      a.size > 0 ? e.set(o, { ...r, validationErrors: a }) : t.push({
+        id: o,
+        fields: { ...r.fields }
+      });
+    }
+    return n.value = e, t;
+  }
+  function p() {
+    n.value = /* @__PURE__ */ new Map();
+  }
+  function m(t) {
+    return n.value.has(t);
+  }
+  function M(t) {
+    var e;
+    return ((e = n.value.get(t)) == null ? void 0 : e.validationErrors) ?? /* @__PURE__ */ new Map();
+  }
+  function u(t) {
+    const e = /* @__PURE__ */ new Map(), o = l.schema.value;
+    if (!o) return e;
+    for (const r of o.fields)
+      if (r.required) {
+        const a = t.fields[r.id];
+        (a == null || a === "") && e.set(r.id, `${r.name} 为必填项`);
+      }
+    return e;
+  }
+  return {
+    drafts: h(n),
+    addDraft: d,
+    updateDraftField: c,
+    removeDraft: f,
+    commitDraft: v,
+    commitAll: w,
+    discardAll: p,
+    isDraft: m,
+    getDraftErrors: M
+  };
+}
+export {
+  y as useDraftRows
+};

package/dist/composables/useFixedColumns.d.ts

@@ -0,0 +1,25 @@
+import { Ref, ComputedRef } from 'vue';
+import { TableColumn } from '../types';
+export interface UseFixedColumnsOptions {
+    columns: Ref<TableColumn[]>;
+    fixedColumnKeys: Ref<string[]>;
+    scrollContainerRef: Ref<HTMLElement | null>;
+    fixedContainerRef: Ref<HTMLElement | null>;
+    /** Width of the selector checkbox column (default 40) */
+    selectorWidth?: number;
+}
+export declare function useFixedColumns(options: UseFixedColumnsOptions): {
+    fixedColumns: ComputedRef<TableColumn[]>;
+    scrollableColumns: ComputedRef<TableColumn[]>;
+    fixedWidth: ComputedRef<number>;
+    handleScroll: (e: Event) => void;
+    handleFixedScroll: (e: Event) => void;
+    scrollLeft: Readonly<Ref<number, number>>;
+    syncHover: (rowId: string | null) => void;
+    isRowHovered: (rowId: string) => boolean;
+    hoverState: Readonly<Ref<{
+        readonly rowId: string | null;
+    }, {
+        readonly rowId: string | null;
+    }>>;
+};

package/dist/composables/useFixedColumns.js

@@ -0,0 +1,61 @@
+import { ref as f, computed as a, onUnmounted as w, readonly as d } from "vue";
+function A(n) {
+  const m = n.selectorWidth ?? 40, i = f(0), u = f({ rowId: null });
+  let o = null, r = null, c = null;
+  const s = a(() => {
+    const e = new Set(n.fixedColumnKeys.value);
+    return n.columns.value.filter((l) => e.has(l.key));
+  }), v = a(() => {
+    const e = new Set(n.fixedColumnKeys.value);
+    return n.columns.value.filter((l) => !e.has(l.key));
+  }), h = a(() => {
+    let e = m;
+    for (const l of s.value)
+      e += typeof l.width == "number" ? l.width : l.minWidth ?? 200;
+    return e;
+  });
+  function x(e) {
+    if (c === "fixed") {
+      c = null;
+      return;
+    }
+    const l = e.target;
+    i.value = l.scrollLeft, o !== null && cancelAnimationFrame(o), o = requestAnimationFrame(() => {
+      const t = n.fixedContainerRef.value;
+      t && t !== l && (c = "scroll", t.scrollTop = l.scrollTop), o = null;
+    });
+  }
+  function y(e) {
+    if (c === "scroll") {
+      c = null;
+      return;
+    }
+    const l = e.target;
+    r !== null && cancelAnimationFrame(r), r = requestAnimationFrame(() => {
+      const t = n.scrollContainerRef.value;
+      t && t !== l && (c = "fixed", t.scrollTop = l.scrollTop), r = null;
+    });
+  }
+  function F(e) {
+    u.value = { rowId: e };
+  }
+  function S(e) {
+    return u.value.rowId === e;
+  }
+  return w(() => {
+    o !== null && cancelAnimationFrame(o), r !== null && cancelAnimationFrame(r);
+  }), {
+    fixedColumns: s,
+    scrollableColumns: v,
+    fixedWidth: h,
+    handleScroll: x,
+    handleFixedScroll: y,
+    scrollLeft: d(i),
+    syncHover: F,
+    isRowHovered: S,
+    hoverState: d(u)
+  };
+}
+export {
+  A as useFixedColumns
+};

package/dist/composables/useFocusTrap.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Focus trap composable — 管理 dialog/drawer/panel 的焦点陷阱
+ *
+ * 返回 containerRef（绑到容器元素），activate() 打开时调用，deactivate() 关闭时调用。
+ */
+export declare function useFocusTrap(): {
+    containerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    activate: () => void;
+    deactivate: () => void;
+};

package/dist/composables/useFocusTrap.js

@@ -0,0 +1,37 @@
+import { ref as f, onBeforeUnmount as s, nextTick as d } from "vue";
+function v() {
+  const o = f(null);
+  let t = null;
+  function r() {
+    return o.value ? Array.from(
+      o.value.querySelectorAll(
+        'button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"]), a[href]'
+      )
+    ).filter((e) => !e.closest('[aria-hidden="true"]')) : [];
+  }
+  function u(e) {
+    if (e.key !== "Tab") return;
+    const n = r();
+    if (n.length === 0) {
+      e.preventDefault();
+      return;
+    }
+    const c = n[0], i = n[n.length - 1];
+    e.shiftKey ? document.activeElement === c && (e.preventDefault(), i.focus()) : document.activeElement === i && (e.preventDefault(), c.focus());
+  }
+  function l() {
+    t = document.activeElement, d(() => {
+      const e = r();
+      e.length && e[0].focus(), document.addEventListener("keydown", u);
+    });
+  }
+  function a() {
+    document.removeEventListener("keydown", u), t == null || t.focus(), t = null;
+  }
+  return s(() => {
+    document.removeEventListener("keydown", u);
+  }), { containerRef: o, activate: l, deactivate: a };
+}
+export {
+  v as useFocusTrap
+};

package/dist/composables/useInlineEdit.js

@@ -0,0 +1,28 @@
+import { ref as c, readonly as f } from "vue";
+function I() {
+  const n = c(null);
+  function o(e, l) {
+    n.value = { rowId: e, fieldId: l };
+  }
+  function r(e, l, u) {
+    var i, t;
+    return ((i = n.value) == null ? void 0 : i.rowId) === e && ((t = n.value) == null ? void 0 : t.fieldId) === l && (n.value = null), u;
+  }
+  function a() {
+    n.value = null;
+  }
+  function d(e, l) {
+    var u, i;
+    return ((u = n.value) == null ? void 0 : u.rowId) === e && ((i = n.value) == null ? void 0 : i.fieldId) === l;
+  }
+  return {
+    editingCell: f(n),
+    activate: o,
+    commit: r,
+    cancel: a,
+    isEditing: d
+  };
+}
+export {
+  I as useInlineEdit
+};

package/dist/composables/useKeyboardNavigation.d.ts

@@ -0,0 +1,45 @@
+import { Ref } from 'vue';
+import { TableColumn } from '../types';
+import { EditingCell } from './useInlineEdit';
+export interface UseKeyboardNavigationOptions {
+    columns: Ref<TableColumn[]>;
+    rows: Ref<Array<{
+        id: string;
+    } & Record<string, any>>>;
+    containerRef: Ref<HTMLElement | null>;
+    editingCell: Ref<EditingCell | null>;
+    enabled: Ref<boolean>;
+    /** Callback to activate inline edit on a cell */
+    onActivateEdit?: (rowId: string, colKey: string) => void;
+    /** Callback to cancel inline edit */
+    onCancelEdit?: () => void;
+    /** Callback to scroll a row into view */
+    onScrollToRow?: (rowIndex: number) => void;
+    /** Callback to get cell text value for copy (optional, enables Ctrl+C) */
+    getCellValue?: (rowId: string, colKey: string) => string;
+    /** Callback when paste data is received (optional, enables Ctrl+V) */
+    onPaste?: (startRowId: string, startColKey: string, data: string[][]) => void;
+}
+export interface SelectedCell {
+    rowId: string;
+    colKey: string;
+}
+export declare function useKeyboardNavigation(options: UseKeyboardNavigationOptions): {
+    activeCell: Readonly<Ref<{
+        readonly rowId: string;
+        readonly colKey: string;
+    } | null, {
+        readonly rowId: string;
+        readonly colKey: string;
+    } | null>>;
+    selectedRange: Readonly<Ref<readonly {
+        readonly rowId: string;
+        readonly colKey: string;
+    }[], readonly {
+        readonly rowId: string;
+        readonly colKey: string;
+    }[]>>;
+    setActiveCell: (rowId: string, colKey: string) => void;
+    clearActiveCell: () => void;
+    handleKeyDown: (e: KeyboardEvent) => void;
+};

package/dist/composables/useKeyboardNavigation.js

@@ -0,0 +1,140 @@
+import { ref as g, readonly as A } from "vue";
+function M(t) {
+  const l = g(null), i = g(null), s = g([]);
+  function k(e, a) {
+    l.value = { rowId: e, colKey: a }, i.value = null, s.value = [];
+  }
+  function m() {
+    l.value = null, i.value = null, s.value = [];
+  }
+  function h() {
+    return t.columns.value.filter((e) => !e.hidden);
+  }
+  function C(e, a) {
+    const n = t.rows.value, c = h(), r = n.findIndex((v) => v.id === e.rowId), u = c.findIndex((v) => v.key === e.colKey), o = n.findIndex((v) => v.id === a.rowId), y = c.findIndex((v) => v.key === a.colKey);
+    if (r === -1 || u === -1 || o === -1 || y === -1)
+      return [];
+    const I = Math.min(r, o), K = Math.max(r, o), d = Math.min(u, y), w = Math.max(u, y), f = [];
+    for (let v = I; v <= K; v++)
+      for (let x = d; x <= w; x++)
+        f.push({ rowId: n[v].id, colKey: c[x].key });
+    return f;
+  }
+  async function S() {
+    if (!t.getCellValue) return;
+    const e = s.value.length > 0 ? s.value : l.value ? [l.value] : [];
+    if (e.length === 0) return;
+    const a = t.rows.value, n = h(), c = [...new Set(e.map((d) => d.rowId))], r = [...new Set(e.map((d) => d.colKey))], u = c.sort((d, w) => a.findIndex((f) => f.id === d) - a.findIndex((f) => f.id === w)), o = r.sort((d, w) => n.findIndex((f) => f.key === d) - n.findIndex((f) => f.key === w)), y = new Set(e.map((d) => `${d.rowId}:${d.colKey}`)), I = [];
+    for (const d of u) {
+      const w = [];
+      for (const f of o)
+        y.has(`${d}:${f}`) ? w.push(t.getCellValue(d, f)) : w.push("");
+      I.push(w.join("	"));
+    }
+    const K = I.join(`
+`);
+    try {
+      await navigator.clipboard.writeText(K);
+    } catch {
+    }
+  }
+  async function E() {
+    if (!t.onPaste || !l.value) return;
+    let e;
+    try {
+      e = await navigator.clipboard.readText();
+    } catch {
+      return;
+    }
+    if (!e) return;
+    const a = e.split(/\r?\n/).filter((n) => n.length > 0).map((n) => n.split("	"));
+    a.length !== 0 && t.onPaste(l.value.rowId, l.value.colKey, a);
+  }
+  function T(e) {
+    var n, c, r;
+    if (!t.enabled.value) return;
+    if (t.editingCell.value !== null) {
+      if (e.key === "Escape") {
+        e.preventDefault(), (n = t.onCancelEdit) == null || n.call(t);
+        return;
+      }
+      if (e.key === "Tab") {
+        e.preventDefault(), (c = t.onCancelEdit) == null || c.call(t), R(e.shiftKey);
+        return;
+      }
+      return;
+    }
+    if ((e.ctrlKey || e.metaKey) && e.key === "c") {
+      e.preventDefault(), S();
+      return;
+    }
+    if ((e.ctrlKey || e.metaKey) && e.key === "v") {
+      e.preventDefault(), E();
+      return;
+    }
+    if (!l.value) {
+      if (["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(e.key)) {
+        e.preventDefault();
+        const u = t.rows.value, o = h();
+        u.length > 0 && o.length > 0 && k(u[0].id, o[0].key);
+      }
+      return;
+    }
+    switch (e.key) {
+      case "ArrowUp":
+        e.preventDefault(), D(-1, e.shiftKey);
+        break;
+      case "ArrowDown":
+        e.preventDefault(), D(1, e.shiftKey);
+        break;
+      case "ArrowLeft":
+        e.preventDefault(), b(-1, e.shiftKey);
+        break;
+      case "ArrowRight":
+        e.preventDefault(), b(1, e.shiftKey);
+        break;
+      case "Enter":
+        e.preventDefault(), l.value && ((r = t.onActivateEdit) == null || r.call(t, l.value.rowId, l.value.colKey));
+        break;
+      case "Escape":
+        e.preventDefault(), m();
+        break;
+      case "Tab":
+        e.preventDefault(), R(e.shiftKey);
+        break;
+    }
+  }
+  function D(e, a = !1) {
+    var u;
+    if (!l.value) return;
+    const n = t.rows.value, c = n.findIndex((o) => o.id === l.value.rowId);
+    if (c === -1) return;
+    const r = c + e;
+    r < 0 || r >= n.length || (a ? (i.value || (i.value = { rowId: l.value.rowId, colKey: l.value.colKey }), l.value = { rowId: n[r].id, colKey: l.value.colKey }, s.value = C(i.value, l.value)) : (i.value = null, s.value = [], l.value = { rowId: n[r].id, colKey: l.value.colKey }), (u = t.onScrollToRow) == null || u.call(t, r));
+  }
+  function b(e, a = !1) {
+    if (!l.value) return;
+    const n = h(), c = n.findIndex((u) => u.key === l.value.colKey);
+    if (c === -1) return;
+    const r = c + e;
+    r < 0 || r >= n.length || (a ? (i.value || (i.value = { rowId: l.value.rowId, colKey: l.value.colKey }), l.value = { rowId: l.value.rowId, colKey: n[r].key }, s.value = C(i.value, l.value)) : (i.value = null, s.value = [], l.value = { rowId: l.value.rowId, colKey: n[r].key }));
+  }
+  function R(e) {
+    var y;
+    if (!l.value) return;
+    const a = t.rows.value, n = h(), c = a.findIndex((I) => I.id === l.value.rowId), r = n.findIndex((I) => I.key === l.value.colKey);
+    if (c === -1 || r === -1) return;
+    let u = r + (e ? -1 : 1), o = c;
+    u >= n.length ? (u = 0, o++) : u < 0 && (u = n.length - 1, o--), !(o < 0 || o >= a.length) && (l.value = { rowId: a[o].id, colKey: n[u].key }, i.value = null, s.value = [], (y = t.onScrollToRow) == null || y.call(t, o));
+  }
+  return {
+    activeCell: A(l),
+    selectedRange: A(s),
+    setActiveCell: k,
+    clearActiveCell: m,
+    handleKeyDown: T
+  };
+}
+export {
+  M as useKeyboardNavigation
+};

package/dist/composables/useMarkdown.js

@@ -0,0 +1,69 @@
+import { marked as o } from "marked";
+import e from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/lib/core.js";
+import l from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/javascript.js";
+import p from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/typescript.js";
+import u from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/python.js";
+import n from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/bash.js";
+import j from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/json.js";
+import w from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/sql.js";
+import c from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/xml.js";
+import k from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/css.js";
+import f from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/markdown.js";
+import L from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/yaml.js";
+import $ from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/java.js";
+import q from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/go.js";
+import B from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/rust.js";
+import i from "../node_modules/.pnpm/highlight.js@11.11.1/node_modules/highlight.js/es/languages/plaintext.js";
+e.registerLanguage("plaintext", i);
+e.registerLanguage("text", i);
+e.registerLanguage("txt", i);
+e.registerLanguage("javascript", l);
+e.registerLanguage("js", l);
+e.registerLanguage("typescript", p);
+e.registerLanguage("ts", p);
+e.registerLanguage("python", u);
+e.registerLanguage("py", u);
+e.registerLanguage("bash", n);
+e.registerLanguage("sh", n);
+e.registerLanguage("shell", n);
+e.registerLanguage("json", j);
+e.registerLanguage("sql", w);
+e.registerLanguage("xml", c);
+e.registerLanguage("html", c);
+e.registerLanguage("css", k);
+e.registerLanguage("markdown", f);
+e.registerLanguage("md", f);
+e.registerLanguage("yaml", L);
+e.registerLanguage("yml", L);
+e.registerLanguage("java", $);
+e.registerLanguage("go", q);
+e.registerLanguage("rust", B);
+function Q(h = {}) {
+  const { showCopyButton: d = !1, t: y = (r) => r } = h, s = new o.Renderer();
+  s.code = function(r, x) {
+    const m = typeof r == "object" ? r.text || "" : r, t = typeof r == "object" ? r.lang || "" : x || "", a = t && e.getLanguage(t) ? t : "plaintext";
+    let g = "";
+    try {
+      g = e.highlight(m, { language: a }).value;
+    } catch {
+      g = e.highlight(m, { language: "plaintext" }).value;
+    }
+    const v = d ? `<button onclick="navigator.clipboard.writeText(this.parentElement.nextElementSibling.innerText)" class="of-markdown-copy-btn">${y("common.copy")}</button>` : "";
+    return `<div class="of-code-block-wrapper">
+    <div class="of-code-block-header">
+      <span class="of-code-block-lang">${a}</span>
+      ${v}
+    </div>
+    <pre class="of-code-block-pre"><code class="hljs language-${a}">${g}</code></pre>
+  </div>`;
+  }, o.use({ renderer: s });
+  function b(r) {
+    return o.parse(r);
+  }
+  return {
+    renderMarkdown: b
+  };
+}
+export {
+  Q as useMarkdown
+};

package/dist/composables/useRowDrag.d.ts

@@ -0,0 +1,32 @@
+import { Ref } from 'vue';
+import { GroupedListItem } from './useTableGroup';
+export interface UseRowDragOptions<T> {
+    /** The flattened items list (with group headers) */
+    processedItems: Ref<GroupedListItem<T>[]>;
+    /** Whether cross-group drag is allowed */
+    enableCrossGroupDrag?: Ref<boolean>;
+    /** The field id used for grouping (needed for cross-group value update) */
+    groupFieldId?: Ref<string | undefined>;
+}
+export interface RowReorderPayload {
+    rowId: string;
+    beforeRowId: string | null;
+}
+export interface RowGroupChangePayload {
+    rowId: string;
+    groupFieldId: string;
+    newValue: unknown;
+}
+export declare function useRowDrag<T extends Record<string, any>>(options: UseRowDragOptions<T>): {
+    isDragging: Readonly<Ref<boolean, boolean>>;
+    draggedRowId: Readonly<Ref<string | null, string | null>>;
+    dropTargetId: Readonly<Ref<string | null, string | null>>;
+    dropPosition: Readonly<Ref<"before" | "after" | "into-group", "before" | "after" | "into-group">>;
+    handleDragStart: (e: DragEvent, item: GroupedListItem<T>) => void;
+    handleDragOver: (e: DragEvent, targetItem: GroupedListItem<T>) => void;
+    handleDrop: (e: DragEvent, targetItem: GroupedListItem<T>, callbacks: {
+        onReorder?: (payload: RowReorderPayload) => void;
+        onGroupChange?: (payload: RowGroupChangePayload) => void;
+    }) => void;
+    handleDragEnd: () => void;
+};