impact-nova 2.0.9 → 2.1.0-alpha.10

package/dist/components/data/data-table/data-table-sheet-context.js

@@ -0,0 +1,18 @@
+import { useContext as t, createContext as n } from "react";
+const s = n(!1), o = n(null), h = () => {
+  const e = t(s), a = t(o);
+  if (!a)
+    throw new Error("useDataTableSheet must be used within DataTableSheet");
+  return { open: e, setOpen: a };
+}, u = () => {
+  const e = t(o);
+  if (!e)
+    throw new Error("useDataTableSheetApi must be used within DataTableSheet");
+  return { setOpen: e };
+};
+export {
+  o as DataTableSheetApiContext,
+  s as DataTableSheetStateContext,
+  h as useDataTableSheet,
+  u as useDataTableSheetApi
+};

package/dist/components/data/data-table/data-table-sheet-portal-store.d.ts

@@ -0,0 +1,13 @@
+export interface DataTableSheetPortalSnapshot {
+    sheetTarget: HTMLDivElement | null;
+    scopedSheetOpen: boolean;
+}
+export interface DataTableSheetPortalStore {
+    getSnapshot: () => DataTableSheetPortalSnapshot;
+    subscribe: (listener: () => void) => () => void;
+    setSheetTarget: (sheetTarget: HTMLDivElement | null) => void;
+    registerScopedSheetDepth: (delta: 1 | -1) => void;
+    reset: () => void;
+}
+export declare function createDataTableSheetPortalStore(): DataTableSheetPortalStore;
+export declare function useDataTableSheetPortalSnapshot(store: DataTableSheetPortalStore): DataTableSheetPortalSnapshot;

package/dist/components/data/data-table/data-table-sheet-portal-store.js

@@ -0,0 +1,36 @@
+import { useSyncExternalStore as o } from "react";
+function p() {
+  let t = 0, n = {
+    sheetTarget: null,
+    scopedSheetOpen: !1
+  };
+  const r = /* @__PURE__ */ new Set(), a = () => {
+    r.forEach((e) => e());
+  };
+  return {
+    getSnapshot: () => n,
+    subscribe: (e) => (r.add(e), () => r.delete(e)),
+    setSheetTarget: (e) => {
+      n.sheetTarget !== e && (n = { ...n, sheetTarget: e }, a());
+    },
+    registerScopedSheetDepth: (e) => {
+      t = Math.max(0, t + e);
+      const s = t > 0;
+      n.scopedSheetOpen !== s && (n = { ...n, scopedSheetOpen: s }, a());
+    },
+    reset: () => {
+      t = 0, n = { sheetTarget: null, scopedSheetOpen: !1 }, a();
+    }
+  };
+}
+function S(t) {
+  return o(
+    t.subscribe,
+    t.getSnapshot,
+    t.getSnapshot
+  );
+}
+export {
+  p as createDataTableSheetPortalStore,
+  S as useDataTableSheetPortalSnapshot
+};

