@oneflowui/ui 0.8.4 → 0.8.6

package/dist/composables/useDatabaseViewMiddleware.d.ts

@@ -0,0 +1,56 @@
+import { DataRecord } from '../types';
+import { DatabaseViewActionContext, DatabaseViewActionErrorContext, DatabaseViewActionMiddleware } from '../contracts/database';
+export interface DatabaseViewToastMiddlewareOptions<T extends DataRecord = DataRecord> {
+    onSuccess?: (message: string, context: DatabaseViewActionContext<T>) => void | Promise<void>;
+    onError?: (message: string, context: DatabaseViewActionErrorContext<T>) => void | Promise<void>;
+    resolveSuccessMessage?: (context: DatabaseViewActionContext<T>) => string;
+    resolveErrorMessage?: (context: DatabaseViewActionErrorContext<T>) => string;
+}
+export interface DatabaseViewAnalyticsEvent<T extends DataRecord = DataRecord> {
+    phase: "before" | "after" | "error";
+    action: DatabaseViewActionContext<T>["action"];
+    tableId: string;
+    viewId: string;
+    selectedRecordId: string | null;
+    page: number;
+    pageSize: number;
+    totalCount: number;
+    payload: unknown;
+    error?: unknown;
+}
+export interface DatabaseViewAnalyticsMiddlewareOptions<T extends DataRecord = DataRecord> {
+    onEvent: (event: DatabaseViewAnalyticsEvent<T>) => void;
+}
+export interface DatabaseViewOptimisticMiddlewareOptions<T extends DataRecord = DataRecord> {
+    apply: (context: DatabaseViewActionContext<T>) => void | Promise<void>;
+    revert: (context: DatabaseViewActionErrorContext<T>) => void | Promise<void>;
+    shouldApply?: (context: DatabaseViewActionContext<T>) => boolean;
+}
+export interface DatabaseViewPresetMiddlewareOptions<T extends DataRecord = DataRecord> {
+    toast?: DatabaseViewToastMiddlewareOptions<T> | false;
+    analytics?: DatabaseViewAnalyticsMiddlewareOptions<T> | false;
+    optimistic?: DatabaseViewOptimisticMiddlewareOptions<T> | false;
+    extra?: readonly DatabaseViewMiddlewareInput<T>[];
+}
+export interface DatabaseViewPresetBundleOptions<T extends DataRecord = DataRecord> {
+    middlewares?: DatabaseViewMiddlewareInput<T>[];
+    toast?: DatabaseViewToastMiddlewareOptions<T>;
+    analytics?: DatabaseViewAnalyticsMiddlewareOptions<T>;
+    optimistic?: DatabaseViewOptimisticMiddlewareOptions<T>;
+}
+export interface DatabaseViewPresetBundle<T extends DataRecord = DataRecord> {
+    middleware: DatabaseViewActionMiddleware<T>;
+    presets: {
+        toast?: DatabaseViewActionMiddleware<T>;
+        analytics?: DatabaseViewActionMiddleware<T>;
+        optimistic?: DatabaseViewActionMiddleware<T>;
+    };
+}
+export type DatabaseViewMiddlewareInput<T extends DataRecord = DataRecord> = DatabaseViewActionMiddleware<T> | readonly DatabaseViewMiddlewareInput<T>[] | null | undefined;
+export declare function createDatabaseViewToastMiddleware<T extends DataRecord = DataRecord>(options?: DatabaseViewToastMiddlewareOptions<T>): DatabaseViewActionMiddleware<T>;
+export declare function createDatabaseViewAnalyticsMiddleware<T extends DataRecord = DataRecord>(options: DatabaseViewAnalyticsMiddlewareOptions<T>): DatabaseViewActionMiddleware<T>;
+export declare function createDatabaseViewOptimisticMiddleware<T extends DataRecord = DataRecord>(options: DatabaseViewOptimisticMiddlewareOptions<T>): DatabaseViewActionMiddleware<T>;
+export declare function createDatabaseViewPresetBundle<T extends DataRecord = DataRecord>(options?: DatabaseViewPresetBundleOptions<T>): DatabaseViewPresetBundle<T>;
+export declare function composeDatabaseViewMiddlewares<T extends DataRecord = DataRecord>(...inputs: DatabaseViewMiddlewareInput<T>[]): DatabaseViewActionMiddleware<T>;
+export declare function createDatabaseViewPresetInputs<T extends DataRecord = DataRecord>(options: DatabaseViewPresetMiddlewareOptions<T>): DatabaseViewMiddlewareInput<T>[];
+export declare function createDatabaseViewPresetMiddleware<T extends DataRecord = DataRecord>(options?: DatabaseViewPresetBundleOptions<T>): DatabaseViewActionMiddleware<T>;

