impact-nova 2.1.0-alpha.5 → 2.1.0-alpha.6

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

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

package/dist/components/data/data-table/use-data-table-column-list-sync.d.ts

@@ -0,0 +1,16 @@
+import { GridApi } from 'ag-grid-community';
+import { NestedListItem } from '../nested-list/nested-list.types';
+export interface UseDataTableColumnListSyncOptions {
+    gridApi: GridApi | null;
+    frozenColumnsLabel: string;
+    scrollableColumnsLabel: string;
+}
+export declare function useDataTableColumnListSync({ gridApi, frozenColumnsLabel, scrollableColumnsLabel, }: UseDataTableColumnListSyncOptions): {
+    items: NestedListItem[];
+    isReady: boolean;
+    externalSyncKey: boolean;
+    listWrapperRef: import('react').RefObject<HTMLDivElement | null>;
+    handleChange: (currentItems: NestedListItem[], enableApplyDiscard: boolean) => void;
+    handleSubmit: (finalItems: NestedListItem[]) => void;
+    handlePinChange: (itemId: string, newPinned: "left" | "right" | null) => void;
+};

package/dist/components/data/data-table/use-data-table-column-list-sync.js

@@ -0,0 +1,222 @@
+import { useState as M, useRef as h, useCallback as a, useEffect as x } from "react";
+import { mergePartialOrderedColumnState as L } from "./data-table-column-state.js";
+import { afterSynchronousColumnApply as b, normalizeColumnPinned as q, GRID_AUTO_UNPIN_WAIT_MS as H, alignColumnTreePinMetadata as N, EXTERNAL_SYNC_DEBOUNCE_MS as J, readGridColumnPinned as Q } from "./data-table-column-apply.js";
+import { buildColumnTreeFromGrid as Z } from "./build-column-tree-from-grid.js";
+import { computeColumnListSyncFingerprints as z, resolveColumnListSyncMode as A } from "./data-table-column-list-sync.js";
+import { subscribeGridApiEvent as j } from "../ag-grid-react/grid-api-event-subscription.js";
+function se({
+  gridApi: n,
+  frozenColumnsLabel: O,
+  scrollableColumnsLabel: _
+}) {
+  const [K, v] = M([]), [V, W] = M(!1), [w, B] = M(!1), i = h(!1), E = h(null), S = h(0), y = h(""), P = h(""), C = a(() => !n || i.current ? null : Z(n, {
+    frozenColumns: O,
+    scrollableColumns: _
+  }), [n, O, _]), g = a(
+    (t, e, o) => {
+      const l = y.current, c = z(t);
+      y.current = c.structural, P.current = c.indicators, v(t), W(!0), e === "structural" && l !== "" && B((d) => !d);
+    },
+    [n]
+  ), p = a(
+    (t = "unknown") => {
+      const e = C();
+      e && g(e, "structural", t);
+    },
+    [g, C, n]
+  ), D = a(
+    (t) => {
+      const e = C();
+      if (!e) return;
+      const o = A(
+        e,
+        y.current,
+        P.current
+      );
+      if (o !== "skip") {
+        if (o === "structural") {
+          const l = E.current?.querySelector(
+            '[data-component="nested-list"] .overflow-y-auto'
+          );
+          l && (S.current = l.scrollTop);
+        }
+        g(e, o, t);
+      }
+    },
+    [g, C]
+  );
+  x(() => {
+    if (!n) return;
+    queueMicrotask(() => p("initial"));
+    const t = [
+      "columnVisible",
+      "columnPinned",
+      "columnMoved",
+      "gridReady",
+      "columnGroupOpened",
+      "columnRowGroupChanged",
+      "columnPivotModeChanged",
+      "columnEverythingChanged",
+      "dragStopped",
+      "columnValueChanged",
+      "displayedColumnsChanged",
+      "sortChanged",
+      "filterChanged",
+      "newColumnsLoaded"
+    ];
+    let e = null;
+    const o = (c) => {
+      i.current || (e && clearTimeout(e), e = setTimeout(() => {
+        e = null, !(i.current || n.isDestroyed()) && D(`grid:${c}`);
+      }, J));
+    }, l = t.map(
+      (c) => j(n, c, () => {
+        o(c);
+      })
+    );
+    return () => {
+      e && clearTimeout(e), l.forEach((c) => c());
+    };
+  }, [n, p, D]), x(() => {
+    if (S.current === 0) return;
+    const t = requestAnimationFrame(() => {
+      const e = E.current?.querySelector(
+        '[data-component="nested-list"] .overflow-y-auto'
+      );
+      e && (e.scrollTop = S.current, S.current = 0);
+    });
+    return () => cancelAnimationFrame(t);
+  }, [w]);
+  const U = a(
+    (t) => {
+      const e = [], o = (l, c) => {
+        l.forEach((r) => {
+          if (r.id === "root-frozen") {
+            r.children && o(r.children, "left");
+            return;
+          }
+          if (r.id === "root-scrollable") {
+            r.children && o(r.children, null);
+            return;
+          }
+          if (r.category === "group" || r.children && r.children.length > 0)
+            r.children && o(r.children, c);
+          else {
+            let u;
+            if (c === null)
+              u = null;
+            else {
+              const f = r.data?.pinned;
+              u = f === "left" || f === "right" ? f : c;
+            }
+            e.push({
+              colId: r.id,
+              pinned: u,
+              hide: !r.checked
+            });
+          }
+        });
+      };
+      return o(t, null), e;
+    },
+    []
+  ), I = a(
+    (t) => {
+      if (!n) return;
+      i.current = !0;
+      const e = U(t);
+      if (e.length === 0) {
+        b(() => {
+          i.current = !1;
+        });
+        return;
+      }
+      const o = n.getColumnState(), l = L(o, e), c = new Set(
+        o.filter((s) => q(s.pinned)).map((s) => s.colId)
+      ), r = l.filter(
+        (s) => q(s.pinned) && !c.has(s.colId)
+      ), d = new Set(r.map((s) => s.colId));
+      n.applyColumnState({ state: l, applyOrder: !0 });
+      const u = () => {
+        i.current = !1, p("handleChanges:releaseLockAndSync");
+      };
+      if (d.size === 0) {
+        b(u);
+        return;
+      }
+      let T = !1, f = null, G = null;
+      G = j(n, "columnPinned", () => {
+        if (T || n.isDestroyed()) return;
+        const s = n.getColumnState();
+        if (r.filter((R) => {
+          const m = s.find((F) => F.colId === R.colId);
+          return m && !m.pinned;
+        }).length > 0) {
+          T = !0, f && clearTimeout(f), G?.();
+          const R = l.filter(
+            (m) => m.pinned && !d.has(m.colId)
+          );
+          if (R.length > 0) {
+            const m = R[0], F = l.map(
+              (k) => k.colId === m.colId ? { ...k, pinned: null } : k
+            );
+            n.applyColumnState({ state: F, applyOrder: !0 });
+          }
+          b(u);
+        }
+      }), f = setTimeout(() => {
+        G?.(), T || u();
+      }, H);
+    },
+    [n, U, p]
+  ), X = a(
+    (t) => {
+      I(N(t));
+    },
+    [I]
+  ), Y = a(
+    (t, e) => {
+      const o = N(t);
+      e || I(o), v(o);
+      const l = z(o);
+      y.current = l.structural, P.current = l.indicators;
+    },
+    [I]
+  ), $ = a(
+    (t, e) => {
+      if (v((c) => {
+        const r = (d) => d.map((u) => u.id === t ? {
+          ...u,
+          data: {
+            ...u.data,
+            pinned: e
+          }
+        } : u.children ? {
+          ...u,
+          children: r(u.children)
+        } : u);
+        return r(c);
+      }), !n) return;
+      i.current = !0;
+      const o = n.getColumnState(), l = L(o, [
+        { colId: t, pinned: e }
+      ]);
+      n.applyColumnState({ state: l, applyOrder: !0 }), b(() => {
+        i.current = !1, Q(n, t) !== e && p("handlePinChange");
+      });
+    },
+    [n, p]
+  );
+  return {
+    items: K,
+    isReady: V,
+    externalSyncKey: w,
+    listWrapperRef: E,
+    handleChange: Y,
+    handleSubmit: X,
+    handlePinChange: $
+  };
+}
+export {
+  se as useDataTableColumnListSync
+};

