@oneflowui/ui 0.4.2 → 0.4.4

package/dist/composables/useRowDrag.js

@@ -0,0 +1,85 @@
+import { ref as c, readonly as D } from "vue";
+function y(i) {
+  const I = c(!1), u = c(null), g = c(null), s = c("before");
+  let v = null;
+  function f(e) {
+    return (e == null ? void 0 : e.__type) === "group-header";
+  }
+  function d(e) {
+    return String(e.id ?? "");
+  }
+  function T(e, r) {
+    if (f(r)) {
+      e.preventDefault();
+      return;
+    }
+    v = r, u.value = d(r), I.value = !0, e.dataTransfer && (e.dataTransfer.effectAllowed = "move", e.dataTransfer.setData("text/plain", u.value));
+  }
+  function R(e, r) {
+    var l;
+    if (e.preventDefault(), !v) return;
+    if (e.dataTransfer && (e.dataTransfer.dropEffect = "move"), f(r)) {
+      (l = i.enableCrossGroupDrag) != null && l.value && (g.value = r.id, s.value = "into-group");
+      return;
+    }
+    const n = e.currentTarget;
+    if (!n) return;
+    const t = n.getBoundingClientRect(), p = e.clientY - t.top < t.height / 2;
+    g.value = d(r), s.value = p ? "before" : "after";
+  }
+  function C(e, r, n) {
+    var o, p, l, w;
+    if (e.preventDefault(), !v || !u.value) {
+      h();
+      return;
+    }
+    const t = u.value;
+    if (f(r)) {
+      const a = (o = i.groupFieldId) == null ? void 0 : o.value;
+      a && ((p = i.enableCrossGroupDrag) != null && p.value) && ((l = n.onGroupChange) == null || l.call(n, {
+        rowId: t,
+        groupFieldId: a,
+        newValue: r.__groupKey
+      }));
+    } else {
+      const a = d(r);
+      t !== a && ((w = n.onReorder) == null || w.call(n, {
+        rowId: t,
+        beforeRowId: s.value === "before" ? a : _(a)
+      }));
+    }
+    h();
+  }
+  function G() {
+    h();
+  }
+  function _(e) {
+    const r = i.processedItems.value;
+    for (let n = 0; n < r.length; n++) {
+      const t = r[n];
+      if (!f(t) && d(t) === e) {
+        for (let o = n + 1; o < r.length; o++)
+          if (!f(r[o]))
+            return d(r[o]);
+        return null;
+      }
+    }
+    return null;
+  }
+  function h() {
+    I.value = !1, u.value = null, g.value = null, v = null;
+  }
+  return {
+    isDragging: D(I),
+    draggedRowId: D(u),
+    dropTargetId: D(g),
+    dropPosition: D(s),
+    handleDragStart: T,
+    handleDragOver: R,
+    handleDrop: C,
+    handleDragEnd: G
+  };
+}
+export {
+  y as useRowDrag
+};

package/dist/composables/useSchemaEngine.d.ts

@@ -0,0 +1,31 @@
+import { Ref, ComputedRef } from 'vue';
+import { FieldDef, TableColumn, TableSchema, ViewConfig } from '../types';
+export interface ValidationRule {
+    fieldId: string;
+    type: "required" | "min" | "max" | "pattern" | "custom";
+    message: string;
+    validate: (value: unknown) => boolean;
+}
+export interface FilterFieldConfig {
+    fieldId: string;
+    label: string;
+    type: "string" | "number" | "date" | "select" | "boolean";
+    options?: {
+        value: string;
+        label: string;
+    }[];
+}
+export interface FilterPanelConfig {
+    fields: FilterFieldConfig[];
+}
+export interface UseSchemaEngineOptions {
+    schema: Ref<TableSchema | undefined>;
+    view?: Ref<ViewConfig | undefined>;
+}
+export declare function useSchemaEngine(options: UseSchemaEngineOptions): {
+    columns: ComputedRef<TableColumn[]>;
+    fieldDefs: ComputedRef<FieldDef[]>;
+    validationRules: ComputedRef<Map<string, ValidationRule[]>>;
+    filterConfig: ComputedRef<FilterPanelConfig>;
+    formulaDependencyGraph: ComputedRef<Map<string, string[]>>;
+};

package/dist/composables/useSchemaEngine.js

