@vtable-guild/vtable-guild 2.9.0-alpha.1 → 2.9.0-alpha.2

package/dist/table/src/composables/useTableEdit.mjs

@@ -1,183 +1,400 @@
-import { shallowRef as x, getCurrentScope as O, onScopeDispose as V, computed as M } from "vue";
-import { snapshot as B } from "../utils/snapshot.mjs";
-function H(u) {
-  const r = x(/* @__PURE__ */ new Map()), g = x(/* @__PURE__ */ new Map()), c = x(/* @__PURE__ */ new Map()), s = x(/* @__PURE__ */ new Map()), a = u.clone ?? ((e) => B(e));
-  let d = !1;
-  function E(e) {
-    const t = typeof u.rowKey == "function" ? u.rowKey(e) : e[u.rowKey];
+import { shallowRef as N, toValue as F, watch as ne, getCurrentScope as oe, onScopeDispose as ae, computed as x, nextTick as se } from "vue";
+import { snapshot as Y } from "../utils/snapshot.mjs";
+import { stateEqual as ie } from "../utils/stateEqual.mjs";
+function fe(l) {
+  const i = N(/* @__PURE__ */ new Map()), M = N(/* @__PURE__ */ new Map()), m = N(/* @__PURE__ */ new Map()), p = N(/* @__PURE__ */ new Map()), S = N(), h = N(), o = l.clone ?? ((e) => Y(e));
+  let y = !1;
+  function g(e) {
+    const t = typeof l.rowKey == "function" ? l.rowKey(e) : e[l.rowKey];
     if (typeof t != "string" && typeof t != "number")
       throw new Error("useTableEdit requires a string or number row key");
     return t;
   }
-  function p(e) {
-    if (!g.value.has(e)) return;
-    const t = new Map(g.value);
-    t.delete(e), g.value = t;
+  function P() {
+    const e = [...h.value ?? F(l.dataSource) ?? []], t = /* @__PURE__ */ new Set();
+    for (const r of e) {
+      const s = g(r);
+      if (t.has(s)) throw new Error("useTableEdit requires unique source row keys");
+      t.add(s);
+    }
+    return e;
   }
-  function P(e, t) {
-    g.value = new Map(g.value).set(e, t);
+  function I(e) {
+    const t = h.value, r = e.map(o);
+    h.value = r;
     try {
-      u.onError?.(t, e);
+      l.onChange(e);
+    } catch (s) {
+      throw h.value === r && (h.value = t), s;
+    } finally {
+      se(() => {
+        h.value === r && (h.value = void 0, b());
+      });
+    }
+  }
+  function b() {
+    const e = S.value;
+    e && (S.value = void 0, e.controller.abort(), e.resolve({ valid: !1, errors: /* @__PURE__ */ new Map(), obsolete: !0 }));
+  }
+  function B(e, t, r) {
+    return {
+      key: e,
+      original: t.original === void 0 ? void 0 : o(t.original),
+      isNew: t.isNew,
+      signal: r
+    };
+  }
+  function G(e, t, r, s) {
+    const v = l.toDraft?.(o(e), {
+      key: t,
+      original: r === void 0 ? void 0 : o(r),
+      isNew: s
+    }) ?? e;
+    if (g(v) !== t) throw new Error("Converting an editor cannot change its row key");
+    return o(v);
+  }
+  function z(e, t, r) {
+    const s = o(t.draft), v = l.toValue?.(s, B(e, t, r)) ?? s;
+    if (g(v) !== e)
+      throw new Error("Converting a submission cannot change its row key");
+    return o(v);
+  }
+  function D(e, t = new AbortController().signal) {
+    const r = P(), s = new Set(r.map(g)), v = (d, u) => e ? z(d, u, t) : o(u.draft), f = r.map((d) => {
+      const u = g(d), n = i.value.get(u);
+      if (e && n?.isNew) throw new Error("A cached new row duplicates a source row key");
+      return n ? v(u, n) : o(d);
+    }), c = [], a = [];
+    for (const [d, u] of i.value) {
+      if (s.has(d)) continue;
+      const n = v(d, u);
+      u.position === "top" ? c.unshift(n) : a.push(n);
+    }
+    return [...c, ...f, ...a];
+  }
+  function K(e) {
+    if (!M.value.has(e)) return;
+    const t = new Map(M.value);
+    t.delete(e), M.value = t;
+  }
+  function q(e, t) {
+    M.value = new Map(M.value).set(e, t);
+    try {
+      l.onError?.(t, e);
     } catch {
     }
   }
-  function S(e) {
-    const t = c.value.get(e);
+  function R(e) {
+    const t = m.value.get(e);
     if (!t) return;
     t.controller.abort();
-    const n = new Map(c.value);
-    n.delete(e), c.value = n, t.resolve(void 0);
+    const r = new Map(m.value);
+    r.delete(e), m.value = r, t.resolve(void 0);
   }
-  function N(e) {
-    const t = s.value.get(e);
+  function T(e) {
+    const t = p.value.get(e);
     if (!t) return;
     t.controller.abort();
-    const n = new Map(s.value);
-    n.delete(e), s.value = n, t.resolve(!1);
+    const r = new Map(p.value);
+    r.delete(e), p.value = r, t.resolve(!1);
   }
-  function K(e) {
-    S(e), N(e);
-    const t = new Map(r.value);
-    t.delete(e), r.value = t, p(e);
+  function O(e) {
+    b(), R(e), T(e);
+    const t = new Map(i.value);
+    t.delete(e), i.value = t, K(e);
   }
-  function y(e) {
-    const t = s.value.get(e);
+  function H(e) {
+    const t = p.value.get(e);
     if (t) return t.promise;
-    const n = r.value.get(e);
-    if (d || !n) return Promise.resolve(!1);
-    if (S(e), p(e), !u.onCancel)
-      return K(e), Promise.resolve(!0);
-    let v;
-    const m = new Promise((o) => {
-      v = o;
-    }), i = { controller: new AbortController(), promise: m, resolve: v };
-    s.value = new Map(s.value).set(e, i);
-    const f = () => !d && s.value.get(e) === i;
+    const r = i.value.get(e);
+    if (y || !r) return Promise.resolve(!1);
+    if (b(), R(e), K(e), !l.onCancel)
+      return O(e), Promise.resolve(!0);
+    let s;
+    const v = new Promise((a) => {
+      s = a;
+    }), f = { controller: new AbortController(), promise: v, resolve: s };
+    p.value = new Map(p.value).set(e, f);
+    const c = () => !y && p.value.get(e) === f;
     return (async () => {
       try {
-        const o = await u.onCancel(a(n.draft), {
+        const a = await l.onCancel(o(r.draft), {
           key: e,
-          original: n.original === void 0 ? void 0 : a(n.original),
-          isNew: n.isNew,
-          signal: i.controller.signal
+          original: r.original === void 0 ? void 0 : o(r.original),
+          isNew: r.isNew,
+          signal: f.controller.signal
         });
-        if (!f() || o === !1) return;
-        i.resolve(!0), K(e);
-      } catch (o) {
-        if (!f()) return;
-        const b = {
+        if (!c() || a === !1) return;
+        f.resolve(!0), O(e);
+      } catch (a) {
+        if (!c()) return;
+        const d = {
           type: "cancel",
-          message: o instanceof Error ? o.message : String(o),
-          cause: o
+          message: a instanceof Error ? a.message : String(a),
+          cause: a
         };
-        P(e, b);
+        q(e, d);
       } finally {
-        if (f()) {
-          const o = new Map(s.value);
-          o.delete(e), s.value = o;
+        if (c()) {
+          const a = new Map(p.value);
+          a.delete(e), p.value = a;
         }
-        i.resolve(!1);
+        f.resolve(!1);
+      }
+    })(), v;
+  }
+  function Z() {
+    return Promise.all([...i.value.keys()].map(H));
+  }
+  function J(e, t, r = "bottom") {
+    if (y) return !1;
+    const s = g(e);
+    if (i.value.has(s) || l.mode !== "multiple" && i.value.size > 0) return !1;
+    const v = t ? void 0 : o(e), f = G(e, s, v, t);
+    return b(), i.value = new Map(i.value).set(s, {
+      draft: f,
+      original: v,
+      isNew: t,
+      position: r
+    }), !0;
+  }
+  function _(e, t = {}) {
+    if (y || l.mode !== "multiple" && i.value.size > 0) return !1;
+    const r = P(), s = new Set(r.map(g)), v = s.size + [...i.value.keys()].filter((n) => !s.has(n)).length, f = Number.isFinite(l.maxRows) ? Math.max(0, Math.floor(l.maxRows)) : void 0;
+    if (f !== void 0 && v >= f) return !1;
+    const c = e ?? l.createRecord?.();
+    if (!c) return !1;
+    const a = g(c);
+    if (s.has(a) || i.value.has(a)) return !1;
+    const d = t.mode === "source";
+    if (d && (l.dataSource === void 0 || !l.onChange)) return !1;
+    const u = t.position ?? "bottom";
+    if (!J(c, !d, u)) return !1;
+    if (d)
+      try {
+        const n = r.map(o);
+        u === "top" ? n.unshift(o(c)) : n.push(o(c)), I(n);
+      } catch (n) {
+        return O(a), q(a, {
+          type: "save",
+          message: n instanceof Error ? n.message : String(n),
+          cause: n
+        }), !1;
       }
-    })(), m;
-  }
-  function T() {
-    return Promise.all([...r.value.keys()].map(y));
-  }
-  function A(e, t) {
-    if (d) return !1;
-    const n = E(e);
-    return r.value.has(n) || u.mode !== "multiple" && r.value.size > 0 ? !1 : (r.value = new Map(r.value).set(n, {
-      draft: a(e),
-      original: t ? void 0 : a(e),
-      isNew: t
-    }), !0);
-  }
-  function j(e, t) {
-    const n = r.value.get(e);
-    if (d || !n) return !1;
-    const v = typeof t == "function" ? t(a(n.draft)) : { ...a(n.draft), ...t };
-    if (E(v) !== e) throw new Error("Editing a row key is unsupported");
-    return S(e), N(e), p(e), r.value = new Map(r.value).set(e, { ...n, draft: a(v) }), !0;
-  }
-  function q(e) {
-    const t = c.value.get(e);
+    return !0;
+  }
+  function $(e, t) {
+    const r = i.value.get(e);
+    if (y || !r) return !1;
+    const s = typeof t == "function" ? t(o(r.draft)) : { ...o(r.draft), ...t };
+    if (g(s) !== e) throw new Error("Editing a row key is unsupported");
+    return b(), R(e), T(e), K(e), i.value = new Map(i.value).set(e, { ...r, draft: o(s) }), !0;
+  }
+  function ee(e) {
+    const t = m.value.get(e);
     if (t) return t.promise;
-    const n = r.value.get(e);
-    if (d || !n || s.value.has(e)) return Promise.resolve(void 0);
-    p(e);
-    let v;
-    const m = new Promise((w) => {
-      v = w;
-    }), i = { controller: new AbortController(), promise: m, resolve: v };
-    c.value = new Map(c.value).set(e, i);
-    const f = () => !d && c.value.get(e) === i, o = {
+    const r = i.value.get(e);
+    if (y || !r || p.value.has(e)) return Promise.resolve(void 0);
+    b(), K(e);
+    let s;
+    const v = new Promise((u) => {
+      s = u;
+    }), f = { controller: new AbortController(), promise: v, resolve: s };
+    m.value = new Map(m.value).set(e, f);
+    const c = () => !y && m.value.get(e) === f, a = {
       key: e,
-      original: n.original === void 0 ? void 0 : a(n.original),
-      isNew: n.isNew,
-      signal: i.controller.signal
-    }, b = (w) => {
-      f() && P(e, w);
+      original: r.original === void 0 ? void 0 : o(r.original),
+      isNew: r.isNew,
+      signal: f.controller.signal
+    }, d = (u) => {
+      c() && q(e, u);
     };
     return (async () => {
-      let w = "validation";
+      let u = "validation";
       try {
-        const l = a(n.draft), h = await u.validate?.(a(l), o);
-        if (!f()) return;
-        if (h?.message || Object.keys(h?.fields ?? {}).length > 0) {
-          b({
-            ...h,
+        const n = o(r.draft), w = await l.validate?.(o(n), a);
+        if (!c()) return;
+        if (w?.message || Object.keys(w?.fields ?? {}).length > 0) {
+          d({
+            ...w,
             type: "validation",
-            message: h?.message ?? "Validation failed"
+            message: w?.message ?? "Validation failed"
           });
           return;
         }
-        w = "save";
-        const C = await u.onSave?.(a(l), o);
-        if (!f() || C === !1) return;
-        const D = C === !0 ? l : C ?? l;
-        if (!n.isNew && E(D) !== e)
+        u = "save";
+        const E = z(e, { ...r, draft: n }, a.signal), j = await l.onSave?.(o(E), a);
+        if (!c() || j === !1) return;
+        const U = j === !0 ? E : j ?? E;
+        if (!r.isNew && g(U) !== e)
           throw new Error("Saving an existing row cannot change its key");
-        const z = a(D), R = new Map(r.value);
-        R.delete(e), r.value = R, p(e), i.resolve(z);
-      } catch (l) {
-        b({
-          type: w,
-          message: l instanceof Error ? l.message : String(l),
-          cause: l
+        const A = o(U), k = g(A);
+        if (k !== e && i.value.has(k))
+          throw new Error("Saving a new row cannot duplicate another draft row key");
+        if (l.dataSource !== void 0 && l.onChange) {
+          const C = P().map(o);
+          if (r.isNew && C.some((V) => g(V) === e || g(V) === k))
+            throw new Error("Saving a new row cannot duplicate a source row key");
+          const X = C.findIndex((V) => g(V) === e);
+          if (X >= 0 ? C[X] = o(A) : r.position === "top" ? C.unshift(o(A)) : C.push(o(A)), I(C), !c()) return;
+        }
+        b();
+        const W = new Map(i.value);
+        W.delete(e), i.value = W, K(e), f.resolve(A);
+      } catch (n) {
+        d({
+          type: u,
+          message: n instanceof Error ? n.message : String(n),
+          cause: n
         });
       } finally {
-        if (f()) {
-          const l = new Map(c.value);
-          l.delete(e), c.value = l;
+        if (c()) {
+          const n = new Map(m.value);
+          n.delete(e), m.value = n;
         }
-        i.resolve(void 0);
+        f.resolve(void 0);
       }
-    })(), m;
+    })(), v;
   }
-  return O() && V(() => {
-    d = !0;
-    for (const e of r.value.keys()) K(e);
+  function te() {
+    if (y) return Promise.resolve({ valid: !1, errors: /* @__PURE__ */ new Map(), obsolete: !0 });
+    if (S.value) return S.value.promise;
+    const e = D(!1), t = new Set(P().map(g)), r = e.map((a) => {
+      const d = g(a), u = i.value.get(d);
+      return {
+        key: d,
+        record: o(a),
+        entry: u ? {
+          ...u,
+          draft: o(u.draft),
+          original: u.original === void 0 ? void 0 : o(u.original)
+        } : void 0
+      };
+    });
+    let s;
+    const v = new Promise((a) => {
+      s = a;
+    }), f = { controller: new AbortController(), promise: v, resolve: s };
+    S.value = f;
+    const c = () => !y && S.value === f;
+    return (async () => {
+      const a = /* @__PURE__ */ new Map(), d = [];
+      for (const n of r) {
+        if (!c()) return;
+        try {
+          if (n.entry?.isNew && t.has(n.key))
+            throw new Error("A cached new row duplicates a source row key");
+          const w = n.entry ?? {
+            original: o(n.record),
+            draft: G(n.record, n.key, n.record, !1),
+            isNew: !1,
+            position: "bottom"
+          }, E = await l.validate?.(
+            o(w.draft),
+            B(n.key, w, f.controller.signal)
+          );
+          if (!c()) return;
+          (E?.message || Object.keys(E?.fields ?? {}).length) && a.set(n.key, {
+            ...E,
+            type: "validation",
+            message: E?.message ?? "Validation failed"
+          });
+        } catch (w) {
+          if (!c()) return;
+          a.set(n.key, {
+            type: "validation",
+            message: w instanceof Error ? w.message : String(w),
+            cause: w
+          });
+        }
+      }
+      if (!c()) return;
+      if (!a.size)
+        for (const n of r) {
+          try {
+            d.push(
+              n.entry ? z(n.key, n.entry, f.controller.signal) : o(n.record)
+            );
+          } catch (w) {
+            a.set(n.key, {
+              type: "validation",
+              message: w instanceof Error ? w.message : String(w),
+              cause: w
+            });
+          }
+          if (!c()) return;
+        }
+      if (!c()) return;
+      const u = new Map([...M.value].filter(([, n]) => n.type !== "validation"));
+      for (const [n, w] of a) u.set(n, w);
+      M.value = u;
+      for (const [n, w] of a) {
+        try {
+          l.onError?.(Y(w), n);
+        } catch {
+        }
+        if (!c()) return;
+      }
+      S.value = void 0, f.resolve({
+        valid: a.size === 0,
+        errors: new Map(a),
+        ...a.size ? {} : { values: d.map(o) }
+      });
+    })(), v;
+  }
+  function L() {
+    b(), h.value = void 0;
+    for (const e of m.value.keys()) R(e);
+    for (const e of p.value.keys()) T(e);
+    i.value = /* @__PURE__ */ new Map(), M.value = /* @__PURE__ */ new Map();
+  }
+  let Q = F(l.dataSource)?.map(o);
+  const re = l.dataSource === void 0 ? void 0 : ne(
+    () => F(l.dataSource),
+    (e) => {
+      h.value && (h.value = void 0, b()), !ie(Q, e) && (Q = e?.map(o), b());
+    },
+    { deep: !0, flush: "sync" }
+  );
+  return oe() && ae(() => {
+    y = !0, re?.(), L();
   }), {
-    editableKeys: M(() => [...r.value.keys()]),
-    savingKeys: M(() => new Set(c.value.keys())),
-    cancellingKeys: M(() => new Set(s.value.keys())),
-    errors: M(() => new Map(g.value)),
-    newRecords: M(
-      () => [...r.value.values()].filter((e) => e.isNew).map((e) => a(e.draft))
-    ),
-    isEditing: (e) => r.value.has(e),
+    records: x(() => D(!1)),
+    validating: x(() => !!S.value),
+    editableKeys: x(() => [...i.value.keys()]),
+    savingKeys: x(() => new Set(m.value.keys())),
+    cancellingKeys: x(() => new Set(p.value.keys())),
+    errors: x(() => new Map(M.value)),
+    newRecords: x(() => {
+      const e = [], t = [];
+      for (const r of i.value.values()) {
+        if (!r.isNew) continue;
+        const s = o(r.draft);
+        r.position === "top" ? e.unshift(s) : t.push(s);
+      }
+      return [...e, ...t];
+    }),
+    isEditing: (e) => i.value.has(e),
     getDraft: (e) => {
-      const t = r.value.get(e);
-      return t ? a(t.draft) : void 0;
+      const t = i.value.get(e);
+      return t ? o(t.draft) : void 0;
+    },
+    getOriginal: (e) => {
+      const t = i.value.get(e)?.original;
+      return t === void 0 ? void 0 : o(t);
     },
-    start: (e) => A(e, !1),
-    add: (e) => A(e, !0),
-    setDraft: j,
-    save: q,
-    cancel: y,
-    cancelAll: T
+    getDrafts: () => new Map([...i.value].map(([e, t]) => [e, o(t.draft)])),
+    getValues: () => D(!0),
+    validateAll: te,
+    reset: L,
+    start: (e) => J(e, !1),
+    add: _,
+    setDraft: $,
+    save: ee,
+    cancel: H,
+    cancelAll: Z
   };
 }
 export {
-  H as useTableEdit
+  fe as useTableEdit
 };

package/dist/table/src/composables/useTableEditable.d.ts

@@ -0,0 +1,4 @@
+import { UseTableEditableOptions, UseTableEditableReturn } from '../types/editable';
+/** Optional column-to-editor wiring on top of the same useTableEdit row state. */
+export declare function useTableEditable<T extends object>(options: UseTableEditableOptions<T>): UseTableEditableReturn<T>;
+//# sourceMappingURL=useTableEditable.d.ts.map

package/dist/table/src/composables/useTableEditable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTableEditable.d.ts","sourceRoot":"","sources":["../../../../../table/src/composables/useTableEditable.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,mBAAmB,CAAA;AAkB1B,kFAAkF;AAClF,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAC/C,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAClC,sBAAsB,CAAC,CAAC,CAAC,CAoJ3B"}

package/dist/table/src/composables/useTableEditable.mjs

@@ -0,0 +1,125 @@
+import { h as I, toValue as y } from "vue";
+import { useTableEdit as k } from "./useTableEdit.mjs";
+import { snapshot as T } from "../utils/snapshot.mjs";
+import { setField as h, getField as w } from "../utils/fieldPath.mjs";
+import K from "../components/TableEditableCell.mjs";
+import { valueEnumEntries as A } from "../utils/valueEnum.mjs";
+function E(s) {
+  return s.flatMap(
+    (c) => typeof c == "symbol" ? [] : "children" in c ? E(c.children) : [c]
+  );
+}
+function N(s) {
+  const c = s.clone ?? T, p = () => E(y(s.columns)).filter(
+    (e) => e.editor && e.dataIndex !== void 0
+  );
+  function g(e, t, r) {
+    return {
+      ...r,
+      name: Array.isArray(e.dataIndex) ? e.dataIndex.join(".") : String(e.dataIndex),
+      column: e,
+      draft: c(t),
+      original: r.original && c(r.original),
+      value: w(t, e.dataIndex)
+    };
+  }
+  function b(e, t, r) {
+    const n = c(e);
+    for (const a of p()) {
+      const l = a.editor, u = r ? l.transform : l.convertValue;
+      u && h(
+        n,
+        a.dataIndex,
+        u(w(n, a.dataIndex), g(a, n, t))
+      );
+    }
+    return n;
+  }
+  const f = k({
+    ...s,
+    toDraft: (e, t) => b(e, t, !1),
+    toValue: (e, t) => b(e, t, !0),
+    async validate(e, t) {
+      const r = {};
+      for (const n of p()) {
+        const a = n.editor, l = g(n, e, t), u = await a.validate?.(l.value, { ...l, signal: t.signal });
+        if (t.signal.aborted) return;
+        u && (r[l.name] = u);
+      }
+      return Object.keys(r).length ? { fields: r } : s.validate?.(e, t);
+    }
+  });
+  function x(e) {
+    return typeof s.rowKey == "function" ? s.rowKey(e) : e[s.rowKey];
+  }
+  function m(e) {
+    const t = x(e.record), r = f.getDraft(t), n = e.column.editor;
+    if (!r || !n || e.column.dataIndex === void 0) return;
+    const a = g(e.column, r, {
+      key: t,
+      original: f.getOriginal(t),
+      isNew: f.newRecords.value.some((o) => x(o) === t)
+    }), l = (o) => typeof o == "function" ? o(a) : o;
+    if (l(n.editable) === !1 || l(n.readonly)) return;
+    const u = [
+      ...y(n.options) ?? y(n.dictionary?.options) ?? A(e.column.valueEnum).flatMap(([o, i]) => {
+        const d = typeof i == "string" ? i : i.text;
+        return typeof d == "string" ? [{ value: o, label: d, ...typeof i == "object" ? { status: i.status } : {} }] : [];
+      })
+    ];
+    for (const o of Array.isArray(a.value) ? a.value : [a.value]) {
+      if (typeof o != "string" && typeof o != "number" && typeof o != "boolean" || u.some((v) => v.value === o))
+        continue;
+      const i = y(n.dictionary?.valueEnum)?.get(o), d = typeof i == "string" ? i : i?.text;
+      typeof d == "string" && u.push({ value: o, label: d });
+    }
+    return {
+      key: t,
+      column: e.column,
+      draft: r,
+      value: a.value,
+      valueType: n.valueType ?? (e.column.valueEnum ? "select" : e.column.valueType ?? "text"),
+      fieldProps: typeof n.fieldProps == "function" ? n.fieldProps(a) : n.fieldProps ?? {},
+      options: u,
+      onSearch: n.dictionary ? (o) => {
+        n.dictionary.search(o);
+      } : void 0,
+      loading: y(n.dictionary?.loading) ?? !1,
+      disabled: !!l(n.disabled) || f.savingKeys.value.has(t) || f.cancellingKeys.value.has(t),
+      readonly: !1,
+      error: f.errors.value.get(t)?.fields?.[a.name],
+      name: a.name,
+      mode: "edit",
+      onChange(o) {
+        const i = m(e);
+        i && !i.disabled && f.setDraft(t, (d) => {
+          h(d, e.column.dataIndex, o);
+          const v = n.onValueChange?.(
+            o,
+            g(e.column, d, {
+              key: t,
+              original: f.getOriginal(t),
+              isNew: a.isNew
+            })
+          );
+          return v ? { ...d, ...v } : d;
+        });
+      }
+    };
+  }
+  return {
+    ...f,
+    getCell: m,
+    renderEditor(e) {
+      const t = m(e);
+      return t ? I(K, {
+        context: t,
+        controls: y(s.controls),
+        ui: s.ui
+      }) : void 0;
+    }
+  };
+}
+export {
+  N as useTableEditable
+};

package/dist/table/src/composables/useTableEditable.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useTableEditable.test.d.ts.map

package/dist/table/src/composables/useTableEditable.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTableEditable.test.d.ts","sourceRoot":"","sources":["../../../../../table/src/composables/useTableEditable.test.ts"],"names":[],"mappings":""}