package/dist/components/forms/select/hooks/useSelectValueState.d.ts

@@ -0,0 +1,19 @@
+import { Option, PropsValue } from '../select.types';
+export interface UseSelectValueStateParams<OptionType> {
+    value: PropsValue<OptionType> | undefined;
+    defaultValue: PropsValue<OptionType> | undefined;
+    isMulti: boolean;
+    onChange?: unknown;
+}
+export interface UseSelectValueStateResult<OptionType> {
+    usesMenuSession: boolean;
+    currentValue: PropsValue<OptionType>;
+    setCurrentValue: (next: PropsValue<OptionType>) => void;
+    beginMenuSession: () => void;
+    endMenuSession: () => PropsValue<OptionType> | undefined;
+}
+/**
+ * Controlled selects without `onChange` keep edits in a menu session so
+ * `onMenuClose` can batch-commit without stale `value` props.
+ */
+export declare function useSelectValueState<OptionType extends Option = Option>({ value, defaultValue, isMulti, onChange, }: UseSelectValueStateParams<OptionType>): UseSelectValueStateResult<OptionType>;

package/dist/components/forms/select/hooks/useSelectValueState.js

@@ -0,0 +1,41 @@
+import { useState as i, useRef as v, useCallback as r } from "react";
+import { cloneSelectValue as M } from "../utils/select.js";
+function h({
+  value: c,
+  defaultValue: V,
+  isMulti: s,
+  onChange: f
+}) {
+  const u = c !== void 0, e = u && f === void 0, [S, d] = i(
+    V ?? (s ? [] : null)
+  ), [a, l] = i(null), o = v(null), t = u ? c : S, m = e && a !== null ? a : t, p = r(
+    (n) => {
+      if (!u) {
+        d(n);
+        return;
+      }
+      e && (o.current = n, l(n));
+    },
+    [u, e]
+  ), C = r(() => {
+    if (!e)
+      return;
+    const n = M(t, s);
+    o.current = n, l(n);
+  }, [e, t, s]), b = r(() => {
+    if (!e)
+      return;
+    const n = o.current ?? t;
+    return o.current = null, l(null), n;
+  }, [e, t]);
+  return {
+    usesMenuSession: e,
+    currentValue: m,
+    setCurrentValue: p,
+    beginMenuSession: C,
+    endMenuSession: b
+  };
+}
+export {
+  h as useSelectValueState
+};

package/dist/components/forms/select/index.js

@@ -1,13 +1,14 @@
 import { Select as n } from "./select.js";
-import { cx as r, getIndeterminateState as i, getLeafOptions as c, getSelectedCount as S, getSequence as a, isInvertedSelection as d, isOptionArray as g, isSelected as l } from "./utils/select.js";
+import { cloneSelectValue as c, cx as r, getIndeterminateState as i, getLeafOptions as l, getSelectedCount as S, getSequence as a, isInvertedSelection as d, isOptionArray as g, isSelected as p } from "./utils/select.js";
 export {
   n as Select,
+  c as cloneSelectValue,
   r as cx,
   i as getIndeterminateState,
-  c as getLeafOptions,
+  l as getLeafOptions,
   S as getSelectedCount,
   a as getSequence,
   d as isInvertedSelection,
   g as isOptionArray,
-  l as isSelected
+  p as isSelected
 };