@@ -0,0 +1,129 @@
+import { computed as l } from "vue";
+function b(n) {
+  const r = l(() => {
+    var e;
+    const s = n.schema.value;
+    if (!s) return [];
+    const i = (e = n.view) == null ? void 0 : e.value;
+    if (i != null && i.visibleFields && i.visibleFields.length > 0) {
+      const a = new Map(s.fields.map((t) => [t.id, t]));
+      return i.visibleFields.map((t) => a.get(t)).filter((t) => t !== void 0 && !t.hidden);
+    }
+    return s.fields.filter((a) => !a.hidden);
+  }), c = l(() => r.value.map((s) => f(s))), m = l(() => {
+    const s = /* @__PURE__ */ new Map(), i = n.schema.value;
+    if (!i) return s;
+    for (const e of i.fields) {
+      const a = [];
+      if (e.required && a.push({
+        fieldId: e.id,
+        type: "required",
+        message: `${e.name} 为必填项`,
+        validate: (t) => t != null && t !== ""
+      }), e.type === "number") {
+        if (e.min !== void 0) {
+          const t = e.min;
+          a.push({
+            fieldId: e.id,
+            type: "min",
+            message: `${e.name} 不能小于 ${t}`,
+            validate: (d) => typeof d == "number" && d >= t
+          });
+        }
+        if (e.max !== void 0) {
+          const t = e.max;
+          a.push({
+            fieldId: e.id,
+            type: "max",
+            message: `${e.name} 不能大于 ${t}`,
+            validate: (d) => typeof d == "number" && d <= t
+          });
+        }
+      }
+      e.type === "email" && a.push({
+        fieldId: e.id,
+        type: "pattern",
+        message: `${e.name} 格式不正确`,
+        validate: (t) => typeof t != "string" || t === "" || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(t)
+      }), e.type === "url" && a.push({
+        fieldId: e.id,
+        type: "pattern",
+        message: `${e.name} 不是有效的 URL`,
+        validate: (t) => {
+          if (typeof t != "string" || t === "") return !0;
+          try {
+            return new URL(t), !0;
+          } catch {
+            return !1;
+          }
+        }
+      }), a.length > 0 && s.set(e.id, a);
+    }
+    return s;
+  }), u = l(() => ({
+    fields: r.value.map((s) => y(s))
+  })), o = l(() => {
+    const s = /* @__PURE__ */ new Map(), i = n.schema.value;
+    if (!i) return s;
+    for (const e of i.fields)
+      e.type === "formula" && e.dependencies && s.set(e.id, [...e.dependencies]);
+    return s;
+  });
+  return {
+    columns: c,
+    fieldDefs: r,
+    validationRules: m,
+    filterConfig: u,
+    formulaDependencyGraph: o
+  };
+}
+const p = {
+  text: "string",
+  number: "number",
+  currency: "number",
+  progress: "number",
+  rating: "number",
+  date: "date",
+  datetime: "date",
+  select: "status",
+  multi_select: "status"
+};
+function f(n) {
+  return {
+    key: n.id,
+    label: n.name,
+    width: n.width ?? "fill",
+    type: p[n.type] ?? "string",
+    hidden: n.hidden
+  };
+}
+function y(n) {
+  const r = {
+    fieldId: n.id,
+    label: n.name,
+    type: "string"
+  };
+  switch (n.type) {
+    case "number":
+    case "currency":
+    case "progress":
+    case "rating":
+      r.type = "number";
+      break;
+    case "date":
+    case "datetime":
+      r.type = "date";
+      break;
+    case "checkbox":
+      r.type = "boolean";
+      break;
+    case "select":
+    case "multi_select":
+      r.type = "select", r.options = n.options.map((c) => ({ value: c.value, label: c.label }));
+      break;
+  }
+  return r;
+}
+export {
+  b as useSchemaEngine
+};

package/dist/composables/useSearch.d.ts

@@ -0,0 +1,30 @@
+export interface UseSearchOptions {
+    /** 防抖延迟（ms），默认 300 */
+    debounceMs?: number;
+    /** 最小搜索字符数，默认 1 */
+    minChars?: number;
+    /** 搜索模式 */
+    mode?: "client" | "server";
+}
+export interface SearchHighlight {
+    /** 原始文本 */
+    text: string;
+    /** 是否为匹配片段 */
+    match: boolean;
+}
+export declare function useSearch(options?: UseSearchOptions): {
+    /** 绑定到 input 的 v-model */
+    inputKeyword: import('vue').Ref<string, string>;
+    /** 防抖后的搜索词（传给 useSupabaseProvider 的 searchKeyword） */
+    keyword: Readonly<import('vue').Ref<string, string>>;
+    /** 是否有有效搜索词 */
+    isSearching: import('vue').ComputedRef<boolean>;
+    /** 高亮文本分段 */
+    highlightText: (text: string, query?: string) => SearchHighlight[];
+    /** 客户端过滤 */
+    filterBySearch: <T extends Record<string, unknown>>(data: T[], searchColumns: string[]) => T[];
+    /** 清空 */
+    clearSearch: () => void;
+    /** 直接设置 */
+    setKeyword: (val: string) => void;
+};

package/dist/composables/useSearch.js

