@oneflowui/ui 0.4.3 → 0.4.4

package/dist/composables/useSupabaseProvider.d.ts

@@ -0,0 +1,70 @@
+import { Ref } from 'vue';
+import { SortState } from './useTable';
+import { FilterCondition as TableFilterCondition, FilterLogic } from './useTableFilter';
+export interface SupabaseQueryBuilder {
+    from(table: string): SupabaseFilterBuilder;
+}
+export interface SupabaseFilterBuilder {
+    select(columns?: string, options?: {
+        count?: "exact" | "planned" | "estimated";
+    }): SupabaseFilterBuilder;
+    order(column: string, options?: {
+        ascending?: boolean;
+    }): SupabaseFilterBuilder;
+    range(from: number, to: number): SupabaseFilterBuilder;
+    eq(column: string, value: unknown): SupabaseFilterBuilder;
+    neq(column: string, value: unknown): SupabaseFilterBuilder;
+    gt(column: string, value: unknown): SupabaseFilterBuilder;
+    gte(column: string, value: unknown): SupabaseFilterBuilder;
+    lt(column: string, value: unknown): SupabaseFilterBuilder;
+    lte(column: string, value: unknown): SupabaseFilterBuilder;
+    like(column: string, pattern: string): SupabaseFilterBuilder;
+    ilike(column: string, pattern: string): SupabaseFilterBuilder;
+    is(column: string, value: null): SupabaseFilterBuilder;
+    not(column: string, operator: string, value: unknown): SupabaseFilterBuilder;
+    in(column: string, values: unknown[]): SupabaseFilterBuilder;
+    textSearch(column: string, query: string, options?: {
+        type?: "plain" | "phrase" | "websearch";
+    }): SupabaseFilterBuilder;
+    or(filters: string): SupabaseFilterBuilder;
+    then<T>(onfulfilled?: (value: any) => T): Promise<T>;
+}
+export interface UseSupabaseProviderOptions {
+    /** Supabase client instance (pass your createClient() result) */
+    client: SupabaseQueryBuilder;
+    /** Supabase table name */
+    table: string;
+    /** select columns, defaults to '*' */
+    select?: string;
+    /** Fixed filter conditions always appended (e.g. { project: 'xxx' }) */
+    baseFilters?: Record<string, unknown>;
+    /** Reactive filter conditions from useTableFilter */
+    filterConditions?: Ref<readonly TableFilterCondition[]>;
+    /** Filter logic: and / or */
+    filterLogic?: Ref<FilterLogic>;
+    /** Full-text search keyword */
+    searchKeyword?: Ref<string>;
+    /** Columns to search with ilike */
+    searchColumns?: string[];
+    /** Row transformer: Supabase row -> your T type */
+    transform?: (row: Record<string, unknown>) => Record<string, unknown>;
+}
+export declare function useSupabaseProvider<T extends Record<string, unknown> = Record<string, unknown>>(options: UseSupabaseProviderOptions): {
+    onFetch: (params: {
+        page: number;
+        pageSize: number;
+        sort: SortState;
+    }) => Promise<{
+        data: T[];
+        total: number;
+    }>;
+    totalCount: Readonly<Ref<number, number>>;
+    loading: Readonly<Ref<boolean, boolean>>;
+    error: Readonly<Ref<Error | null, Error | null>>;
+    /** Exposed for advanced usage */
+    buildQuery: (params: {
+        page: number;
+        pageSize: number;
+        sort: SortState;
+    }) => SupabaseFilterBuilder;
+};

package/dist/composables/useSupabaseProvider.js

