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

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

@@ -0,0 +1,168 @@
+import { ref as q, shallowRef as A, toValue as S, watch as K, getCurrentScope as L, onScopeDispose as Q, computed as E } from "vue";
+import { snapshot as x } from "../utils/snapshot.mjs";
+import { stateEqual as z } from "../utils/stateEqual.mjs";
+function M() {
+  const e = new Error("Dictionary request cancelled");
+  return e.name = "AbortError", e;
+}
+function V(e, r) {
+  if (!e || !Array.isArray(e.options) || typeof e.complete != "boolean")
+    throw new Error("Dictionary request must return { options, complete }");
+  const d = /* @__PURE__ */ new Map();
+  for (const a of e.options) {
+    if (!a || !["string", "number", "boolean"].includes(typeof a.value) || typeof a.value == "number" && !Number.isFinite(a.value) || typeof a.label != "string")
+      throw new Error("Dictionary options require a primitive value and a string label");
+    d.set(a.value, { ...a });
+  }
+  return { options: [...d.values()], complete: e.complete && r === "" };
+}
+function H(e) {
+  if (!e.key.trim()) throw new Error("A stable dictionary key is required");
+  const r = [], d = Math.max(0, Number.isFinite(e.cacheTime) ? e.cacheTime : 3e5), a = Math.max(
+    1,
+    Number.isFinite(e.maxEntries) ? Math.floor(e.maxEntries) : 50
+  ), m = (n) => {
+    const i = r.indexOf(n);
+    i >= 0 && r.splice(i, 1);
+  };
+  function b() {
+    for (const n of [...r])
+      !n.pending && (n.expires <= Date.now() || r.length > a) && m(n);
+  }
+  return Object.freeze({
+    key: e.key,
+    invalidate() {
+      r.splice(0);
+    },
+    load(n, { signal: i, keyword: v, force: y = !1 }) {
+      if (i.aborted) return Promise.reject(M());
+      b();
+      let s = r.find(
+        (t) => t.keyword === v && z(t.params, n)
+      );
+      if (s?.result && !y) return Promise.resolve(x(s.result));
+      if (!s?.pending) {
+        s && m(s);
+        const t = new AbortController(), f = x(n), o = {
+          params: f,
+          keyword: v,
+          expires: 0,
+          controller: t,
+          pending: !0,
+          users: /* @__PURE__ */ new Set(),
+          task: Promise.resolve().then(() => {
+            if (t.signal.aborted) throw M();
+            return e.request(x(f), { signal: t.signal, keyword: v });
+          }).then((u) => {
+            if (t.signal.aborted) throw M();
+            const p = V(u, v);
+            return o.pending = !1, o.result = p, o.expires = Date.now() + d, b(), p;
+          }).catch((u) => {
+            throw o.pending = !1, m(o), u;
+          })
+        };
+        r.push(o), s = o;
+      }
+      const l = s, h = /* @__PURE__ */ Symbol();
+      return l.users.add(h), new Promise((t, f) => {
+        function o() {
+          i.removeEventListener("abort", u), l.users.delete(h), !l.users.size && l.pending && (l.controller.abort(), m(l));
+        }
+        function u() {
+          o(), f(M());
+        }
+        i.addEventListener("abort", u, { once: !0 }), l.task.then(
+          (p) => {
+            o(), i.aborted ? f(M()) : t(x(p));
+          },
+          (p) => {
+            o(), f(p);
+          }
+        );
+      });
+    }
+  });
+}
+function I(e) {
+  const r = q(e.defaultKeyword ?? ""), d = A([]), a = A(/* @__PURE__ */ new Map()), m = q(!1), b = q(!1), n = A(null);
+  let i = x(S(e.params) ?? {}), v = !1, y = 0, s, l, h, t, f = Promise.resolve(!1);
+  function o() {
+    y++, clearTimeout(l), l = void 0, s?.abort(), s = void 0, t = void 0, h?.(!1), h = void 0, b.value = !1;
+  }
+  function u(c = !1, g = !1) {
+    if (v) return Promise.resolve(!1);
+    if (s && l === void 0 && t && t.keyword === r.value && z(t.params, i))
+      return f;
+    o();
+    const P = y, D = new AbortController();
+    s = D;
+    const C = x(i), F = r.value;
+    return t = { params: C, keyword: F }, b.value = !0, m.value = !1, n.value = null, f = new Promise((T) => {
+      h = T;
+      const N = async () => {
+        l = void 0;
+        try {
+          const w = await e.dictionary.load(C, {
+            keyword: F,
+            signal: D.signal,
+            force: g
+          });
+          if (v || P !== y) return;
+          d.value = w.options, m.value = w.complete;
+          const k = w.complete ? /* @__PURE__ */ new Map() : new Map(a.value);
+          for (const R of w.options) k.set(R.value, R);
+          a.value = k, T(!0);
+        } catch (w) {
+          if (!v && P === y && !D.signal.aborted) {
+            n.value = w instanceof Error ? w : new Error(String(w));
+            try {
+              e.onError?.(n.value);
+            } catch (k) {
+              n.value = k instanceof Error ? k : new Error(String(k));
+            }
+          }
+          T(!1);
+        } finally {
+          P === y && (b.value = !1, s = void 0, h = void 0);
+        }
+      }, O = c ? 0 : Math.max(0, e.debounceTime ?? 0);
+      O ? l = setTimeout(() => {
+        N();
+      }, O) : N();
+    }), f;
+  }
+  const p = K(
+    () => S(e.params),
+    (c) => {
+      z(i, c ?? {}) || (i = x(c ?? {}), r.value = "", a.value = /* @__PURE__ */ new Map(), d.value = [], u());
+    },
+    { deep: !0 }
+  );
+  return L() && Q(() => {
+    v = !0, p(), o();
+  }), e.manualRequest || u(), {
+    options: E(() => d.value),
+    valueEnum: E(() => {
+      const c = /* @__PURE__ */ new Map();
+      for (const g of [...S(e.selectedOptions) ?? [], ...a.value.values()])
+        c.set(g.value, { text: g.label, status: g.status });
+      return c;
+    }),
+    filters: E(
+      () => m.value ? d.value.map(({ value: c, label: g }) => ({ value: c, text: g })) : []
+    ),
+    complete: E(() => m.value),
+    loading: E(() => b.value),
+    error: E(() => n.value),
+    keyword: E(() => r.value),
+    search(c) {
+      return r.value = c, u();
+    },
+    reload: () => u(!0, !0),
+    cancel: o
+  };
+}
+export {
+  H as createTableDictionary,
+  I as useTableDictionary
+};

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

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

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

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

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