@@ -0,0 +1,59 @@
+import { ref as f, computed as y, watch as T, readonly as S } from "vue";
+function L(m = {}) {
+  const { debounceMs: h = 300, minChars: a = 1 } = m, u = f(""), r = f(""), w = y(() => r.value.length >= a);
+  let t = null;
+  T(u, (e) => {
+    t && clearTimeout(t);
+    const n = e.trim();
+    if (n.length < a) {
+      r.value = "";
+      return;
+    }
+    t = setTimeout(() => {
+      r.value = n;
+    }, h);
+  });
+  function d(e, n) {
+    const o = n ?? r.value;
+    if (!o || !e)
+      return [{ text: e, match: !1 }];
+    const i = o.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), c = new RegExp(`(${i})`, "gi");
+    return e.split(c).filter(Boolean).map((s) => ({
+      text: s,
+      match: s.toLowerCase() === o.toLowerCase()
+    }));
+  }
+  function g(e, n) {
+    if (!r.value || !n.length) return e;
+    const o = r.value.toLowerCase();
+    return e.filter((i) => n.some((c) => {
+      const l = i[c];
+      return l == null ? !1 : String(l).toLowerCase().includes(o);
+    }));
+  }
+  function p() {
+    u.value = "", r.value = "", t && clearTimeout(t);
+  }
+  function v(e) {
+    u.value = e, r.value = e.trim(), t && clearTimeout(t);
+  }
+  return {
+    /** 绑定到 input 的 v-model */
+    inputKeyword: u,
+    /** 防抖后的搜索词（传给 useSupabaseProvider 的 searchKeyword） */
+    keyword: S(r),
+    /** 是否有有效搜索词 */
+    isSearching: w,
+    /** 高亮文本分段 */
+    highlightText: d,
+    /** 客户端过滤 */
+    filterBySearch: g,
+    /** 清空 */
+    clearSearch: p,
+    /** 直接设置 */
+    setKeyword: v
+  };
+}
+export {
+  L as useSearch
+};

package/dist/composables/useStream.js

@@ -0,0 +1,80 @@
+import { ref as y, readonly as b } from "vue";
+function P(e = {}) {
+  const t = y(!1), c = y(!1), k = y(null), l = y(0);
+  let r = null, n = "";
+  async function O(q) {
+    var x, I, R, T, A, B, C, E, F;
+    c.value = !0, t.value = !1, k.value = null, n = "", r = new AbortController();
+    let w = null;
+    e.timeout && e.timeout > 0 && (w = setTimeout(() => {
+      r == null || r.abort();
+    }, e.timeout));
+    let m = "", v = [], D = !1;
+    const S = () => {
+      var a, u;
+      if (m && ((a = e.onChunk) == null || a.call(e, m), m = ""), v.length > 0) {
+        for (const f of v)
+          (u = e.onData) == null || u.call(e, f);
+        v = [];
+      }
+      D = !1;
+    }, g = () => {
+      D || (D = !0, requestAnimationFrame(S));
+    };
+    try {
+      const a = q.getReader(), u = new TextDecoder();
+      for (c.value = !1, t.value = !0; ; ) {
+        const { done: f, value: i } = await a.read();
+        if (f) break;
+        const d = u.decode(i, { stream: !0 });
+        if (e.mode === "sse") {
+          n += d;
+          const L = n.split(`
+`);
+          n = L.pop() ?? "";
+          for (const J of L) {
+            const h = J.trim();
+            if (!(!h || h.startsWith(":")) && h.startsWith("data: ")) {
+              const s = h.slice(6);
+              if (s === "[DONE]") continue;
+              try {
+                const N = JSON.parse(s);
+                (e.bufferInterval ?? 0) > 0 ? (v.push(N), g()) : (x = e.onData) == null || x.call(e, N);
+              } catch {
+                (e.bufferInterval ?? 0) > 0 ? (m += s, g()) : (I = e.onChunk) == null || I.call(e, s);
+              }
+            }
+          }
+        } else
+          (e.bufferInterval ?? 0) > 0 ? (m += d, g()) : (R = e.onChunk) == null || R.call(e, d);
+      }
+      S(), (T = e.onDone) == null || T.call(e);
+    } catch (a) {
+      if (a.name !== "AbortError") {
+        const u = ((A = e.retry) == null ? void 0 : A.maxRetries) ?? 0;
+        if (l.value < u) {
+          const f = ((B = e.retry) == null ? void 0 : B.baseDelay) ?? 1e3, i = ((C = e.retry) == null ? void 0 : C.backoff) === "linear" ? f * (l.value + 1) : f * Math.pow(2, l.value);
+          l.value++, await new Promise((d) => setTimeout(d, i)), (E = e.onRetry) == null || E.call(e, l.value);
+          return;
+        }
+        k.value = a, (F = e.onError) == null || F.call(e, a);
+      }
+    } finally {
+      w && clearTimeout(w), t.value = !1, c.value = !1;
+    }
+  }
+  function W() {
+    r == null || r.abort(), t.value = !1, c.value = !1;
+  }
+  return {
+    isStreaming: b(t),
+    isLoading: b(c),
+    error: b(k),
+    retryCount: b(l),
+    start: O,
+    cancel: W
+  };
+}
+export {
+  P as useStream
+};

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