@toolbox-web/grid-react 0.9.0 → 0.11.0

package/chunks/data-grid-GKyKxE6c.js

@@ -0,0 +1,799 @@
+import { jsx as b } from "react/jsx-runtime";
+import { DataGridElement as pe } from "@toolbox-web/grid";
+import { createContext as Y, useContext as I, useRef as S, useCallback as Z, useEffect as p, forwardRef as me, useMemo as w, useImperativeHandle as ye, Children as he, isValidElement as ve } from "react";
+import { flushSync as y } from "react-dom";
+import { createRoot as v } from "react-dom/client";
+import { c as we } from "./feature-registry-Y3KvnN54.js";
+function Ce(n) {
+  return n.charAt(0).toUpperCase() + n.slice(1);
+}
+function ce(n) {
+  return n.toLowerCase() === "id" ? "ID" : n.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").split(" ").filter(Boolean).map(Ce).join(" ");
+}
+const Re = /* @__PURE__ */ new Set(["string", "number", "boolean", "date", "datetime", "currency"]);
+function be(n) {
+  const t = n.lastIndexOf(":");
+  if (t > 0) {
+    const e = n.slice(t + 1).toLowerCase();
+    if (Re.has(e)) {
+      const r = n.slice(0, t);
+      return {
+        field: r,
+        header: ce(r),
+        type: e
+      };
+    }
+  }
+  return {
+    field: n,
+    header: ce(n)
+  };
+}
+function Ee(n) {
+  return n.map((t) => typeof t == "string" ? be(t) : t);
+}
+const z = {
+  onCellClick: "cell-click",
+  onRowClick: "row-click",
+  onCellActivate: "cell-activate",
+  onCellChange: "cell-change",
+  onCellCommit: "cell-commit",
+  onRowCommit: "row-commit",
+  onSortChange: "sort-change",
+  onFilterChange: "filter-change",
+  onColumnResize: "column-resize",
+  onColumnMove: "column-move",
+  onColumnVisibility: "column-visibility",
+  onColumnStateChange: "column-state-change",
+  onSelectionChange: "selection-change",
+  onRowMove: "row-move",
+  onGroupToggle: "group-toggle",
+  onTreeExpand: "tree-expand",
+  onDetailExpand: "detail-expand",
+  onResponsiveChange: "responsive-change",
+  onCopy: "copy",
+  onPaste: "paste",
+  onUndoRedo: "undo-redo",
+  onExportComplete: "export-complete",
+  onPrintStart: "print-start",
+  onPrintComplete: "print-complete"
+}, Q = Y(null), Ue = ({ icons: n, children: t }) => /* @__PURE__ */ b(Q.Provider, { value: n, children: t });
+function Je() {
+  return I(Q);
+}
+const De = Q, $ = /* @__PURE__ */ new WeakMap(), W = /* @__PURE__ */ new Map();
+function de(n) {
+  const t = n.querySelector("tbw-grid-responsive-card");
+  if (t) {
+    const r = $.get(t);
+    if (r) return r;
+  }
+  const e = n.id || n.getAttribute("data-grid-id");
+  if (e)
+    return W.get(e);
+}
+function Pe(n) {
+  const { children: t, cardRowHeight: e = "auto" } = n, r = S(null), i = Z(
+    (s) => {
+      if (r.current = s, !s) return;
+      $.set(s, t);
+      const c = s.closest("tbw-grid");
+      if (c) {
+        const u = c.id || c.getAttribute("data-grid-id");
+        u && W.set(u, t);
+      }
+    },
+    [t]
+  );
+  p(() => () => {
+    const s = r.current;
+    if (s) {
+      $.delete(s);
+      const c = s.closest("tbw-grid");
+      if (c) {
+        const u = c.id || c.getAttribute("data-grid-id");
+        u && W.delete(u);
+      }
+    }
+  }, []);
+  const d = e === "auto" ? "auto" : String(e);
+  return /* @__PURE__ */ b("tbw-grid-responsive-card", { ref: i, cardRowHeight: d });
+}
+Pe.displayName = "GridResponsiveCard";
+const T = Y(null), Ye = ({ defaults: n, children: t }) => /* @__PURE__ */ b(T.Provider, { value: n, children: t });
+function Ze() {
+  return I(T);
+}
+function Qe(n) {
+  return I(T)?.[n];
+}
+const Se = T;
+function xe(n) {
+  const t = /* @__PURE__ */ new WeakMap();
+  return (e) => {
+    const r = e.cellEl;
+    if (r) {
+      const s = t.get(r);
+      if (s)
+        return y(() => {
+          s.root.render(n(e));
+        }), s.container;
+    }
+    const i = document.createElement("div");
+    i.className = "react-cell-renderer", i.style.display = "contents";
+    const d = v(i);
+    return y(() => {
+      d.render(n(e));
+    }), r && t.set(r, { root: d, container: i }), i;
+  };
+}
+function Ae(n) {
+  return (t) => {
+    const e = document.createElement("div");
+    e.className = "react-cell-editor", e.style.display = "contents";
+    const r = v(e);
+    return y(() => {
+      r.render(n(t));
+    }), e;
+  };
+}
+function Ge(n) {
+  if (!n) return;
+  if (!n.columns) return n;
+  const t = n.columns.map((e) => {
+    const { renderer: r, editor: i, ...d } = e, s = { ...d };
+    return r && (s.renderer = xe(r)), i && (s.editor = Ae(i)), s;
+  });
+  return {
+    ...n,
+    columns: t
+  };
+}
+const q = /* @__PURE__ */ new WeakMap(), B = /* @__PURE__ */ new Map();
+function Ie(n) {
+  const t = n.querySelector("tbw-grid-detail");
+  if (t) {
+    const r = q.get(t);
+    if (r) return r;
+  }
+  const e = n.id || n.getAttribute("data-grid-id");
+  if (e)
+    return B.get(e);
+}
+function Ne(n) {
+  const { children: t, showExpandColumn: e = !0, animation: r = "slide" } = n, i = S(null), d = Z(
+    (c) => {
+      if (i.current = c, !c) return;
+      q.set(c, t);
+      const u = c.closest("tbw-grid");
+      if (u) {
+        const g = u.id || u.getAttribute("data-grid-id");
+        g && B.set(g, t);
+      }
+    },
+    [t]
+  );
+  return p(() => () => {
+    const c = i.current;
+    if (c) {
+      q.delete(c);
+      const u = c.closest("tbw-grid");
+      if (u) {
+        const h = u.id || u.getAttribute("data-grid-id");
+        h && B.delete(h);
+      }
+      const g = c.parentNode;
+      g && g.contains(c);
+    }
+  }, []), /* @__PURE__ */ b(
+    "tbw-grid-detail",
+    {
+      ref: d,
+      showExpandColumn: e ? void 0 : "false",
+      animation: r === !1 ? "false" : r
+    }
+  );
+}
+Ne.displayName = "GridDetailPanel";
+const K = /* @__PURE__ */ new WeakMap(), U = /* @__PURE__ */ new Map();
+function Ve(n) {
+  const t = K.get(n);
+  if (t) return t;
+  const e = n.id;
+  if (e)
+    return U.get(e);
+}
+function Xe(n) {
+  const { id: t, title: e, icon: r, tooltip: i, order: d = 100, children: s } = n, c = S(null), u = Z(
+    (g) => {
+      c.current = g, g && (K.set(g, s), t && U.set(t, s));
+    },
+    [s, t]
+  );
+  return p(() => () => {
+    const g = c.current;
+    g && (K.delete(g), t && U.delete(t));
+  }, [t]), /* @__PURE__ */ b(
+    "tbw-grid-tool-panel",
+    {
+      ref: u,
+      id: t,
+      title: e,
+      icon: r,
+      tooltip: i,
+      order: d?.toString()
+    }
+  );
+}
+const R = /* @__PURE__ */ new WeakMap(), E = /* @__PURE__ */ new Map();
+function et(n, t) {
+  const e = n.getAttribute("field"), r = R.get(n) ?? {};
+  if (r.renderer = t, R.set(n, r), e) {
+    const i = E.get(e) ?? {};
+    i.renderer = t, E.set(e, i);
+  }
+}
+function tt(n, t) {
+  const e = n.getAttribute("field"), r = R.get(n) ?? {};
+  if (r.editor = t, R.set(n, r), e) {
+    const i = E.get(e) ?? {};
+    i.editor = t, E.set(e, i);
+  }
+}
+function Le(n) {
+  let t = R.get(n)?.renderer;
+  if (!t) {
+    const e = n.getAttribute("field");
+    e && (t = E.get(e)?.renderer);
+  }
+  return t;
+}
+function Te(n) {
+  let t = R.get(n)?.editor;
+  if (!t) {
+    const e = n.getAttribute("field");
+    e && (t = E.get(e)?.editor);
+  }
+  return t;
+}
+class ue {
+  mountedViews = [];
+  typeDefaults = null;
+  /**
+   * Sets the type defaults map for this adapter.
+   * Called by DataGrid when it receives type defaults from context.
+   *
+   * @internal
+   */
+  setTypeDefaults(t) {
+    this.typeDefaults = t;
+  }
+  /**
+   * Determines if this adapter can handle the given element.
+   * Checks if a renderer or editor is registered for this element.
+   */
+  canHandle(t) {
+    const e = t.getAttribute("field");
+    let r = R.get(t);
+    if (!r && e) {
+      const s = E.get(e);
+      s && (s.renderer || s.editor) && (r = s, R.set(t, r));
+    }
+    const i = r?.renderer !== void 0, d = r?.editor !== void 0;
+    return r !== void 0 && (i || d);
+  }
+  /**
+   * Creates a view renderer function that renders a React component
+   * and returns its container DOM element.
+   *
+   * Uses a cell cache to reuse React roots for performance - instead of
+   * creating new roots on each render, we reuse existing ones and just
+   * call root.render() with new data.
+   *
+   * Returns undefined if no renderer is registered for this element,
+   * allowing the grid to use its default rendering.
+   */
+  createRenderer(t) {
+    const e = Le(t);
+    if (!e)
+      return;
+    const r = /* @__PURE__ */ new WeakMap();
+    return (i) => {
+      const d = i.cellEl;
+      if (d) {
+        const u = r.get(d);
+        if (u)
+          return y(() => {
+            u.root.render(e(i));
+          }), u.container;
+        const g = document.createElement("div");
+        g.className = "react-cell-renderer", g.style.display = "contents";
+        const h = v(g);
+        return y(() => {
+          h.render(e(i));
+        }), r.set(d, { root: h, container: g, lastRowIndex: i.rowIndex ?? -1 }), this.mountedViews.push({ root: h, container: g }), g;
+      }
+      const s = document.createElement("div");
+      s.className = "react-cell-renderer", s.style.display = "contents";
+      const c = v(s);
+      return y(() => {
+        c.render(e(i));
+      }), this.mountedViews.push({ root: c, container: s }), s;
+    };
+  }
+  /**
+   * Creates an editor spec that renders a React component
+   * with commit/cancel callbacks passed as props.
+   */
+  createEditor(t) {
+    const e = Te(t);
+    return e ? (r) => {
+      const i = document.createElement("div");
+      i.className = "react-cell-editor", i.style.display = "contents";
+      const d = v(i);
+      return y(() => {
+        d.render(e(r));
+      }), this.mountedViews.push({ root: d, container: i }), i;
+    } : () => document.createElement("div");
+  }
+  /**
+   * Creates a detail renderer function for MasterDetailPlugin.
+   * Renders React components for expandable detail rows.
+   */
+  createDetailRenderer(t) {
+    const e = Ie(t);
+    if (e)
+      return (r, i) => {
+        const d = document.createElement("div");
+        d.className = "react-detail-panel";
+        const s = { row: r, rowIndex: i }, c = v(d);
+        return y(() => {
+          c.render(e(s));
+        }), this.mountedViews.push({ root: c, container: d }), d;
+      };
+  }
+  /**
+   * Framework adapter hook called by MasterDetailPlugin during attach().
+   * Parses the <tbw-grid-detail> element and returns a React-based renderer.
+   */
+  parseDetailElement(t) {
+    const e = t.closest("tbw-grid");
+    if (e)
+      return this.createDetailRenderer(e);
+  }
+  /**
+   * Creates a responsive card renderer function for ResponsivePlugin.
+   * Renders React components for card layout in responsive mode.
+   */
+  createResponsiveCardRenderer(t) {
+    const e = de(t);
+    if (e)
+      return (r, i) => {
+        const d = document.createElement("div");
+        d.className = "react-responsive-card";
+        const s = { row: r, index: i }, c = v(d);
+        return y(() => {
+          c.render(e(s));
+        }), this.mountedViews.push({ root: c, container: d }), d;
+      };
+  }
+  /**
+   * Creates a tool panel renderer from a light DOM element.
+   * Renders React components into tool panel containers.
+   */
+  createToolPanelRenderer(t) {
+    const e = Ve(t);
+    if (!e)
+      return;
+    const r = t.closest("tbw-grid");
+    return (i) => {
+      const d = {
+        grid: r ?? i
+      }, s = v(i);
+      return y(() => {
+        s.render(e(d));
+      }), this.mountedViews.push({ root: s, container: i }), () => {
+        const c = this.mountedViews.findIndex((u) => u.container === i);
+        if (c !== -1) {
+          const { root: u } = this.mountedViews[c];
+          try {
+            u.unmount();
+          } catch {
+          }
+          this.mountedViews.splice(c, 1);
+        }
+      };
+    };
+  }
+  /**
+   * Gets type-level defaults from the type defaults map.
+   *
+   * This enables application-wide type defaults configured via GridTypeProvider.
+   * The returned TypeDefault contains renderer/editor functions that render
+   * React components into the grid's cells.
+   *
+   * @example
+   * ```tsx
+   * // App.tsx
+   * const typeDefaults = {
+   *   country: {
+   *     renderer: (ctx) => <CountryBadge code={ctx.value} />,
+   *     editor: (ctx) => <CountrySelect value={ctx.value} onCommit={ctx.commit} />
+   *   }
+   * };
+   *
+   * <GridTypeProvider defaults={typeDefaults}>
+   *   <App />
+   * </GridTypeProvider>
+   *
+   * // Any grid with type: 'country' columns will use these components
+   * ```
+   */
+  getTypeDefault(t) {
+    if (!this.typeDefaults)
+      return;
+    const e = this.typeDefaults[t];
+    if (!e)
+      return;
+    const r = {
+      editorParams: e.editorParams
+    };
+    return e.renderer && (r.renderer = this.createTypeRenderer(e.renderer)), e.editor && (r.editor = this.createTypeEditor(e.editor)), r;
+  }
+  /**
+   * Creates a renderer function from a React render function for type defaults.
+   * @internal
+   */
+  createTypeRenderer(t) {
+    return (e) => {
+      const r = document.createElement("span");
+      r.style.display = "contents";
+      const i = v(r);
+      return this.mountedViews.push({ root: i, container: r }), y(() => {
+        i.render(t(e));
+      }), r;
+    };
+  }
+  /**
+   * Creates an editor function from a React render function for type defaults.
+   * @internal
+   */
+  createTypeEditor(t) {
+    return (e) => {
+      const r = document.createElement("span");
+      r.style.display = "contents";
+      const i = v(r);
+      return this.mountedViews.push({ root: i, container: r }), y(() => {
+        i.render(t(e));
+      }), r;
+    };
+  }
+  /**
+   * Clean up all mounted React roots.
+   * Call this when the grid is unmounted.
+   */
+  destroy() {
+    this.mountedViews.forEach(({ root: t }) => {
+      try {
+        t.unmount();
+      } catch {
+      }
+    }), this.mountedViews = [];
+  }
+  /**
+   * Unmount a specific container (called when cell is recycled).
+   */
+  unmount(t) {
+    const e = this.mountedViews.findIndex((r) => r.container === t);
+    if (e !== -1) {
+      const { root: r } = this.mountedViews[e];
+      try {
+        r.unmount();
+      } catch {
+      }
+      this.mountedViews.splice(e, 1);
+    }
+  }
+}
+const rt = ue, ke = {
+  undoRedo: ["editing"],
+  clipboard: ["selection"]
+};
+function Fe(n) {
+  const t = new Set(n);
+  for (const e of n) {
+    const r = ke[e];
+    if (r)
+      for (const i of r)
+        t.has(i) || console.warn(
+          `[DataGrid] Feature "${e}" requires "${i}" to be enabled. Add the "${i}" prop to your DataGrid.`
+        );
+  }
+}
+function Me(n) {
+  const t = [], e = [], r = { ...n };
+  r.multiSort !== void 0 ? delete r.sorting : r.sorting !== void 0 && (r.multiSort = r.sorting, delete r.sorting);
+  for (const [s, c] of Object.entries(r)) {
+    if (c === void 0 || c === !1) continue;
+    const u = s;
+    e.push(u);
+  }
+  Fe(e);
+  const i = [
+    "selection",
+    "editing",
+    // Then everything else in the order they were specified
+    ...e.filter((s) => s !== "selection" && s !== "editing")
+  ], d = [...new Set(i)].filter((s) => e.includes(s));
+  for (const s of d) {
+    const c = n[s];
+    if (c === void 0 || c === !1) continue;
+    const u = we(s, c);
+    u && t.push(u);
+  }
+  return t;
+}
+let ae = !1, _ = null;
+function J() {
+  return ae || (_ = new ue(), pe.registerAdapter(_), ae = !0), _;
+}
+J();
+const Oe = Y(null);
+function je(n) {
+  const e = n.getPluginByName?.("masterDetail");
+  e && typeof e.refreshDetailRenderer == "function" && e.refreshDetailRenderer();
+}
+function He(n, t) {
+  const e = n;
+  if (!n.querySelector("tbw-grid-responsive-card") || !de(n)) return;
+  const d = e.getPluginByName?.("responsive");
+  if (d && typeof d.setCardRenderer == "function") {
+    const s = t.createResponsiveCardRenderer(n);
+    s && d.setCardRenderer(s);
+  }
+}
+function ze(n) {
+  const t = {};
+  return he.forEach(n, (e) => {
+    if (ve(e)) {
+      if (e.type && e.type.displayName === "GridDetailPanel") {
+        const r = e.props;
+        t.masterDetail = {
+          // Use props from the child component for configuration
+          showExpandColumn: r.showExpandColumn ?? !0,
+          animation: r.animation ?? "slide"
+          // detailRenderer will be wired up by refreshMasterDetailRenderer after mount
+        };
+      }
+      e.type && e.type.displayName === "GridResponsiveCard" && (t.responsive = !0);
+    }
+  }), t;
+}
+const nt = me(function(t, e) {
+  const {
+    // Core props
+    rows: r,
+    gridConfig: i,
+    columns: d,
+    columnDefaults: s,
+    fitMode: c,
+    sortable: u,
+    filterable: g,
+    selectable: h,
+    loading: k,
+    editOn: F,
+    customStyles: N,
+    className: le,
+    style: fe,
+    children: M,
+    // Plugin props
+    plugins: D,
+    // SSR mode
+    ssr: X,
+    // Legacy event handlers
+    onRowsChange: O,
+    // Feature props and event props are in ...rest
+    ...C
+  } = t, l = S(null), V = S(null), ee = I(Se), j = I(De), te = [
+    "selection",
+    "editing",
+    "filtering",
+    "multiSort",
+    "sorting",
+    // deprecated alias for multiSort
+    "clipboard",
+    "contextMenu",
+    "reorder",
+    "rowReorder",
+    "visibility",
+    "undoRedo",
+    "tree",
+    "groupingRows",
+    "groupingColumns",
+    "pinnedColumns",
+    "pinnedRows",
+    "masterDetail",
+    "responsive",
+    "columnVirtualization",
+    "export",
+    "print",
+    "pivot",
+    "serverSide"
+  ], ge = w(() => te.map((o) => {
+    const a = C[o];
+    return a !== void 0 ? `${o}:${JSON.stringify(a)}` : "";
+  }).filter(Boolean).join("|"), [C]), re = w(() => {
+    const o = {};
+    for (const a of te)
+      a in C && C[a] !== void 0 && (o[a] = C[a]);
+    return o;
+  }, [ge]), ne = w(() => ze(M), [M]), oe = w(() => ({ ...ne, ...re }), [re, ne]), H = w(() => D || X ? [] : Me(oe), [oe, D, X]), x = w(() => {
+    if (D) {
+      const o = new Set(D.map((f) => f.name)), a = H.filter((f) => !o.has(f.name));
+      return [...D, ...a];
+    }
+    return H;
+  }, [D, H]), A = w(() => {
+    if (!d) return d;
+    const o = Ee(d);
+    return s ? o.map((a) => ({
+      ...s,
+      ...a
+      // Individual column props override defaults
+    })) : o;
+  }, [d, s]), G = w(() => {
+    const o = Ge(i), a = {};
+    if (u !== void 0 && (a.sortable = u), g !== void 0 && (a.filterable = g), h !== void 0 && (a.selectable = h), j) {
+      const f = o?.icons || i?.icons || {};
+      a.icons = { ...j, ...f };
+    }
+    if (x.length > 0 && o) {
+      const f = o.plugins || [], m = new Set(f.map((P) => P.name)), L = x.filter((P) => !m.has(P.name));
+      return {
+        ...o,
+        ...a,
+        plugins: [...f, ...L]
+      };
+    }
+    return x.length > 0 && !o ? { ...a, plugins: x } : Object.keys(a).length > 0 ? { ...o, ...a } : o;
+  }, [i, x, u, g, h, j]);
+  p(() => {
+    J().setTypeDefaults(ee);
+  }, [ee]), p(() => {
+    l.current && (l.current.rows = r);
+  }, [r]), p(() => {
+    l.current && G && (l.current.gridConfig = G);
+  }, [G]), p(() => {
+    l.current && A && (l.current.columns = A);
+  }, [A]), p(() => {
+    l.current && c !== void 0 && (l.current.fitMode = c);
+  }, [c]), p(() => {
+    l.current && F !== void 0 && (l.current.editOn = F);
+  }, [F]), p(() => {
+    l.current && k !== void 0 && (l.current.loading = k);
+  }, [k]), p(() => {
+    const o = l.current;
+    if (!o) return;
+    const a = J();
+    o.__frameworkAdapter = a, je(o), He(o, a);
+    let f = !1;
+    const m = requestAnimationFrame(() => {
+      f || (typeof o.refreshColumns == "function" && o.refreshColumns(), typeof o.refreshShellHeader == "function" && o.refreshShellHeader());
+    });
+    return () => {
+      f = !0, cancelAnimationFrame(m);
+    };
+  }, []), p(() => {
+    if (!l.current || !N) return;
+    const o = l.current, a = "react-custom-styles";
+    let f = !0;
+    return o.ready?.().then(() => {
+      f && N && (o.registerStyles?.(a, N), V.current = a);
+    }), () => {
+      f = !1, V.current && (o.unregisterStyles?.(V.current), V.current = null);
+    };
+  }, [N]), p(() => {
+    const o = l.current;
+    if (!o) return;
+    const a = [];
+    if (O) {
+      const f = ((m) => O(m.detail.rows));
+      o.addEventListener("rows-change", f), a.push(["rows-change", f]);
+    }
+    return () => {
+      a.forEach(([f, m]) => {
+        o.removeEventListener(f, m);
+      });
+    };
+  }, [O]);
+  const ie = w(() => Object.keys(z).filter((o) => typeof C[o] == "function").sort().join("|"), [C]), se = S({});
+  for (const o of Object.keys(z))
+    se.current[o] = C[o];
+  return p(() => {
+    const o = l.current;
+    if (!o) return;
+    const a = [];
+    for (const [f, m] of Object.entries(z))
+      if (ie.includes(f)) {
+        const L = ((P) => {
+          se.current[f]?.(P.detail, P);
+        });
+        o.addEventListener(m, L), a.push([m, L]);
+      }
+    return () => {
+      a.forEach(([f, m]) => {
+        o.removeEventListener(f, m);
+      });
+    };
+  }, [ie]), ye(
+    e,
+    () => ({
+      get element() {
+        return l.current;
+      },
+      async getConfig() {
+        return l.current?.getConfig?.() ?? {};
+      },
+      async ready() {
+        return l.current?.ready?.();
+      },
+      async forceLayout() {
+        return l.current?.forceLayout?.();
+      },
+      async toggleGroup(o) {
+        return l.current?.toggleGroup?.(o);
+      },
+      registerStyles(o, a) {
+        l.current?.registerStyles?.(o, a);
+      },
+      unregisterStyles(o) {
+        l.current?.unregisterStyles?.(o);
+      },
+      setRowLoading(o, a) {
+        l.current?.setRowLoading?.(o, a);
+      },
+      setCellLoading(o, a, f) {
+        l.current?.setCellLoading?.(o, a, f);
+      },
+      isRowLoading(o) {
+        return l.current?.isRowLoading?.(o) ?? !1;
+      },
+      isCellLoading(o, a) {
+        return l.current?.isCellLoading?.(o, a) ?? !1;
+      },
+      clearAllLoading() {
+        l.current?.clearAllLoading?.();
+      }
+    }),
+    []
+  ), /* @__PURE__ */ b(
+    "tbw-grid",
+    {
+      ref: (o) => {
+        if (l.current = o, o) {
+          const a = o;
+          G && (a.gridConfig = G), r && (a.rows = r), A && (a.columns = A);
+        }
+      },
+      class: le,
+      style: fe,
+      children: /* @__PURE__ */ b(Oe.Provider, { value: l, children: M })
+    }
+  );
+});
+export {
+  nt as D,
+  Oe as G,
+  rt as R,
+  tt as a,
+  Ye as b,
+  Ue as c,
+  Ne as d,
+  Pe as e,
+  Xe as f,
+  Qe as g,
+  Je as h,
+  ue as i,
+  et as r,
+  Ze as u
+};