package/dist/composables/useDatabaseViewMiddleware.js

@@ -0,0 +1,158 @@
+function n(e) {
+  switch (e.action) {
+    case "cell-edit":
+      return "单元格更新已完成";
+    case "select-record":
+      return "记录选择已更新";
+    case "schema-event":
+      return "结构变更已处理";
+    case "save-view":
+      return "视图已保存";
+    case "delete-view":
+      return "视图已删除";
+    case "refresh":
+      return "数据视图已刷新";
+  }
+}
+function o(e) {
+  return `${n(e)}失败`;
+}
+function l(e = {}) {
+  return {
+    async after(a) {
+      var t;
+      const r = (e.resolveSuccessMessage ?? n)(a);
+      await ((t = e.onSuccess) == null ? void 0 : t.call(e, r, a));
+    },
+    async error(a) {
+      var t;
+      const r = (e.resolveErrorMessage ?? o)(a);
+      await ((t = e.onError) == null ? void 0 : t.call(e, r, a));
+    }
+  };
+}
+function u(e) {
+  const a = (r, t, i) => {
+    e.onEvent({
+      phase: r,
+      action: t.action,
+      tableId: t.tableId,
+      viewId: t.activeViewId,
+      selectedRecordId: t.selectedRecordId,
+      page: t.page,
+      pageSize: t.pageSize,
+      totalCount: t.totalCount,
+      payload: t.payload,
+      error: i
+    });
+  };
+  return {
+    before(r) {
+      a("before", r);
+    },
+    after(r) {
+      a("after", r);
+    },
+    error(r) {
+      a("error", r, r.error);
+    }
+  };
+}
+function f(e) {
+  const a = e.shouldApply ?? ((r) => r.action === "cell-edit");
+  return {
+    async before(r) {
+      a(r) && await e.apply(r);
+    },
+    async error(r) {
+      a(r) && await e.revert(r);
+    }
+  };
+}
+function w(e = {}) {
+  const a = {
+    toast: e.toast ? l(e.toast) : void 0,
+    analytics: e.analytics ? u(e.analytics) : void 0,
+    optimistic: e.optimistic ? f(e.optimistic) : void 0
+  };
+  return {
+    middleware: y(
+      ...e.middlewares ?? [],
+      a.analytics,
+      a.toast,
+      a.optimistic
+    ),
+    presets: a
+  };
+}
+function d(e) {
+  const a = [];
+  for (const r of e)
+    if (r) {
+      if (Array.isArray(r)) {
+        a.push(...d(r));
+        continue;
+      }
+      a.push(r);
+    }
+  return a;
+}
+function y(...e) {
+  const a = d(e), r = /* @__PURE__ */ new WeakMap();
+  return {
+    async before(t) {
+      let i = 0;
+      try {
+        for (const s of a) {
+          if (!s.before) {
+            i += 1;
+            continue;
+          }
+          await s.before(t), i += 1;
+        }
+        r.set(t, i);
+      } catch (s) {
+        throw r.set(t, i), s;
+      }
+    },
+    async after(t) {
+      const i = r.get(t) ?? a.length;
+      try {
+        for (let s = i - 1; s >= 0; s -= 1) {
+          const c = a[s];
+          c != null && c.after && await c.after(t);
+        }
+      } finally {
+        r.delete(t);
+      }
+    },
+    async error(t) {
+      const i = r.get(t) ?? a.length;
+      try {
+        for (let s = i - 1; s >= 0; s -= 1) {
+          const c = a[s];
+          c != null && c.error && await c.error(t);
+        }
+      } finally {
+        r.delete(t);
+      }
+    }
+  };
+}
+function g(e) {
+  var r;
+  const a = [];
+  return e.toast && a.push(l(e.toast)), e.analytics && a.push(u(e.analytics)), e.optimistic && a.push(f(e.optimistic)), (r = e.extra) != null && r.length && a.push(e.extra), a;
+}
+function h(e = {}) {
+  return w(e).middleware;
+}
+export {
+  y as composeDatabaseViewMiddlewares,
+  u as createDatabaseViewAnalyticsMiddleware,
+  f as createDatabaseViewOptimisticMiddleware,
+  w as createDatabaseViewPresetBundle,
+  g as createDatabaseViewPresetInputs,
+  h as createDatabaseViewPresetMiddleware,
+  l as createDatabaseViewToastMiddleware
+};