package/dist/components/data/data-table/data-table-sheet.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { DataTableSheetProps } from './data-table.types';
+export type { DataTableSheetProps } from './data-table.types';
+export declare const DataTableSheet: ({ children, defaultOpen, open: controlledOpen, onOpenChange, }: DataTableSheetProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DataTableSheetTrigger: ({ children, asChild, }: {
+    children: React.ReactNode;
+    asChild?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const DataTableSheetHeader: ({ title, children, className, }: {
+    title?: React.ReactNode;
+    children?: React.ReactNode;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const DataTableSheetContent: ({ children, className, }: {
+    children: React.ReactNode;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/data/data-table/data-table-sheet.js

@@ -0,0 +1,137 @@
+import { jsx as t, jsxs as c } from "react/jsx-runtime";
+import d, { useState as b, useEffect as u, useCallback as T } from "react";
+import { createPortal as g } from "react-dom";
+import { Cross as C } from "impact-nova-icons";
+import { cn as f } from "../../../lib/utils.js";
+import { Button as x } from "../../primitives/button/button.js";
+import { useDataTable as w, useDataTableSheetPortal as D } from "./data-table-context.js";
+import { DATA_TABLE_SCOPED_SHEET_HOST_MIN_HEIGHT_PX as v } from "./data-table-constants.js";
+import { DataTableSheetApiContext as N, DataTableSheetStateContext as k, useDataTableSheet as S, useDataTableSheetApi as _ } from "./data-table-sheet-context.js";
+const I = ({
+  children: n,
+  defaultOpen: r = !1,
+  open: e,
+  onOpenChange: o
+}) => {
+  const { registerScopedSheetDepth: a } = w(), [s, i] = b(r), l = e !== void 0 ? e : s, h = d.useRef(o);
+  u(() => {
+    h.current = o;
+  });
+  const y = T((p) => {
+    e === void 0 && i(p), h.current?.(p);
+  }, [e]);
+  return u(() => {
+    if (l)
+      return a(1), () => {
+        a(-1);
+      };
+  }, [l, a]), /* @__PURE__ */ t(N.Provider, { value: y, children: /* @__PURE__ */ t(k.Provider, { value: l, children: n }) });
+}, M = ({
+  children: n,
+  asChild: r
+}) => {
+  const { setOpen: e, open: o } = S(), a = () => {
+    e(!o);
+  };
+  if (r) {
+    const s = d.Children.only(n);
+    return d.cloneElement(s, {
+      onClick: (i) => {
+        s.props.onClick?.(i), a();
+      }
+    });
+  }
+  return /* @__PURE__ */ t(x, { variant: "outline", onClick: a, children: n });
+}, G = ({
+  title: n,
+  children: r,
+  className: e
+}) => {
+  const { setOpen: o } = _();
+  return /* @__PURE__ */ c(
+    "div",
+    {
+      className: f(
+        "flex shrink-0 flex-row justify-between items-center px-4 py-3 mb-2 bg-brand-tint",
+        e
+      ),
+      children: [
+        /* @__PURE__ */ t("div", { className: "flex items-center gap-2", children: n && /* @__PURE__ */ t("h2", { className: "font-[Manrope] font-bold text-base text-content", children: n }) }),
+        /* @__PURE__ */ c("div", { className: "flex items-center gap-2", children: [
+          r,
+          /* @__PURE__ */ t(
+            x,
+            {
+              type: "button",
+              variant: "ghost",
+              size: "iconSm",
+              "data-component": "data-table-sheet-close",
+              className: "close_icon h-6 w-6 rounded-full hover:bg-muted/50",
+              "aria-label": "Close",
+              onClick: () => o(!1),
+              children: /* @__PURE__ */ t(C, { className: "!h-3 !w-3 text-content-icon" })
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}, L = ({
+  children: n,
+  className: r
+}) => {
+  const { open: e } = S(), { sheetTarget: o } = D(), [a, s] = b(!1);
+  if (e && !a && s(!0), !a) return null;
+  const i = /* @__PURE__ */ c(
+    "div",
+    {
+      className: f(
+        "-my-px flex h-[calc(100%_+_2px)]",
+        e && "animate-in slide-in-from-right-[100%] duration-200 ease-in-out fade-in fill-mode-forwards motion-reduce:animate-none motion-reduce:transition-none"
+      ),
+      style: {
+        minHeight: v,
+        display: e ? void 0 : "none"
+      },
+      children: [
+        /* @__PURE__ */ t("div", { className: "w-[10px] bg-canvas-elevated border-l border-stroke-hairline shrink-0" }),
+        /* @__PURE__ */ t(
+          "div",
+          {
+            "data-component": "data-table-sheet-panel",
+            className: f(
+              "relative flex h-full w-[355px] flex-col overflow-y-auto bg-canvas-elevated border-t border-l border-stroke-hairline pointer-events-auto shadow-elevation-floating",
+              r
+            ),
+            children: n
+          }
+        ),
+        /* @__PURE__ */ t("div", { className: "w-[16px] bg-canvas-elevated border-l border-stroke-hairline shrink-0" })
+      ]
+    }
+  ), m = /* @__PURE__ */ t(
+    "div",
+    {
+      className: "pointer-events-none absolute inset-0 z-[35] flex justify-end overflow-x-hidden overflow-y-visible",
+      style: { display: e ? void 0 : "none" },
+      children: i
+    }
+  );
+  return o ? g(m, o) : /* @__PURE__ */ t(
+    "div",
+    {
+      className: "pointer-events-none fixed inset-0 z-[35] flex justify-end overflow-x-hidden overflow-y-visible",
+      style: {
+        minHeight: v,
+        display: e ? void 0 : "none"
+      },
+      children: i
+    }
+  );
+};
+export {
+  I as DataTableSheet,
+  L as DataTableSheetContent,
+  G as DataTableSheetHeader,
+  M as DataTableSheetTrigger
+};

package/dist/components/data/data-table/data-table-view-menu.d.ts

@@ -0,0 +1,16 @@
+import { DropdownMenuTrigger } from '../../feedback/dropdown-menu';
+import * as React from "react";
+export declare const DataTableViewMenuTrigger: {
+    ({ children, ...props }: Omit<React.ComponentPropsWithoutRef<typeof DropdownMenuTrigger>, "asChild">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const DataTableViewMenuContent: React.ForwardRefExoticComponent<Omit<Omit<import('@radix-ui/react-dropdown-menu').DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    portalled?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const DataTableViewMenuSettingsItem: () => import("react/jsx-runtime").JSX.Element;
+export declare const DataTableViewMenuDensity: () => import("react/jsx-runtime").JSX.Element;
+export interface DataTableViewMenuViewportExpandProps {
+    expanded: boolean;
+    onExpandedChange: (expanded: boolean) => void;
+}
+export declare const DataTableViewMenuViewportExpand: ({ expanded, onExpandedChange, }: DataTableViewMenuViewportExpandProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/data/data-table/data-table-view-menu.js

@@ -0,0 +1,133 @@
+import { jsx as a, jsxs as s } from "react/jsx-runtime";
+import * as c from "react";
+import { DropdownMenuContent as p, DropdownMenuSub as m, DropdownMenuSubTrigger as d, DropdownMenuSubContent as u, DropdownMenuRadioGroup as g, DropdownMenuRadioItem as r, DropdownMenuItem as l, DropdownMenuTrigger as f } from "../../feedback/dropdown-menu/dropdown-menu.js";
+import { Button as h } from "../../primitives/button/button.js";
+import { cn as b } from "../../../lib/utils.js";
+import { Density as x, Stack as T, StackCompact as w, StackComfort as D, Settings as N, ThreeDots as C, Collapse as M, Expand as S } from "impact-nova-icons";
+import { useImpactNovaI18n as i } from "../../../i18n/use-impact-nova-i18n.js";
+import { useDataTable as v } from "./data-table-context.js";
+import { DataTableSheetTrigger as P } from "./data-table-sheet.js";
+const y = ({
+  children: t,
+  ...n
+}) => {
+  const { t: o } = i();
+  return /* @__PURE__ */ a(f, { asChild: !0, ...n, children: t ?? /* @__PURE__ */ s(h, { variant: "secondary", size: "icon", "aria-label": o("dataTable.more"), children: [
+    /* @__PURE__ */ a(C, { size: "sm" }),
+    /* @__PURE__ */ a("span", { className: "sr-only", children: o("dataTable.openMenu") })
+  ] }) });
+};
+y.displayName = "DataTableViewMenuTrigger";
+const k = c.forwardRef(({ className: t, align: n = "end", ...o }, e) => /* @__PURE__ */ a(
+  p,
+  {
+    ref: e,
+    align: n,
+    "data-component": "data-table-view-menu",
+    className: b("w-[240px] flex flex-col gap-[2px]", t),
+    ...o
+  }
+));
+k.displayName = "DataTableViewMenuContent";
+const G = () => {
+  const { t } = i();
+  return /* @__PURE__ */ a(P, { asChild: !0, children: /* @__PURE__ */ a(
+    l,
+    {
+      className: "flex cursor-pointer gap-2",
+      onClick: (n) => n.stopPropagation(),
+      onSelect: (n) => n.stopPropagation(),
+      children: /* @__PURE__ */ s("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ a(N, { size: "sm", className: "text-content-icon" }),
+        /* @__PURE__ */ a("span", { children: t("dataTable.tableSettings") })
+      ] })
+    }
+  ) });
+}, q = () => {
+  const { t } = i(), { rowHeight: n, setRowHeight: o } = v();
+  return /* @__PURE__ */ s(m, { children: [
+    /* @__PURE__ */ s(
+      d,
+      {
+        className: "flex items-center gap-2 cursor-pointer",
+        onClick: (e) => e.stopPropagation(),
+        children: [
+          /* @__PURE__ */ a(x, { size: "sm", className: "text-content-icon" }),
+          /* @__PURE__ */ a("span", { children: t("dataTable.contentDensity") })
+        ]
+      }
+    ),
+    /* @__PURE__ */ a(u, { className: "w-[190px]", children: /* @__PURE__ */ s(
+      g,
+      {
+        value: n,
+        onValueChange: (e) => o(e),
+        className: "flex flex-col gap-0.5",
+        children: [
+          /* @__PURE__ */ a(
+            r,
+            {
+              value: "default",
+              onClick: (e) => e.stopPropagation(),
+              onSelect: (e) => e.stopPropagation(),
+              children: /* @__PURE__ */ s("div", { className: "flex items-center gap-2", children: [
+                /* @__PURE__ */ a(T, { size: "sm", className: "text-content-icon" }),
+                t("dataTable.densityDefault")
+              ] })
+            }
+          ),
+          /* @__PURE__ */ a(
+            r,
+            {
+              value: "compact",
+              onClick: (e) => e.stopPropagation(),
+              onSelect: (e) => e.stopPropagation(),
+              children: /* @__PURE__ */ s("div", { className: "flex items-center gap-2", children: [
+                /* @__PURE__ */ a(w, { size: "sm", className: "text-content-icon" }),
+                t("dataTable.densityCompact")
+              ] })
+            }
+          ),
+          /* @__PURE__ */ a(
+            r,
+            {
+              value: "comfort",
+              onClick: (e) => e.stopPropagation(),
+              onSelect: (e) => e.stopPropagation(),
+              children: /* @__PURE__ */ s("div", { className: "flex items-center gap-2", children: [
+                /* @__PURE__ */ a(D, { size: "sm", className: "text-content-icon" }),
+                t("dataTable.densityComfort")
+              ] })
+            }
+          )
+        ]
+      }
+    ) })
+  ] });
+}, A = ({
+  expanded: t,
+  onExpandedChange: n
+}) => {
+  const { t: o } = i();
+  return /* @__PURE__ */ a(
+    l,
+    {
+      className: "flex cursor-pointer gap-2",
+      onClick: (e) => e.stopPropagation(),
+      onSelect: (e) => {
+        e.stopPropagation(), n(!t);
+      },
+      children: /* @__PURE__ */ s("div", { className: "flex items-center gap-2", children: [
+        t ? /* @__PURE__ */ a(M, { size: "sm", className: "text-content-icon" }) : /* @__PURE__ */ a(S, { size: "sm", className: "text-content-icon" }),
+        /* @__PURE__ */ a("span", { children: o(t ? "dataTable.tableCollapse" : "dataTable.tableExpand") })
+      ] })
+    }
+  );
+};
+export {
+  k as DataTableViewMenuContent,
+  q as DataTableViewMenuDensity,
+  G as DataTableViewMenuSettingsItem,
+  y as DataTableViewMenuTrigger,
+  A as DataTableViewMenuViewportExpand
+};

package/dist/components/data/data-table/data-table.d.ts

@@ -0,0 +1,16 @@
+import { DataTableProps, DataTableContentProps, DataTableToolbarProps } from './data-table.types';
+export type { DataTableProps, DataTableContentProps, DataTableToolbarProps, } from './data-table.types';
+/**
+ * DataTable Root
+ * Provides context and structural container.
+ */
+export declare const DataTable: ({ children, className, }: DataTableProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * DataTable Content — does not subscribe to sheet open/close; only the frame
+ * and sheet UI re-render when the scoped settings panel toggles.
+ */
+export declare function DataTableContent<TData>(props: DataTableContentProps<TData>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Top bar above the grid. Optional — omit to remove the toolbar from the DOM.
+ */
+export declare const DataTableToolbar: ({ children, className, }: DataTableToolbarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/data/data-table/data-table.js

@@ -0,0 +1,202 @@
+import { jsx as n, jsxs as E } from "react/jsx-runtime";
+import { useState as g, useMemo as u, useCallback as D, useEffect as w, memo as v } from "react";
+import { AgGridWrapper as O } from "../ag-grid-react/index.js";
+import { cn as H } from "../../../lib/utils.js";
+import { DataTableContext as F, DataTableSheetPortalStoreContext as I, useDataTable as N, useDataTableSheetPortal as P } from "./data-table-context.js";
+import { createDataTableSheetPortalStore as z } from "./data-table-sheet-portal-store.js";
+import { DATA_TABLE_SCOPED_SHEET_HOST_MIN_HEIGHT_PX as B } from "./data-table-constants.js";
+import { extractRuntimeColumnDefs as M, mergeInitialGridRuntimeState as j } from "./data-table-column-def-pin.js";
+const _ = {
+  default: 46,
+  compact: 30,
+  comfort: 52
+}, U = ({
+  children: i,
+  className: t
+}) => {
+  const [r, e] = g(null), [o, c] = g("medium"), [a, S] = g("full"), [s, f] = g("default"), l = u(() => z(), []), m = D((d) => {
+    l.registerScopedSheetDepth(d);
+  }, [l]), p = D((d) => {
+    e(d);
+  }, []), x = {
+    small: "12px",
+    medium: "14px",
+    large: "16px"
+  }[o], b = `${_[s]}px`, T = u(
+    () => ({
+      gridApi: r,
+      registerApi: p,
+      registerScopedSheetDepth: m,
+      fontSize: o,
+      setFontSize: c,
+      numericFormat: a,
+      setNumericFormat: S,
+      rowHeight: s,
+      setRowHeight: f
+    }),
+    [
+      r,
+      p,
+      m,
+      o,
+      a,
+      s
+    ]
+  );
+  return /* @__PURE__ */ n(F.Provider, { value: T, children: /* @__PURE__ */ n(
+    I.Provider,
+    {
+      value: l,
+      children: /* @__PURE__ */ n(
+        "div",
+        {
+          "data-component": "data-table",
+          className: H(
+            "flex flex-col w-full min-h-0 rounded-[inherit]",
+            t
+          ),
+          style: {
+            "--ag-font-size": x,
+            "--ag-row-height": b
+          },
+          children: i
+        }
+      )
+    }
+  ) });
+}, A = {
+  full: "full_no",
+  k: "thou",
+  m: "mil",
+  b: "bil",
+  full_precision: "full_precision"
+}, k = v(function() {
+  const { setSheetTarget: t } = P();
+  return /* @__PURE__ */ n(
+    "div",
+    {
+      ref: t,
+      className: "absolute inset-0 pointer-events-none z-[39] flex overflow-x-hidden overflow-y-visible"
+    }
+  );
+}), L = v(function({
+  className: t,
+  children: r
+}) {
+  const { scopedSheetOpen: e } = P();
+  return /* @__PURE__ */ E(
+    "div",
+    {
+      className: H(
+        "relative flex-1 min-h-0 w-full bg-canvas-elevated rounded-b-[inherit] grid-rounded-bottom",
+        t
+      ),
+      style: e ? { minHeight: B } : void 0,
+      children: [
+        r,
+        /* @__PURE__ */ n(k, {})
+      ]
+    }
+  );
+}), W = v(function({
+  resolvedRowHeight: t,
+  mergedContext: r,
+  onGridReady: e,
+  columnDefs: o,
+  maintainColumnOrder: c = !0,
+  ...a
+}) {
+  return /* @__PURE__ */ n(
+    O,
+    {
+      ...a,
+      columnDefs: o,
+      rowHeight: t,
+      onGridReady: e,
+      context: r,
+      maintainColumnOrder: c
+    }
+  );
+});
+function Z(i) {
+  const {
+    registerApi: t,
+    rowHeight: r,
+    gridApi: e,
+    numericFormat: o
+  } = N(), {
+    className: c,
+    onGridReady: a,
+    rowHeight: S,
+    context: s,
+    columnDefs: f,
+    initialState: l,
+    suppressInitialRuntimeState: m,
+    maintainColumnOrder: p = !0,
+    ...x
+  } = i, b = _[r], T = S ?? b, { runtimeColumnDefs: d, extractedRuntimeDefaults: y } = u(
+    () => M(f ?? void 0),
+    [f]
+  ), C = u(
+    () => j(
+      l,
+      y,
+      m
+    ),
+    [l, y, m]
+  ), G = u(
+    () => ({
+      ...s,
+      formatType: A[o]
+    }),
+    [s, o]
+  );
+  w(() => {
+    e?.resetRowHeights();
+  }, [r, e]), w(() => {
+    if (e) {
+      const h = e.getGridOption("context") || {};
+      e.setGridOption("context", {
+        ...h,
+        formatType: A[o]
+      }), e.refreshCells({ force: !0 });
+    }
+  }, [o, e]);
+  const R = D(
+    (h) => {
+      t(h.api), a?.(h);
+    },
+    [t, a]
+  );
+  return /* @__PURE__ */ n(L, { className: c, children: /* @__PURE__ */ n(
+    W,
+    {
+      ...x,
+      columnDefs: d,
+      initialState: C,
+      maintainColumnOrder: p,
+      resolvedRowHeight: T,
+      mergedContext: G,
+      onGridReady: R
+    }
+  ) });
+}
+const ee = ({
+  children: i,
+  className: t
+}) => /* @__PURE__ */ n(
+  "div",
+  {
+    "data-component": "data-table-toolbar",
+    className: H(
+      "flex items-center justify-between px-4 py-3 shrink-0 bg-canvas-elevated rounded-t-[inherit]",
+      t
+    ),
+    children: i
+  }
+);
+export {
+  U as DataTable,
+  Z as DataTableContent,
+  ee as DataTableToolbar
+};

package/dist/components/data/data-table/data-table.types.d.ts

@@ -0,0 +1,50 @@
+import { AgGridWrapperProps } from '../ag-grid-react/ag-grid.types';
+import { SuppressInitialRuntimeState } from './data-table-column-def-pin';
+import type * as React from "react";
+/**
+ * Root layout provider for data tables. Compose toolbar, sheet, and `DataTableContent` as children.
+ */
+export type DataTableProps = {
+    children: React.ReactNode;
+    className?: string;
+};
+/**
+ * AG Grid surface — forwards `AgGridReact` grid options (`rowData`, `columnDefs`, `rowModelType`, …)
+ * with Impact Nova styling. See https://www.ag-grid.com/react-data-grid/grid-options/
+ */
+export type DataTableContentProps<TData = unknown> = AgGridWrapperProps<TData> & {
+    className?: string;
+    /**
+     * Skip injecting extracted column pinning/visibility into `initialState` on
+     * first paint — use when a saved view will apply immediately after mount.
+     */
+    suppressInitialRuntimeState?: SuppressInitialRuntimeState;
+};
+/**
+ * Top bar above the grid. Optional — omit to remove the toolbar from the DOM.
+ *
+ * Layout is `justify-between`: place a title or context on the left, actions on the right
+ * (filter toggle, `DataTableSheet` / view menu, export, density, saved views).
+ */
+export type DataTableToolbarProps = {
+    /** Toolbar slots — typically title (left) and action buttons / `DataTableSheet` (right). */
+    children: React.ReactNode;
+    /** Extra classes on the toolbar root (`data-component="data-table-toolbar"`). */
+    className?: string;
+};
+/**
+ * Scoped settings panel state. Renders inside the `DataTable` container (not a viewport modal).
+ *
+ * Compose `DataTableSheetContent` for the slide-in panel, triggers from the toolbar or view menu,
+ * and optional `DataTableColumnList` / `DataTableSavedViews` inside the sheet body.
+ */
+export type DataTableSheetProps = {
+    /** Sheet subtree — typically `DataTableSheetContent`, triggers, and settings panels. */
+    children: React.ReactNode;
+    /** Initial open state when `open` is not provided (uncontrolled). */
+    defaultOpen?: boolean;
+    /** Controlled open state. Pair with `onOpenChange`. */
+    open?: boolean;
+    /** Called when the user opens or closes the sheet. */
+    onOpenChange?: (open: boolean) => void;
+};

package/dist/components/data/data-table/index.d.ts

@@ -0,0 +1,13 @@
+export * from './data-table';
+export * from './data-table-constants';
+export * from './data-table-column-list';
+export * from './data-table-context';
+export * from './data-table-format-options';
+export * from './data-table-sheet';
+export { useDataTableSheet, useDataTableSheetApi } from './data-table-sheet-context';
+export * from './data-table-view-menu';
+export * from './data-table-saved-views';
+export * from './pin-switch';
+export * from './column-indicator';
+export * from './indicator-legend';
+export type { SavedTableViewItem, TableViewTypeOption, DataTableSavedViewsProps, DataTableSavedViewsActionContext, DataTableSavedViewsCancelContext, } from '../data-table/data-table-saved-views.types';