@@ -0,0 +1,4 @@
+import { UseTableEditOptions, UseTableEditReturn } from '../types/editing';
+/** Row drafts and validation without coupling the table to a form or HTTP library. */
+export declare function useTableEdit<TRecord extends object>(options: UseTableEditOptions<TRecord>): UseTableEditReturn<TRecord>;
+//# sourceMappingURL=useTableEdit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTableEdit.d.ts","sourceRoot":"","sources":["../../../../../table/src/composables/useTableEdit.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAKV,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,kBAAkB,CAAA;AAiBzB,sFAAsF;AACtF,wBAAgB,YAAY,CAAC,OAAO,SAAS,MAAM,EACjD,OAAO,EAAE,mBAAmB,CAAC,OAAO,CAAC,GACpC,kBAAkB,CAAC,OAAO,CAAC,CAwiB7B"}

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

@@ -0,0 +1,400 @@
+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() {
+    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 I(e) {
+    const t = h.value, r = e.map(o);
+    h.value = r;
+    try {
+      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 R(e) {
+    const t = m.value.get(e);
+    if (!t) return;
+    t.controller.abort();
+    const r = new Map(m.value);
+    r.delete(e), m.value = r, t.resolve(void 0);
+  }
+  function T(e) {
+    const t = p.value.get(e);
+    if (!t) return;
+    t.controller.abort();
+    const r = new Map(p.value);
+    r.delete(e), p.value = r, t.resolve(!1);
+  }
+  function O(e) {
+    b(), R(e), T(e);
+    const t = new Map(i.value);
+    t.delete(e), i.value = t, K(e);
+  }
+  function H(e) {
+    const t = p.value.get(e);
+    if (t) return t.promise;
+    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 a = await l.onCancel(o(r.draft), {
+          key: e,
+          original: r.original === void 0 ? void 0 : o(r.original),
+          isNew: r.isNew,
+          signal: f.controller.signal
+        });
+        if (!c() || a === !1) return;
+        f.resolve(!0), O(e);
+      } catch (a) {
+        if (!c()) return;
+        const d = {
+          type: "cancel",
+          message: a instanceof Error ? a.message : String(a),
+          cause: a
+        };
+        q(e, d);
+      } finally {
+        if (c()) {
+          const a = new Map(p.value);
+          a.delete(e), p.value = a;
+        }
+        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;
+      }
+    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 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: 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 u = "validation";
+      try {
+        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: w?.message ?? "Validation failed"
+          });
+          return;
+        }
+        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 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 (c()) {
+          const n = new Map(m.value);
+          n.delete(e), m.value = n;
+        }
+        f.resolve(void 0);
+      }
+    })(), v;
+  }
+  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();
+  }), {
+    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 = 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);
+    },
+    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 {
+  fe as useTableEdit
+};

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

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

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

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

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"}