package/dist/composables/useVirtualList.d.ts

@@ -1,10 +1,19 @@
 import { ComputedRef, Ref } from 'vue';
+export interface VirtualListState {
+    scrollTop: Ref<number>;
+    containerHeight: Ref<number>;
+    invalidateVersion: Ref<number>;
+    setScrollTop: (scrollTop: number) => void;
+    setContainerHeight: (containerHeight: number) => void;
+    invalidate: () => void;
+}
 export interface UseVirtualListOptions<T> {
     items: Ref<T[]>;
     itemHeight: number | ((index: number) => number);
     overscan?: number;
     containerRef: Ref<HTMLElement | null>;
     invalidateKey?: Ref<unknown>;
+    state?: VirtualListState;
     /** Optional callback to measure actual row height after render. When provided, measured heights override itemHeight. */
     measureRow?: boolean;
 }
@@ -12,6 +21,8 @@ export type VirtualItem<T> = {
     data: T;
     index: number;
 };
+export declare function createVirtualListState(): VirtualListState;
+export declare function useVirtualListStateCache(cacheKey?: string): VirtualListState;
 export declare function useVirtualList<T>(options: UseVirtualListOptions<T>): {
     visibleItems: ComputedRef<VirtualItem<T>[]>;
     totalHeight: ComputedRef<number>;

package/dist/composables/useVirtualList.js

@@ -1,153 +1,195 @@
-import { ref as T, computed as p, watch as z, getCurrentScope as W, onScopeDispose as X } from "vue";
-function _(x) {
-  var V;
-  const { items: n, itemHeight: c, overscan: B = 5, containerRef: A } = x, s = T(0), v = T(0), h = typeof c == "number", m = Math.max(0, B), a = /* @__PURE__ */ new Map(), b = T(0);
-  let d = null, f = null, l = null;
-  function D(e) {
-    return a.has(e) ? a.get(e) : h ? c : c(e);
+import { ref as b, computed as S, watch as I, getCurrentScope as $, onScopeDispose as tt } from "vue";
+const K = Symbol("oneui.virtual-list-state-persistent"), B = /* @__PURE__ */ new Map();
+function _() {
+  const l = b(0), n = b(0), a = b(0);
+  return {
+    scrollTop: l,
+    containerHeight: n,
+    invalidateVersion: a,
+    setScrollTop(c) {
+      l.value = c;
+    },
+    setContainerHeight(c) {
+      n.value = c;
+    },
+    invalidate() {
+      a.value += 1;
+    }
+  };
+}
+function et(l) {
+  return l[K] = !0, l;
+}
+function nt(l) {
+  return !!l[K];
+}
+function it(l) {
+  const n = l.trim();
+  return n.length > 0 ? n : "default";
+}
+function rt(l = "default") {
+  const n = it(l), a = B.get(n);
+  if (a)
+    return a;
+  const c = et(_());
+  return B.set(n, c), c;
+}
+function at(l) {
+  var A;
+  const { items: n, itemHeight: a, overscan: c = 5, containerRef: U } = l, v = l.state ?? _(), { scrollTop: h, containerHeight: d } = v, m = typeof a == "number", M = Math.max(0, c), o = /* @__PURE__ */ new Map(), w = b(0);
+  let g = null, f = null, r = null;
+  function k(t) {
+    return o.has(t) ? o.get(t) : m ? a : a(t);
   }
-  function K() {
-    !x.measureRow || typeof ResizeObserver > "u" || (f = new ResizeObserver((e) => {
-      let t = !1;
-      for (const i of e) {
-        const r = i.target.dataset.virtualIndex;
-        if (r == null) continue;
-        const u = parseInt(r, 10), g = i.contentRect.height;
-        a.get(u) !== g && (a.set(u, g), t = !0);
+  function D() {
+    !l.measureRow || typeof ResizeObserver > "u" || (f = new ResizeObserver((t) => {
+      let e = !1;
+      for (const i of t) {
+        const s = i.target.dataset.virtualIndex;
+        if (s == null) continue;
+        const p = parseInt(s, 10), x = i.contentRect.height;
+        o.get(p) !== x && (o.set(p, x), e = !0);
       }
-      t && b.value++;
+      e && w.value++;
     }));
   }
-  K();
+  D();
   function C() {
-    a.size !== 0 && (a.clear(), b.value++, l && M(l));
+    if (r && T(r), o.size > 0 && (o.clear(), w.value++), r) {
+      const t = Math.max(0, H.value - d.value);
+      h.value > t && (r.scrollTop = t, v.setScrollTop(t));
+    }
   }
-  function P(e, t) {
-    !e || !f || (e.dataset.virtualIndex = String(t), f.observe(e));
+  function N(t, e) {
+    !t || !f || (t.dataset.virtualIndex = String(e), f.observe(t));
   }
-  const w = p(() => {
-    if (b.value, h && a.size === 0) return [];
-    const e = new Array(n.value.length + 1).fill(0);
-    for (let t = 0; t < n.value.length; t += 1)
-      e[t + 1] = e[t] + Math.max(0, D(t));
-    return e;
-  }), I = p(() => h && a.size === 0 ? n.value.length * c : w.value[n.value.length] ?? 0);
-  function H(e) {
-    const t = Math.max(0, Math.min(e, n.value.length));
-    return h && a.size === 0 ? t * c : w.value[t] ?? 0;
+  const z = S(() => {
+    if (w.value, m && o.size === 0) return [];
+    const t = new Array(n.value.length + 1).fill(0);
+    for (let e = 0; e < n.value.length; e += 1)
+      t[e + 1] = t[e] + Math.max(0, k(e));
+    return t;
+  }), H = S(() => m && o.size === 0 ? n.value.length * a : z.value[n.value.length] ?? 0);
+  function L(t) {
+    const e = Math.max(0, Math.min(t, n.value.length));
+    return m && o.size === 0 ? e * a : z.value[e] ?? 0;
   }
-  function R(e) {
+  function R(t) {
     if (n.value.length === 0) return 0;
-    if (h && a.size === 0) {
-      const r = c;
+    if (m && o.size === 0) {
+      const s = a;
       return Math.max(
         0,
-        Math.min(n.value.length - 1, Math.floor(Math.max(0, e) / r))
+        Math.min(n.value.length - 1, Math.floor(Math.max(0, t) / s))
       );
     }
-    const t = w.value;
-    let i = 0, o = n.value.length;
-    for (; i < o; ) {
-      const r = Math.floor((i + o) / 2);
-      t[r + 1] <= e ? i = r + 1 : o = r;
+    const e = z.value;
+    let i = 0, u = n.value.length;
+    for (; i < u; ) {
+      const s = Math.floor((i + u) / 2);
+      e[s + 1] <= t ? i = s + 1 : u = s;
     }
     return Math.max(0, Math.min(i, n.value.length - 1));
   }
-  const y = p(() => {
-    const e = n.value.length;
-    if (e === 0)
+  const V = S(() => {
+    const t = n.value.length;
+    if (t === 0)
       return { start: 0, end: 0 };
-    if (v.value <= 0)
-      return { start: 0, end: Math.min(e, m * 2 + 1) };
-    if (h && a.size === 0) {
-      const u = c, g = Math.floor(s.value / u), J = Math.ceil(v.value / u), N = Math.max(0, g - m), Q = Math.min(e, g + J + m);
-      return { start: N, end: Q };
+    if (d.value <= 0)
+      return { start: 0, end: Math.min(t, M * 2 + 1) };
+    if (m && o.size === 0) {
+      const p = a, x = Math.floor(h.value / p), W = Math.ceil(d.value / p), X = Math.max(0, x - M), Z = Math.min(t, x + W + M);
+      return { start: X, end: Z };
     }
-    const t = Math.max(0, s.value), i = t + v.value, o = R(t), r = Math.min(e - 1, R(i));
+    const e = Math.max(0, h.value), i = e + d.value, u = R(e), s = Math.min(t - 1, R(i));
     return {
-      start: Math.max(0, o - m),
-      end: Math.min(e, r + m + 1)
+      start: Math.max(0, u - M),
+      end: Math.min(t, s + M + 1)
     };
-  }), U = p(() => H(y.value.start)), Y = p(() => {
-    const { start: e, end: t } = y.value;
-    return n.value.slice(e, t).map((i, o) => ({
+  }), Y = S(() => L(V.value.start)), j = S(() => {
+    const { start: t, end: e } = V.value;
+    return n.value.slice(t, e).map((i, u) => ({
       data: i,
-      index: e + o
+      index: t + u
     }));
   });
-  function M(e) {
-    if (!e) {
-      s.value = 0, v.value = 0;
+  function T(t) {
+    if (!t) {
+      nt(v) || (d.value = 0);
       return;
     }
-    s.value = e.scrollTop, v.value = e.clientHeight;
+    t.scrollTop !== h.value && (t.scrollTop = h.value), d.value = t.clientHeight;
   }
-  function S() {
-    l && (s.value = l.scrollTop);
+  function y() {
+    r && (h.value = r.scrollTop);
   }
-  function O() {
-    d == null || d.disconnect(), d = null;
+  function E() {
+    g == null || g.disconnect(), g = null;
   }
-  function E(e) {
-    e && e.removeEventListener("scroll", S);
+  function O(t) {
+    t && t.removeEventListener("scroll", y);
   }
-  function j(e) {
-    if (!e) {
-      l = null, M(null);
+  function q(t) {
+    if (!t) {
+      r = null, T(null);
       return;
     }
-    l = e, e.addEventListener("scroll", S, { passive: !0 }), M(e), typeof ResizeObserver < "u" && (d = new ResizeObserver(() => {
-      M(e);
-    }), d.observe(e));
+    r = t, t.addEventListener("scroll", y, { passive: !0 }), T(t), typeof ResizeObserver < "u" && (g = new ResizeObserver(() => {
+      T(t);
+    }), g.observe(t));
   }
-  z(
-    A,
-    (e, t) => {
-      E(t), O(), j(e);
+  I(
+    U,
+    (t, e) => {
+      O(e), E(), q(t);
     },
     { immediate: !0 }
-  ), z(
+  ), I(
     () => {
-      var e;
-      return (e = x.invalidateKey) == null ? void 0 : e.value;
+      var t;
+      return (t = l.invalidateKey) == null ? void 0 : t.value;
     },
     () => {
       C();
     },
     { immediate: !0 }
+  ), I(
+    () => v.invalidateVersion.value,
+    () => {
+      C();
+    },
+    { immediate: !0 }
   );
-  let F = n.value.length, L = n.value.length > 0 ? (V = n.value[0]) == null ? void 0 : V.id : void 0;
-  z(n, (e) => {
-    var u;
-    const t = e.length, i = t > 0 ? (u = e[0]) == null ? void 0 : u.id : void 0, o = t === F && i === L;
-    if (F = t, L = i, o)
-      return;
-    C();
-    const r = Math.max(0, I.value - v.value);
-    s.value > r && (s.value = r, l && (l.scrollTop = r));
+  let F = n.value.length, P = n.value.length > 0 ? (A = n.value[0]) == null ? void 0 : A.id : void 0;
+  I(n, (t) => {
+    var s;
+    const e = t.length, i = e > 0 ? (s = t[0]) == null ? void 0 : s.id : void 0, u = e === F && i === P;
+    F = e, P = i, !u && C();
   });
-  function k(e) {
-    if (!l || n.value.length === 0) return;
-    const t = Math.max(0, Math.min(e, n.value.length - 1)), i = H(t);
-    l.scrollTop = i, s.value = i;
+  function G(t) {
+    if (!r || n.value.length === 0) return;
+    const e = Math.max(0, Math.min(t, n.value.length - 1)), i = L(e);
+    r.scrollTop = i, v.setScrollTop(i);
   }
-  function q() {
-    if (!l) return;
-    const e = Math.max(0, I.value - l.clientHeight);
-    l.scrollTop = e, s.value = e;
+  function J() {
+    if (!r) return;
+    const t = Math.max(0, H.value - r.clientHeight);
+    r.scrollTop = t, v.setScrollTop(t);
   }
-  const G = () => {
-    E(l), O(), f == null || f.disconnect(), f = null, l = null;
+  const Q = () => {
+    O(r), E(), f == null || f.disconnect(), f = null, r = null;
   };
-  return W() && X(G), {
-    visibleItems: Y,
-    totalHeight: I,
-    offsetY: U,
-    scrollToIndex: k,
-    scrollToBottom: q,
-    observeRow: P
+  return $() && tt(Q), {
+    visibleItems: j,
+    totalHeight: H,
+    offsetY: Y,
+    scrollToIndex: G,
+    scrollToBottom: J,
+    observeRow: N
   };
 }
 export {
-  _ as useVirtualList
+  _ as createVirtualListState,
+  at as useVirtualList,
+  rt as useVirtualListStateCache
 };

package/dist/composables.js

@@ -0,0 +1,74 @@
+import { DEFAULT_PRIORITY_MAP as a, DEFAULT_STATUS_MAP as t, mergeColorMap as o, resolveBadge as s, useBadge as i } from "./composables/useBadge.js";
+import { useStream as p } from "./composables/useStream.js";
+import { useTypewriter as l } from "./composables/useTypewriter.js";
+import { useAiChat as x } from "./composables/useAiChat.js";
+import { useTableFilter as c } from "./composables/useTableFilter.js";
+import { useTable as w } from "./composables/useTable.js";
+import { useMarkdown as n } from "./composables/useMarkdown.js";
+import { useInlineEdit as T } from "./composables/useInlineEdit.js";
+import { createVirtualListState as M, useVirtualList as P, useVirtualListStateCache as g } from "./composables/useVirtualList.js";
+import { useToast as C } from "./composables/useToast.js";
+import { useTableData as k } from "./composables/useTableData.js";
+import { useTableColumns as L } from "./composables/useTableColumns.js";
+import { useBreakpoint as R } from "./composables/useBreakpoint.js";
+import { useColumnResize as F } from "./composables/useColumnResize.js";
+import { useFixedColumns as _ } from "./composables/useFixedColumns.js";
+import { useKeyboardNavigation as U } from "./composables/useKeyboardNavigation.js";
+import { useRowDrag as W } from "./composables/useRowDrag.js";
+import { useDraftRows as K } from "./composables/useDraftRows.js";
+import { useWorkerSort as Y } from "./composables/useWorkerSort.js";
+import { useDataTableSelection as q } from "./composables/useDataTableSelection.js";
+import { buildDetailSheetCellEditPayloads as H, useDataTableDetailSheet as J } from "./composables/useDataTableDetailSheet.js";
+import { useSchemaEngine as X } from "./composables/useSchemaEngine.js";
+import { useSupabaseProvider as $ } from "./composables/useSupabaseProvider.js";
+import { createLocalStorageBackend as re, createSupabaseBackend as ae, useViewPersistence as te } from "./composables/useViewPersistence.js";
+import { useDatabaseView as se } from "./composables/useDatabaseView.js";
+import { composeDatabaseViewMiddlewares as ue, createDatabaseViewAnalyticsMiddleware as pe, createDatabaseViewOptimisticMiddleware as me, createDatabaseViewPresetBundle as le, createDatabaseViewPresetInputs as fe, createDatabaseViewPresetMiddleware as xe, createDatabaseViewToastMiddleware as de } from "./composables/useDatabaseViewMiddleware.js";
+import { useDatabaseViewport as be, useDatabaseWorkspaceState as we } from "./composables/useDatabaseWorkspace.js";
+import { useSearch as ne } from "./composables/useSearch.js";
+export {
+  a as DEFAULT_PRIORITY_MAP,
+  t as DEFAULT_STATUS_MAP,
+  H as buildDetailSheetCellEditPayloads,
+  ue as composeDatabaseViewMiddlewares,
+  pe as createDatabaseViewAnalyticsMiddleware,
+  me as createDatabaseViewOptimisticMiddleware,
+  le as createDatabaseViewPresetBundle,
+  fe as createDatabaseViewPresetInputs,
+  xe as createDatabaseViewPresetMiddleware,
+  de as createDatabaseViewToastMiddleware,
+  re as createLocalStorageBackend,
+  ae as createSupabaseBackend,
+  M as createVirtualListState,
+  o as mergeColorMap,
+  s as resolveBadge,
+  x as useAiChat,
+  i as useBadge,
+  R as useBreakpoint,
+  F as useColumnResize,
+  J as useDataTableDetailSheet,
+  q as useDataTableSelection,
+  se as useDatabaseView,
+  be as useDatabaseViewport,
+  we as useDatabaseWorkspaceState,
+  K as useDraftRows,
+  _ as useFixedColumns,
+  T as useInlineEdit,
+  U as useKeyboardNavigation,
+  n as useMarkdown,
+  W as useRowDrag,
+  X as useSchemaEngine,
+  ne as useSearch,
+  p as useStream,
+  $ as useSupabaseProvider,
+  w as useTable,
+  L as useTableColumns,
+  k as useTableData,
+  c as useTableFilter,
+  C as useToast,
+  l as useTypewriter,
+  te as useViewPersistence,
+  P as useVirtualList,
+  g as useVirtualListStateCache,
+  Y as useWorkerSort
+};

package/dist/contracts/database.d.ts

@@ -30,6 +30,28 @@ export interface DatabaseViewProvider<T extends DataRecord = DataRecord> {
     onFetch?: (params: DatabaseViewFetchParams) => Promise<DatabaseViewFetchResult<T>>;
     onRefresh?: (params: DatabaseViewFetchParams) => Promise<void> | void;
 }
+export interface DatabaseViewActionContext<T extends DataRecord = DataRecord> {
+    action: "cell-edit" | "select-record" | "schema-event" | "save-view" | "delete-view" | "refresh";
+    payload: unknown;
+    tableId: string;
+    mode: DatabaseViewMode;
+    view: ViewConfig;
+    activeViewId: string;
+    selectedRecordId: string | null;
+    selectedRecord: T | null;
+    page: number;
+    pageSize: number;
+    totalCount: number;
+}
+export interface DatabaseViewActionErrorContext<T extends DataRecord = DataRecord> extends DatabaseViewActionContext<T> {
+    error: unknown;
+}
+export interface DatabaseViewActionMiddleware<T extends DataRecord = DataRecord> {
+    before?: (context: DatabaseViewActionContext<T>) => Promise<void> | void;
+    after?: (context: DatabaseViewActionContext<T>) => Promise<void> | void;
+    error?: (context: DatabaseViewActionErrorContext<T>) => Promise<void> | void;
+}
+export type DatabaseViewActionMiddlewareList<T extends DataRecord = DataRecord> = DatabaseViewActionMiddleware<T> | readonly DatabaseViewActionMiddleware<T>[];
 export type DatabaseSchemaEvent = {
     type: "schema-add-field";
     fieldType: string;
@@ -53,6 +75,7 @@ export type DatabaseSchemaEvent = {
 };
 export type DatabaseViewSchemaEvent = DatabaseSchemaEvent;
 export interface DatabaseViewActions<T extends DataRecord = DataRecord> {
+    middleware?: DatabaseViewActionMiddlewareList<T>;
     onCellEdit?: (payload: {
         rowId: string;
         fieldId: string;