@@ -0,0 +1,126 @@
+import { ref as d, readonly as $ } from "vue";
+function w(e, r) {
+  const { field: n, operator: t, value: l } = r;
+  switch (t) {
+    case "equals":
+      return e.eq(n, l);
+    case "not_equals":
+      return e.neq(n, l);
+    case "contains":
+      return e.ilike(n, `%${l}%`);
+    case "not_contains":
+      return e.not(n, "ilike", `%${l}%`);
+    case "starts_with":
+      return e.ilike(n, `${l}%`);
+    case "ends_with":
+      return e.ilike(n, `%${l}`);
+    case "gt":
+      return e.gt(n, l);
+    case "gte":
+      return e.gte(n, l);
+    case "lt":
+      return e.lt(n, l);
+    case "lte":
+      return e.lte(n, l);
+    case "is_empty":
+      return e.is(n, null);
+    case "is_not_empty":
+      return e.not(n, "is", null);
+    default:
+      return e;
+  }
+}
+function k(e) {
+  const { field: r, operator: n, value: t } = e;
+  switch (n) {
+    case "equals":
+      return `${r}.eq.${t}`;
+    case "not_equals":
+      return `${r}.neq.${t}`;
+    case "contains":
+      return `${r}.ilike.%${t}%`;
+    case "not_contains":
+      return `${r}.not.ilike.%${t}%`;
+    case "starts_with":
+      return `${r}.ilike.${t}%`;
+    case "ends_with":
+      return `${r}.ilike.%${t}`;
+    case "gt":
+      return `${r}.gt.${t}`;
+    case "gte":
+      return `${r}.gte.${t}`;
+    case "lt":
+      return `${r}.lt.${t}`;
+    case "lte":
+      return `${r}.lte.${t}`;
+    case "is_empty":
+      return `${r}.is.null`;
+    case "is_not_empty":
+      return `${r}.not.is.null`;
+    default:
+      return null;
+  }
+}
+function C(e, r, n) {
+  if (r.length === 0) return e;
+  if (n === "or") {
+    const t = r.map((l) => k(l)).filter(Boolean);
+    return t.length > 0 && (e = e.or(t.join(","))), e;
+  }
+  for (const t of r)
+    !t.field || !t.value && t.operator !== "is_empty" && t.operator !== "is_not_empty" || (e = w(e, t));
+  return e;
+}
+function p(e) {
+  const r = d(0), n = d(!1), t = d(null);
+  function l(o) {
+    var i, g, h, _;
+    let a = e.client.from(e.table).select(e.select ?? "*", { count: "exact" });
+    if (e.baseFilters)
+      for (const [u, f] of Object.entries(e.baseFilters))
+        a = a.eq(u, f);
+    if ((i = e.filterConditions) != null && i.value && (a = C(
+      a,
+      e.filterConditions.value,
+      ((g = e.filterLogic) == null ? void 0 : g.value) ?? "and"
+    )), (h = e.searchKeyword) != null && h.value && ((_ = e.searchColumns) != null && _.length)) {
+      const u = e.searchKeyword.value.trim();
+      if (u) {
+        const f = e.searchColumns.map((m) => `${m}.ilike.%${u}%`).join(",");
+        a = a.or(f);
+      }
+    }
+    o.sort.field && o.sort.order && (a = a.order(o.sort.field, {
+      ascending: o.sort.order === "asc"
+    }));
+    const s = (o.page - 1) * o.pageSize, c = s + o.pageSize - 1;
+    return a = a.range(s, c), a;
+  }
+  async function v(o) {
+    n.value = !0, t.value = null;
+    try {
+      const s = await l(o);
+      if (s.error) throw new Error(s.error.message);
+      const c = s.data ?? [], i = e.transform ? c.map(e.transform) : c;
+      return r.value = s.count ?? i.length, {
+        data: i,
+        total: r.value
+      };
+    } catch (a) {
+      return t.value = a, { data: [], total: 0 };
+    } finally {
+      n.value = !1;
+    }
+  }
+  return {
+    onFetch: v,
+    totalCount: $(r),
+    loading: $(n),
+    error: $(t),
+    /** Exposed for advanced usage */
+    buildQuery: l
+  };
+}
+export {
+  p as useSupabaseProvider
+};

package/dist/composables/useTable.d.ts

@@ -59,4 +59,7 @@ export declare function useTable<T extends Record<string, unknown>>(options?: Us
     refresh: () => void;
     fetchData: () => Promise<void>;
     setData: (data: T[]) => void;
+    patchRow: (rowId: string, fields: Partial<Record<string, unknown>>) => void;
+    insertRow: (row: T, position?: number) => void;
+    removeRows: (rowIds: (string | number)[]) => void;
 };

package/dist/composables/useTable.js

@@ -1,115 +1,135 @@
-import { shallowRef as U, ref as f, computed as d, readonly as v, triggerRef as z } from "vue";
-let b = !1;
-function j(u = {}) {
-  const i = U(u.data ?? []), g = f(!1), S = f(null), n = f(/* @__PURE__ */ new Set()), l = f({ field: null, order: null }), a = f({
+import { shallowRef as B, ref as d, computed as S, readonly as f, triggerRef as g } from "vue";
+let D = !1;
+function H(u = {}) {
+  const r = B(u.data ?? []), h = d(!1), p = d(null), i = d(/* @__PURE__ */ new Set()), n = d({ field: null, order: null }), t = d({
     page: 1,
     pageSize: u.pageSize ?? 20,
     total: (u.data ?? []).length
   });
-  function D(e) {
-    l.value.field === e ? (l.value.order = l.value.order === "asc" ? "desc" : l.value.order === "desc" ? null : "asc", l.value.order === null && (l.value.field = null)) : (l.value.field = e, l.value.order = "asc"), a.value.page = 1, n.value.clear(), u.serverSide && o();
-  }
-  function R(e, t) {
-    l.value = { field: e, order: t }, a.value.page = 1, n.value.clear(), u.serverSide && o();
-  }
-  function M(e) {
-    if (!l.value.field || !l.value.order) return e;
-    const t = l.value.field, r = l.value.order;
-    return [...e].sort((K, O) => {
-      const s = K[t], c = O[t];
-      if (s == null && c == null) return 0;
+  function x(e) {
+    n.value.field === e ? (n.value.order = n.value.order === "asc" ? "desc" : n.value.order === "desc" ? null : "asc", n.value.order === null && (n.value.field = null)) : (n.value.field = e, n.value.order = "asc"), t.value.page = 1, i.value.clear(), u.serverSide && c();
+  }
+  function M(e, l) {
+    n.value = { field: e, order: l }, t.value.page = 1, i.value.clear(), u.serverSide && c();
+  }
+  function P(e) {
+    if (!n.value.field || !n.value.order) return e;
+    const l = n.value.field, a = n.value.order;
+    return [...e].sort((o, y) => {
+      const s = o[l], v = y[l];
+      if (s == null && v == null) return 0;
       if (s == null) return 1;
-      if (c == null) return -1;
-      if (typeof s == "number" && typeof c == "number")
-        return r === "asc" ? s - c : c - s;
-      const m = String(s), y = String(c);
-      return r === "asc" ? m.localeCompare(y) : y.localeCompare(m);
+      if (v == null) return -1;
+      if (typeof s == "number" && typeof v == "number")
+        return a === "asc" ? s - v : v - s;
+      const R = String(s), b = String(v);
+      return a === "asc" ? R.localeCompare(b) : b.localeCompare(R);
     });
   }
-  function P(e) {
-    a.value.page = Math.max(1, Math.min(e, w.value)), u.serverSide && o();
+  function C(e) {
+    t.value.page = Math.max(1, Math.min(e, z.value)), u.serverSide && c();
   }
-  function x(e) {
-    a.value.pageSize = e, a.value.page = 1, u.serverSide && o();
-  }
-  const w = d(
-    () => Math.max(1, Math.ceil(a.value.total / a.value.pageSize))
-  ), h = d(() => {
-    if (u.serverSide) return i.value;
-    const e = M(i.value);
-    a.value.total = e.length;
-    const { page: t, pageSize: r } = a.value;
-    return e.slice((t - 1) * r, t * r);
+  function A(e) {
+    t.value.pageSize = e, t.value.page = 1, u.serverSide && c();
+  }
+  const z = S(
+    () => Math.max(1, Math.ceil(t.value.total / t.value.pageSize))
+  ), w = S(() => {
+    if (u.serverSide) return r.value;
+    const e = P(r.value);
+    t.value.total = e.length;
+    const { page: l, pageSize: a } = t.value;
+    return e.slice((l - 1) * a, l * a);
   });
-  function p(e, t) {
-    const r = e.id;
-    return r == null && !b && (b = !0, console.warn(
+  function m(e, l) {
+    const a = e.id;
+    return a == null && !D && (D = !0, console.warn(
       "[OneUI] DataTable: row is missing an `id` field. Row selection may behave incorrectly after sorting or filtering. Please ensure each row has a unique `id` property."
-    )), r ?? t;
+    )), a ?? l;
   }
-  function C(e, t) {
-    const r = p(e, t);
-    n.value.has(r) ? n.value.delete(r) : n.value.add(r);
+  function F(e, l) {
+    const a = m(e, l);
+    i.value.has(a) ? i.value.delete(a) : i.value.add(a);
   }
-  function A(e) {
-    n.value.size === e.length ? n.value.clear() : e.forEach((t, r) => n.value.add(p(t, r)));
+  function I(e) {
+    i.value.size === e.length ? i.value.clear() : e.forEach((l, a) => i.value.add(m(l, a)));
   }
-  function F(e, t) {
-    return n.value.has(p(e, t));
+  function T(e, l) {
+    return i.value.has(m(e, l));
   }
-  function I() {
-    n.value.clear();
+  function k() {
+    i.value.clear();
   }
-  const T = d(() => n.value.size), k = d(
-    () => h.value.length > 0 && n.value.size === h.value.length
+  const q = S(() => i.value.size), E = S(
+    () => w.value.length > 0 && i.value.size === w.value.length
   );
-  async function o() {
+  async function c() {
     if (u.onFetch) {
-      g.value = !0, S.value = null;
+      h.value = !0, p.value = null;
       try {
         const e = await u.onFetch({
-          page: a.value.page,
-          pageSize: a.value.pageSize,
-          sort: l.value
+          page: t.value.page,
+          pageSize: t.value.pageSize,
+          sort: n.value
         });
-        i.value = e.data, z(i), a.value.total = e.total;
+        r.value = e.data, g(r), t.value.total = e.total;
       } catch (e) {
-        S.value = e;
+        p.value = e;
       } finally {
-        g.value = !1;
+        h.value = !1;
       }
     }
   }
-  function q() {
-    u.serverSide ? o() : a.value.page = 1;
+  function K() {
+    u.serverSide ? c() : t.value.page = 1;
+  }
+  function O(e) {
+    r.value = e, g(r), t.value.page = 1, u.serverSide || (t.value.total = e.length);
+  }
+  function U(e, l) {
+    const a = r.value, o = a.findIndex((y) => y.id === e);
+    o !== -1 && (a[o] = { ...a[o], ...l }, g(r));
+  }
+  function _(e, l) {
+    const a = r.value;
+    l !== void 0 && l >= 0 && l <= a.length ? a.splice(l, 0, e) : a.push(e), g(r), u.serverSide || (t.value.total = a.length);
   }
-  function E(e) {
-    i.value = e, z(i), a.value.page = 1, u.serverSide || (a.value.total = e.length);
+  function j(e) {
+    const l = new Set(e.map(String)), a = r.value;
+    r.value = a.filter(
+      (o) => !l.has(String(o.id))
+    ), g(r);
+    for (const o of e)
+      i.value.delete(o);
+    u.serverSide || (t.value.total = r.value.length);
   }
   return {
-    data: h,
-    rawData: v(i),
-    loading: v(g),
-    error: v(S),
-    sort: v(l),
-    pagination: v(a),
-    totalPages: w,
-    selectedRows: v(n),
-    selectedCount: T,
-    isAllSelected: k,
-    toggleSort: D,
-    setSort: R,
-    setPage: P,
-    setPageSize: x,
-    toggleRowSelection: C,
-    toggleSelectAll: A,
-    isRowSelected: F,
-    clearSelection: I,
-    refresh: q,
-    fetchData: o,
-    setData: E
+    data: w,
+    rawData: f(r),
+    loading: f(h),
+    error: f(p),
+    sort: f(n),
+    pagination: f(t),
+    totalPages: z,
+    selectedRows: f(i),
+    selectedCount: q,
+    isAllSelected: E,
+    toggleSort: x,
+    setSort: M,
+    setPage: C,
+    setPageSize: A,
+    toggleRowSelection: F,
+    toggleSelectAll: I,
+    isRowSelected: T,
+    clearSelection: k,
+    refresh: K,
+    fetchData: c,
+    setData: O,
+    patchRow: U,
+    insertRow: _,
+    removeRows: j
   };
 }
 export {
-  j as useTable
+  H as useTable
 };

package/dist/composables/useTableGroup.d.ts

@@ -1,12 +1,25 @@
 import { Ref } from 'vue';
+import { AggregationConfig } from '../types';
+export interface GroupConfig {
+    fieldId: string;
+}
 export interface UseTableGroupOptions<T> {
     data: Ref<T[]>;
-    groupBy: Ref<string | undefined>;
+    /** Single groupBy field (backwards-compatible) */
+    groupBy?: Ref<string | undefined>;
+    /** Multi-level group configs (takes priority over groupBy) */
+    groups?: Ref<GroupConfig[] | undefined>;
+    /** Aggregation configs applied to each group */
+    aggregations?: Ref<AggregationConfig[] | undefined>;
 }
 export type GroupHeaderItem = {
     __type: "group-header";
     __groupKey: string;
+    /** Full path for nested groups, e.g. ['status:done', 'priority:P0'] */
+    __groupPath: string[];
+    __groupLevel: number;
     __groupCount: number;
+    __aggregations?: Record<string, number>;
     id: string;
 };
 export type GroupedListItem<T> = (T & {

package/dist/composables/useTableGroup.js

@@ -1,46 +1,70 @@
-import { ref as g, watch as w, computed as h } from "vue";
-function y(a) {
-  const u = g(/* @__PURE__ */ new Set());
-  function l(e) {
-    const t = new Set(u.value);
-    t.has(e) ? t.delete(e) : t.add(e), u.value = t;
+import { ref as G, computed as h, watch as I } from "vue";
+import { computeAggregations as L } from "../utils/aggregation.js";
+function b(r) {
+  const n = G(/* @__PURE__ */ new Set());
+  function p(e) {
+    const t = new Set(n.value);
+    t.has(e) ? t.delete(e) : t.add(e), n.value = t;
   }
-  w(a.groupBy, () => {
-    u.value = /* @__PURE__ */ new Set();
+  const f = h(() => {
+    var t, s;
+    if ((t = r.groups) != null && t.value && r.groups.value.length > 0)
+      return r.groups.value;
+    const e = (s = r.groupBy) == null ? void 0 : s.value;
+    return e ? [{ fieldId: e }] : [];
+  });
+  I(f, () => {
+    n.value = /* @__PURE__ */ new Set();
   });
   const d = h(() => {
-    const e = a.data.value, t = a.groupBy.value;
-    if (!t)
+    var _;
+    const e = r.data.value, t = f.value;
+    if (t.length === 0)
       return e.map((o) => ({ ...o, __type: "data-row" }));
-    const c = [], s = /* @__PURE__ */ new Map();
-    for (const o of e) {
-      const n = o[t], r = n != null ? String(n) : "";
-      s.has(r) || (c.push(r), s.set(r, [])), s.get(r).push(o);
-    }
-    const p = [], _ = u.value;
-    for (const o of c) {
-      const n = s.get(o);
-      if (p.push({
-        __type: "group-header",
-        __groupKey: o,
-        __groupCount: n.length,
-        id: `__group__${o}`
-      }), !_.has(o))
-        for (const r of n)
-          p.push({ ...r, __type: "data-row" });
-    }
-    return p;
+    const s = ((_ = r.aggregations) == null ? void 0 : _.value) ?? [], l = n.value, a = [];
+    return v(e, t, 0, [], l, s, a), a;
   });
-  function f(e) {
+  function g(e) {
     return e && e.__type === "group-header";
   }
   return {
     groupedItems: d,
-    collapsedGroups: u,
-    toggleGroup: l,
-    isGroupHeader: f
+    collapsedGroups: n,
+    toggleGroup: p,
+    isGroupHeader: g
   };
 }
+function v(r, n, p, f, d, g, e) {
+  const t = n[p];
+  if (!t) {
+    for (const o of r)
+      e.push({ ...o, __type: "data-row" });
+    return;
+  }
+  const s = t.fieldId, l = [], a = /* @__PURE__ */ new Map();
+  for (const o of r) {
+    const c = o[s], u = c != null ? String(c) : "";
+    a.has(u) || (l.push(u), a.set(u, [])), a.get(u).push(o);
+  }
+  const _ = p === n.length - 1;
+  for (const o of l) {
+    const c = a.get(o), u = [...f, `${s}:${o}`], i = u.join("/"), w = g.length > 0 ? L(c, g) : void 0, y = {
+      __type: "group-header",
+      __groupKey: o,
+      __groupPath: u,
+      __groupLevel: p,
+      __groupCount: c.length,
+      __aggregations: w,
+      id: `__group__${i}`
+    };
+    if (e.push(y), !d.has(i))
+      if (_)
+        for (const m of c)
+          e.push({ ...m, __type: "data-row" });
+      else
+        v(c, n, p + 1, u, d, g, e);
+  }
+}
 export {
-  y as useTableGroup
+  b as useTableGroup
 };

package/dist/composables/useViewPersistence.d.ts

@@ -0,0 +1,98 @@
+import { ViewConfig } from '../types';
+export interface ViewStorageBackend {
+    /** 加载指定表的所有视图 */
+    load(tableId: string): Promise<ViewConfig[]>;
+    /** 保存/更新视图 */
+    save(tableId: string, view: ViewConfig): Promise<void>;
+    /** 删除视图 */
+    remove(tableId: string, viewId: string): Promise<void>;
+}
+export declare function createLocalStorageBackend(): ViewStorageBackend;
+export interface SupabaseViewBackendOptions {
+    /** Supabase client (最小接口：from().select/insert/update/delete) */
+    client: {
+        from(table: string): any;
+    };
+    /** 存储视图配置的表名，默认 'view_configs' */
+    tableName?: string;
+}
+export declare function createSupabaseBackend(options: SupabaseViewBackendOptions): ViewStorageBackend;
+export interface UseViewPersistenceOptions {
+    /** 表 ID */
+    tableId: string;
+    /** 存储后端，默认 localStorage */
+    backend?: ViewStorageBackend;
+    /** 默认视图（当没有保存的视图时使用） */
+    defaultView?: ViewConfig;
+    /** 是否自动加载（默认 true） */
+    autoLoad?: boolean;
+}
+export declare function useViewPersistence(options: UseViewPersistenceOptions): {
+    views: Readonly<import('vue').Ref<readonly {
+        readonly viewId: string;
+        readonly viewType: import('..').ViewType;
+        readonly name: string;
+        readonly visibleFields: readonly string[];
+        readonly sorts?: readonly {
+            readonly fieldId: string;
+            readonly direction: "asc" | "desc";
+        }[] | undefined;
+        readonly groups?: readonly {
+            readonly fieldId: string;
+        }[] | undefined;
+        readonly filters?: readonly {
+            readonly fieldId: string;
+            readonly operator: "eq" | "neq" | "contains" | "gt" | "lt" | "is_empty" | "is_not_empty";
+            readonly value?: string | number | boolean | readonly string[] | null | undefined;
+        }[] | undefined;
+        readonly kanbanFieldId?: string | undefined;
+        readonly galleryCoverFieldId?: string | undefined;
+        readonly galleryCardFields?: readonly string[] | undefined;
+        readonly aggregations?: readonly {
+            readonly fieldId: string;
+            readonly fn: import('..').AggregationFn;
+        }[] | undefined;
+        readonly fixedColumns?: readonly string[] | undefined;
+    }[], readonly {
+        readonly viewId: string;
+        readonly viewType: import('..').ViewType;
+        readonly name: string;
+        readonly visibleFields: readonly string[];
+        readonly sorts?: readonly {
+            readonly fieldId: string;
+            readonly direction: "asc" | "desc";
+        }[] | undefined;
+        readonly groups?: readonly {
+            readonly fieldId: string;
+        }[] | undefined;
+        readonly filters?: readonly {
+            readonly fieldId: string;
+            readonly operator: "eq" | "neq" | "contains" | "gt" | "lt" | "is_empty" | "is_not_empty";
+            readonly value?: string | number | boolean | readonly string[] | null | undefined;
+        }[] | undefined;
+        readonly kanbanFieldId?: string | undefined;
+        readonly galleryCoverFieldId?: string | undefined;
+        readonly galleryCardFields?: readonly string[] | undefined;
+        readonly aggregations?: readonly {
+            readonly fieldId: string;
+            readonly fn: import('..').AggregationFn;
+        }[] | undefined;
+        readonly fixedColumns?: readonly string[] | undefined;
+    }[]>>;
+    activeView: import('vue').ComputedRef<ViewConfig>;
+    activeViewId: import('vue').Ref<string, string>;
+    viewList: import('vue').ComputedRef<{
+        id: string;
+        name: string;
+        type: import('..').ViewType;
+    }[]>;
+    loading: Readonly<import('vue').Ref<boolean, boolean>>;
+    error: Readonly<import('vue').Ref<Error | null, Error | null>>;
+    loadViews: () => Promise<void>;
+    saveView: (config?: Partial<ViewConfig>) => Promise<void>;
+    createView: (name: string, baseConfig?: Partial<ViewConfig>) => Promise<string>;
+    deleteView: (viewId: string) => Promise<void>;
+    switchView: (viewId: string) => void;
+    duplicateView: (sourceViewId: string, newName: string) => Promise<string>;
+    updateActiveView: (patch: Partial<ViewConfig>) => void;
+};