impact-nova 2.3.0 → 2.5.0

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

@@ -1,4 +1,4 @@
-import { jsxs as _, jsx as l } from "react/jsx-runtime";
+import { jsxs as _, jsx as n } from "react/jsx-runtime";
 import { useRef as y, useState as F, useMemo as O, useCallback as i } from "react";
 import { useDataTable as E } from "./data-table-context.js";
 import { useDataTableSheet as z } from "./data-table-sheet-context.js";
@@ -7,16 +7,16 @@ import { SelectionMode as R } from "../nested-list/nested-list.types.js";
 import { useImpactNovaI18n as k } from "../../../i18n/use-impact-nova-i18n.js";
 import { countNestedListLeaves as M, buildCollapsedStateForAllGroups as j } from "../nested-list/nested-list-tree-utils.js";
 import { PinSwitch as G } from "./pin-switch.js";
-import { ColumnIndicator as d } from "./column-indicator.js";
+import { ColumnIndicator as m } from "./column-indicator.js";
 import { IndicatorLegend as H } from "./indicator-legend.js";
 import { useDataTableColumnListSync as U } from "./use-data-table-column-list-sync.js";
-const W = 100, le = ({
+const W = 100, ne = ({
   enableApplyDiscard: o = !1,
-  showSearch: m = !0,
+  showSearch: d = !0,
   showSelectAll: p = !0,
   showCollapse: f = !0
 }) => {
-  const { gridApi: h } = E(), { open: C } = z(), { t: r } = k(), b = y({}), [n, S] = F({}), {
+  const { gridApi: h } = E(), { open: C } = z(), { t: r } = k(), b = y({}), [l, S] = F({}), {
     items: a,
     isReady: L,
     externalSyncKey: g,
@@ -29,7 +29,7 @@ const W = 100, le = ({
     frozenColumnsLabel: r("dataTable.frozenColumns"),
     scrollableColumnsLabel: r("dataTable.scrollableColumns"),
     isSyncActive: C
-  }), I = O(() => Object.keys(n).length > 0 || a.length === 0 || M(a) <= W ? n : j(a), [n, a]), x = i(
+  }), x = O(() => Object.keys(l).length > 0 || a.length === 0 || M(a) <= W ? l : j(a), [l, a]), I = i(
     (e) => {
       c(e, o);
     },
@@ -39,15 +39,15 @@ const W = 100, le = ({
       if (!s.isLeaf) return null;
       const t = e.data;
       return !t?.hasSortApplied && !t?.hasFilterApplied ? null : /* @__PURE__ */ _("span", { className: "inline-flex items-center gap-1 shrink-0", children: [
-        t?.hasSortApplied && /* @__PURE__ */ l(d, { type: "sort" }),
-        t?.hasFilterApplied && /* @__PURE__ */ l(d, { type: "filter" })
+        t?.hasSortApplied && /* @__PURE__ */ n(m, { type: "sort" }),
+        t?.hasFilterApplied && /* @__PURE__ */ n(m, { type: "filter" })
       ] });
     },
     []
   ), v = i(
     (e, s) => {
       const t = e.data;
-      return e.category === "structure" ? e.id !== "root-frozen" ? null : /* @__PURE__ */ l(H, {}) : !s.isLeaf || !(t?.pinned === "left" || t?.pinned === "right") ? null : /* @__PURE__ */ l(
+      return e.category === "structure" ? e.id !== "root-frozen" ? null : /* @__PURE__ */ n(H, {}) : !s.isLeaf || !(t?.pinned === "left" || t?.pinned === "right") ? null : /* @__PURE__ */ n(
         G,
         {
           value: t?.pinned ?? null,
@@ -58,31 +58,31 @@ const W = 100, le = ({
     },
     [u]
   );
-  return L ? /* @__PURE__ */ l("div", { ref: A, className: "flex flex-col h-full bg-canvas-elevated", children: /* @__PURE__ */ l(
+  return L ? /* @__PURE__ */ n("div", { ref: A, className: "flex flex-col flex-1 min-h-0 bg-canvas-elevated", children: /* @__PURE__ */ n(
     P,
     {
       items: a,
-      onChange: x,
+      onChange: I,
       onSubmit: T,
       renderLabelExtras: N,
       renderActions: v,
       enableApplyDiscard: o,
-      enableSearch: m,
+      enableSearch: d,
       enableSelectAll: p,
       enableDragDrop: !0,
       enableCollapse: !0,
       enableGlobalCollapse: f,
       selectionMode: R.CASCADE_DOWN,
       searchPlaceholder: r("dataTable.searchColumnsPlaceholder"),
-      className: "h-full",
-      initialCollapsedItems: I,
+      className: "flex-1 min-h-0",
+      initialCollapsedItems: x,
       onCollapseChange: (e) => {
         b.current = e, S(e);
       }
     },
     `data-table-column-list-${g}`
-  ) }) : /* @__PURE__ */ l("div", { className: "p-4 text-[13px] text-content-placeholder", children: r("dataTable.loadingColumns") });
+  ) }) : /* @__PURE__ */ n("div", { className: "p-4 text-[13px] text-content-placeholder", children: r("dataTable.loadingColumns") });
 };
 export {
-  le as DataTableColumnList
+  ne as DataTableColumnList
 };

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

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+import { Tabs, TabsContent, TabsList } from '../../primitives/tabs/tabs';
+/** Flex body below `DataTableSheetHeader` — establishes the sheet scroll height chain. */
+export declare const DataTableSheetBody: ({ children, className, }: {
+    children: React.ReactNode;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+/** Non-scrolling chrome row (saved views, filters summary, etc.). */
+export declare const DataTableSheetSection: ({ children, className, }: {
+    children: React.ReactNode;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export type DataTableSheetTabsProps = React.ComponentPropsWithoutRef<typeof Tabs>;
+/** Tabs root with flex + overflow defaults for sheet settings panels. */
+export declare const DataTableSheetTabs: ({ className, ...rest }: DataTableSheetTabsProps) => import("react/jsx-runtime").JSX.Element;
+export type DataTableSheetTabsListProps = React.ComponentPropsWithoutRef<typeof TabsList>;
+export declare const DataTableSheetTabsList: ({ className, ...rest }: DataTableSheetTabsListProps) => import("react/jsx-runtime").JSX.Element;
+export type DataTableSheetTabPanelLayout = "list" | "scroll";
+export type DataTableSheetTabPanelProps = React.ComponentPropsWithoutRef<typeof TabsContent> & {
+    /**
+     * `list` — NestedList / column tree scrolls internally; search stays fixed.
+     * `scroll` — panel body scrolls (format options, filter forms).
+     */
+    layout?: DataTableSheetTabPanelLayout;
+};
+export declare const DataTableSheetTabPanel: ({ layout, className, children, ...rest }: DataTableSheetTabPanelProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,71 @@
+import { jsx as l } from "react/jsx-runtime";
+import "react";
+import { TabsContent as i, Tabs as T, TabsList as c } from "../../primitives/tabs/tabs.js";
+import { cn as t } from "../../../lib/utils.js";
+const r = ({
+  children: a,
+  className: e
+}) => /* @__PURE__ */ l(
+  "div",
+  {
+    "data-slot": "data-table-sheet-body",
+    className: t("flex flex-col flex-1 min-h-0 overflow-hidden", e),
+    children: a
+  }
+), _ = ({
+  children: a,
+  className: e
+}) => /* @__PURE__ */ l(
+  "div",
+  {
+    "data-slot": "data-table-sheet-section",
+    className: t("shrink-0", e),
+    children: a
+  }
+), x = ({
+  className: a,
+  ...e
+}) => /* @__PURE__ */ l(
+  T,
+  {
+    "data-slot": "data-table-sheet-tabs",
+    className: t(
+      "flex flex-1 min-h-0 w-full flex-col overflow-hidden",
+      a
+    ),
+    ...e
+  }
+), E = ({
+  className: a,
+  ...e
+}) => /* @__PURE__ */ l(c, { className: t("shrink-0", a), ...e }), o = "mt-0 flex-1 min-h-0 data-[state=inactive]:hidden", d = t(
+  o,
+  "flex flex-col overflow-hidden"
+), f = t(
+  o,
+  "overflow-y-auto"
+), S = ({
+  layout: a = "scroll",
+  className: e,
+  children: s,
+  ...n
+}) => /* @__PURE__ */ l(
+  i,
+  {
+    "data-slot": "data-table-sheet-tab-panel",
+    "data-layout": a,
+    className: t(
+      a === "list" ? d : f,
+      e
+    ),
+    ...n,
+    children: a === "list" ? /* @__PURE__ */ l("div", { className: "flex flex-1 min-h-0 flex-col", children: s }) : s
+  }
+);
+export {
+  r as DataTableSheetBody,
+  _ as DataTableSheetSection,
+  S as DataTableSheetTabPanel,
+  x as DataTableSheetTabs,
+  E as DataTableSheetTabsList
+};

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

@@ -1,6 +1,8 @@
 import { default as React } from 'react';
 import { DataTableSheetProps } from './data-table.types';
 export type { DataTableSheetProps } from './data-table.types';
+export { DataTableSheetBody, DataTableSheetSection, DataTableSheetTabs, DataTableSheetTabsList, DataTableSheetTabPanel, } from './data-table-sheet-layout';
+export type { DataTableSheetTabsProps, DataTableSheetTabsListProps, DataTableSheetTabPanelProps, DataTableSheetTabPanelLayout, } from './data-table-sheet-layout';
 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;

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

@@ -4,6 +4,7 @@ export * from './data-table-column-list';
 export * from './data-table-context';
 export * from './data-table-format-options';
 export * from './data-table-sheet';
+export * from './data-table-sheet-layout';
 export { useDataTableSheet, useDataTableSheetApi } from './data-table-sheet-context';
 export * from './data-table-view-menu';
 export * from './data-table-saved-views';

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

@@ -1,42 +1,48 @@
-import { DataTable as t, DataTableContent as o, DataTableToolbar as r } from "./data-table.js";
-import { DATA_TABLE_SCOPED_SHEET_HOST_MIN_HEIGHT_PX as D, DATA_TABLE_SHEET_SLIDE_TRANSITION_MS as l, TABLE_VIEWPORT_SHELL_EXPANDED_CLASS as S } from "./data-table-constants.js";
+import { DataTable as t, DataTableContent as o, DataTableToolbar as T } from "./data-table.js";
+import { DATA_TABLE_SCOPED_SHEET_HOST_MIN_HEIGHT_PX as l, DATA_TABLE_SHEET_SLIDE_TRANSITION_MS as D, TABLE_VIEWPORT_SHELL_EXPANDED_CLASS as b } from "./data-table-constants.js";
 import { DataTableColumnList as n } from "./data-table-column-list.js";
-import { DataTableContext as m, DataTableSheetPortalStoreContext as p, useDataTable as _, useDataTableSheetPortal as x, useDataTableSheetPortalStore as E } from "./data-table-context.js";
-import { DataTableFormatOptions as u } from "./data-table-format-options.js";
-import { DataTableSheet as h, DataTableSheetContent as s, DataTableSheetHeader as C, DataTableSheetTrigger as I } from "./data-table-sheet.js";
-import { useDataTableSheet as w, useDataTableSheetApi as P } from "./data-table-sheet-context.js";
-import { DataTableViewMenuContent as H, DataTableViewMenuDensity as M, DataTableViewMenuSettingsItem as d, DataTableViewMenuTrigger as g, DataTableViewMenuViewportExpand as O } from "./data-table-view-menu.js";
-import { DataTableSavedViews as c } from "./data-table-saved-views.js";
-import { PinSwitch as R } from "./pin-switch.js";
-import { ColumnIndicator as v } from "./column-indicator.js";
-import { IndicatorLegend as F } from "./indicator-legend.js";
+import { DataTableContext as m, DataTableSheetPortalStoreContext as p, useDataTable as x, useDataTableSheetPortal as _, useDataTableSheetPortalStore as h } from "./data-table-context.js";
+import { DataTableFormatOptions as f } from "./data-table-format-options.js";
+import { DataTableSheet as u, DataTableSheetContent as A, DataTableSheetHeader as L, DataTableSheetTrigger as C } from "./data-table-sheet.js";
+import { DataTableSheetBody as P, DataTableSheetSection as w, DataTableSheetTabPanel as V, DataTableSheetTabs as d, DataTableSheetTabsList as H } from "./data-table-sheet-layout.js";
+import { useDataTableSheet as g, useDataTableSheetApi as O } from "./data-table-sheet-context.js";
+import { DataTableViewMenuContent as B, DataTableViewMenuDensity as N, DataTableViewMenuSettingsItem as y, DataTableViewMenuTrigger as R, DataTableViewMenuViewportExpand as X } from "./data-table-view-menu.js";
+import { DataTableSavedViews as F } from "./data-table-saved-views.js";
+import { PinSwitch as W } from "./pin-switch.js";
+import { ColumnIndicator as k } from "./column-indicator.js";
+import { IndicatorLegend as z } from "./indicator-legend.js";
 export {
-  v as ColumnIndicator,
-  D as DATA_TABLE_SCOPED_SHEET_HOST_MIN_HEIGHT_PX,
-  l as DATA_TABLE_SHEET_SLIDE_TRANSITION_MS,
+  k as ColumnIndicator,
+  l as DATA_TABLE_SCOPED_SHEET_HOST_MIN_HEIGHT_PX,
+  D as DATA_TABLE_SHEET_SLIDE_TRANSITION_MS,
   t as DataTable,
   n as DataTableColumnList,
   o as DataTableContent,
   m as DataTableContext,
-  u as DataTableFormatOptions,
-  c as DataTableSavedViews,
-  h as DataTableSheet,
-  s as DataTableSheetContent,
-  C as DataTableSheetHeader,
+  f as DataTableFormatOptions,
+  F as DataTableSavedViews,
+  u as DataTableSheet,
+  P as DataTableSheetBody,
+  A as DataTableSheetContent,
+  L as DataTableSheetHeader,
   p as DataTableSheetPortalStoreContext,
-  I as DataTableSheetTrigger,
-  r as DataTableToolbar,
-  H as DataTableViewMenuContent,
-  M as DataTableViewMenuDensity,
-  d as DataTableViewMenuSettingsItem,
-  g as DataTableViewMenuTrigger,
-  O as DataTableViewMenuViewportExpand,
-  F as IndicatorLegend,
-  R as PinSwitch,
-  S as TABLE_VIEWPORT_SHELL_EXPANDED_CLASS,
-  _ as useDataTable,
-  w as useDataTableSheet,
-  P as useDataTableSheetApi,
-  x as useDataTableSheetPortal,
-  E as useDataTableSheetPortalStore
+  w as DataTableSheetSection,
+  V as DataTableSheetTabPanel,
+  d as DataTableSheetTabs,
+  H as DataTableSheetTabsList,
+  C as DataTableSheetTrigger,
+  T as DataTableToolbar,
+  B as DataTableViewMenuContent,
+  N as DataTableViewMenuDensity,
+  y as DataTableViewMenuSettingsItem,
+  R as DataTableViewMenuTrigger,
+  X as DataTableViewMenuViewportExpand,
+  z as IndicatorLegend,
+  W as PinSwitch,
+  b as TABLE_VIEWPORT_SHELL_EXPANDED_CLASS,
+  x as useDataTable,
+  g as useDataTableSheet,
+  O as useDataTableSheetApi,
+  _ as useDataTableSheetPortal,
+  h as useDataTableSheetPortalStore
 };

package/dist/components/data/nested-list/hooks/useNestedListHandlers.d.ts

@@ -15,6 +15,7 @@ declare function updateParentsNormalized(normalized: NormalizedItems, updates: M
 declare function applyUpdatesToTree(items: NestedListItem[], updates: Map<string, Partial<NestedListItem>>): NestedListItem[];
 interface UseNestedListHandlersProps {
     setItems: React.Dispatch<React.SetStateAction<NestedListItem[]>>;
+    itemsRef: React.RefObject<NestedListItem[]>;
     findItemById: (items: NestedListItem[], id: string) => NestedListItem | null;
     updateParentsUpward: (items: NestedListItem[], targetItemId: string) => NestedListItem[];
     onChange: (items: NestedListItem[]) => void;
@@ -27,13 +28,13 @@ interface UseNestedListHandlersProps {
     setCollapsedItems: React.Dispatch<React.SetStateAction<Record<string, boolean>>>;
     setIsListCollapsed: React.Dispatch<React.SetStateAction<boolean>>;
     setSelectedCategories: React.Dispatch<React.SetStateAction<Set<string>>>;
-    isUserChangeRef: React.MutableRefObject<boolean>;
+    markUserChange: () => void;
     selectionMode: SelectionMode;
     isNormalized?: boolean;
     normalizedState?: NormalizedItems;
     batchUpdateItems?: (updates: Map<string, Partial<NestedListItem>>) => void;
 }
-export declare const useNestedListHandlers: ({ setItems, findItemById, updateParentsUpward, onChange, onItemToggle, getCategory, setCollapsedItems, setIsListCollapsed, setSelectedCategories, isUserChangeRef, selectionMode, isNormalized, normalizedState, batchUpdateItems, }: UseNestedListHandlersProps) => {
+export declare const useNestedListHandlers: ({ setItems, itemsRef, findItemById, updateParentsUpward, onChange, onItemToggle, getCategory, setCollapsedItems, setIsListCollapsed, setSelectedCategories, markUserChange, selectionMode, isNormalized, normalizedState, batchUpdateItems, }: UseNestedListHandlersProps) => {
     handleToggle: (itemId: string) => void;
     handleToggleCollapse: (itemId: string) => void;
     handleCollapseAll: () => void;

package/dist/components/data/nested-list/hooks/useNestedListHandlers.js

@@ -1,185 +1,184 @@
 import { useCallback as _ } from "react";
-import { SelectionMode as D } from "../nested-list.types.js";
-const v = (l, t, r) => l.map((n) => n.id === t ? r(n) : n.children ? {
-  ...n,
-  children: v(n.children, t, r)
-} : n), q = (l, t, r, n) => {
-  const s = (c, e) => c.map((h) => ({
+import { SelectionMode as a } from "../nested-list.types.js";
+const x = (l, s, r) => l.map((c) => c.id === s ? r(c) : c.children ? {
+  ...c,
+  children: x(c.children, s, r)
+} : c), G = (l, s, r, c) => {
+  const t = (e, n) => e.map((h) => ({
     ...h,
-    checked: e,
-    children: h.children ? s(h.children, e) : void 0
+    checked: n,
+    children: h.children ? t(h.children, n) : void 0
   }));
-  return v(l, t, (c) => {
-    const e = { ...c, checked: r };
-    return c.children && (n === D.INDEPENDENT ? e.children = [...c.children] : n === D.CASCADE_DOWN ? e.children = s(c.children, r) : n === D.CASCADE_UP_DOWN && (r ? e.children = [...c.children] : e.children = s(c.children, !1))), e;
+  return x(l, s, (e) => {
+    const n = { ...e, checked: r };
+    return e.children && (c === a.INDEPENDENT ? n.children = [...e.children] : c === a.CASCADE_DOWN ? n.children = t(e.children, r) : c === a.CASCADE_UP_DOWN && (r ? n.children = [...e.children] : n.children = t(e.children, !1))), n;
   });
 };
-function G(l, t, r, n) {
-  const s = /* @__PURE__ */ new Map();
-  s.set(t, { checked: r });
-  const c = (e) => {
+function J(l, s, r, c) {
+  const t = /* @__PURE__ */ new Map();
+  t.set(s, { checked: r });
+  const e = (n) => {
     const h = [];
-    return (l.childrenById.get(e) || []).forEach((i) => {
-      h.push(i), h.push(...c(i));
+    return (l.childrenById.get(n) || []).forEach((p) => {
+      h.push(p), h.push(...e(p));
     }), h;
   };
-  return n === D.CASCADE_DOWN ? c(t).forEach((h) => {
-    s.set(h, { checked: r });
-  }) : n === D.CASCADE_UP_DOWN && !r && c(t).forEach((h) => {
-    s.set(h, { checked: !1 });
-  }), s;
+  return c === a.CASCADE_DOWN ? e(s).forEach((h) => {
+    t.set(h, { checked: r });
+  }) : c === a.CASCADE_UP_DOWN && !r && e(s).forEach((h) => {
+    t.set(h, { checked: !1 });
+  }), t;
 }
-function J(l, t, r, n) {
-  if (n === D.INDEPENDENT) return;
-  ((e) => {
+function K(l, s, r, c) {
+  if (c === a.INDEPENDENT) return;
+  ((n) => {
     const h = [];
-    let f = l.parentById.get(e) || null;
-    for (; f !== null; )
-      h.push(f), f = l.parentById.get(f) || null;
+    let o = l.parentById.get(n) || null;
+    for (; o !== null; )
+      h.push(o), o = l.parentById.get(o) || null;
     return h;
-  })(r).forEach((e) => {
-    const f = (l.childrenById.get(e) || []).map((o) => {
-      const y = t.get(o);
-      return y?.checked !== void 0 ? y.checked : l.byId.get(o)?.checked ?? !1;
+  })(r).forEach((n) => {
+    const o = (l.childrenById.get(n) || []).map((f) => {
+      const E = s.get(f);
+      return E?.checked !== void 0 ? E.checked : l.byId.get(f)?.checked ?? !1;
     });
-    let i;
-    n === D.CASCADE_UP_DOWN ? i = f.some((o) => o) : i = f.every((o) => o), t.set(e, { checked: i });
+    let p;
+    c === a.CASCADE_UP_DOWN ? p = o.some((f) => f) : p = o.every((f) => f), s.set(n, { checked: p });
   });
 }
-function B(l, t) {
+function B(l, s) {
   return l.map((r) => {
-    const n = t.get(r.id), s = n ? { ...r, ...n } : r;
+    const c = s.get(r.id), t = c ? { ...r, ...c } : r;
     return r.children ? {
-      ...s,
-      children: B(r.children, t)
-    } : s;
+      ...t,
+      children: B(r.children, s)
+    } : t;
   });
 }
-const Q = ({
+const V = ({
   setItems: l,
-  findItemById: t,
-  updateParentsUpward: r,
-  onChange: n,
-  onItemToggle: s,
-  getCategory: c,
-  setCollapsedItems: e,
-  setIsListCollapsed: h,
-  setSelectedCategories: f,
-  isUserChangeRef: i,
-  selectionMode: o,
+  itemsRef: s,
+  findItemById: r,
+  updateParentsUpward: c,
+  onChange: t,
+  onItemToggle: e,
+  getCategory: n,
+  setCollapsedItems: h,
+  setIsListCollapsed: o,
+  setSelectedCategories: p,
+  markUserChange: f,
+  selectionMode: E,
   // Normalized state helpers
-  isNormalized: y = !1,
-  normalizedState: E,
-  batchUpdateItems: P
+  isNormalized: T = !1,
+  normalizedState: D,
+  batchUpdateItems: y
 }) => {
-  const W = _(
+  const v = _(
     (d) => {
-      if (!E || !P) return;
-      i.current = !0;
-      const p = E.byId.get(d);
-      if (!p) return;
-      const u = !p.checked, a = G(
-        E,
+      if (!D || !y) return;
+      f();
+      const i = D.byId.get(d);
+      if (!i) return;
+      const u = !i.checked, N = J(
+        D,
         d,
         u,
-        o
+        E
       );
-      J(E, a, d, o), P(a), l((T) => {
-        const w = B(T, a);
-        if (n(w), s) {
-          const k = [];
-          a.forEach((N, A) => {
-            if (N.checked !== void 0) {
-              const C = E.byId.get(A), O = C ? c ? c(C) : C.category : void 0;
-              k.push({ itemId: A, checked: N.checked, category: O });
-            }
-          }), s(k);
-        }
-        return w;
-      });
+      K(D, N, d, E), y(N);
+      const O = B(s.current, N);
+      if (l(O), t(O), e) {
+        const g = [];
+        N.forEach((C, k) => {
+          if (C.checked !== void 0) {
+            const A = D.byId.get(k), P = A ? n ? n(A) : A.category : void 0;
+            g.push({ itemId: k, checked: C.checked, category: P });
+          }
+        }), e(g);
+      }
     },
     [
+      D,
+      y,
+      f,
+      s,
       E,
-      P,
-      i,
-      o,
       l,
-      n,
-      s,
-      c
+      t,
+      e,
+      n
     ]
-  ), g = _(
+  ), W = _(
     (d) => {
-      i.current = !0, l((p) => {
-        const u = t(p, d), a = u ? !u.checked : !1, T = q(
-          p,
-          d,
-          a,
-          o
-        ), w = r(T, d);
-        if (n(w), s && u) {
-          const k = [];
-          if (o === D.INDEPENDENT) {
-            const N = c ? c(u) : u.category;
-            k.push({ itemId: u.id, checked: a, category: N });
-          } else {
-            const N = (A, C, O) => {
-              const b = c ? c(A) : A.category;
-              O.push({ itemId: A.id, checked: C, category: b }), A.children && A.children.forEach((j) => {
-                N(j, C, O);
-              });
-            };
-            N(u, a, k);
-          }
-          s(k);
+      f();
+      const i = s.current, u = r(i, d), N = u ? !u.checked : !1, O = G(
+        i,
+        d,
+        N,
+        E
+      ), g = c(O, d);
+      if (l(g), t(g), e && u) {
+        const C = [];
+        if (E === a.INDEPENDENT) {
+          const k = n ? n(u) : u.category;
+          C.push({ itemId: u.id, checked: N, category: k });
+        } else {
+          const k = (A, P, w) => {
+            const j = n ? n(A) : A.category;
+            w.push({ itemId: A.id, checked: P, category: j }), A.children && A.children.forEach((q) => {
+              k(q, P, w);
+            });
+          };
+          k(u, N, C);
         }
-        return w;
-      });
+        e(C);
+      }
     },
     [
+      r,
       t,
+      e,
+      c,
       n,
+      f,
       s,
-      r,
-      c,
-      i,
       l,
-      o
+      E
     ]
-  ), x = _(
+  ), F = _(
     (d) => {
-      y && E && P ? W(d) : g(d);
+      T && D && y ? v(d) : W(d);
     },
-    [y, E, P, W, g]
-  ), F = _(
+    [T, D, y, v, W]
+  ), H = _(
     (d) => {
-      e((p) => ({
-        ...p,
-        [d]: !p[d]
+      h((i) => ({
+        ...i,
+        [d]: !i[d]
       }));
     },
-    [e]
-  ), H = _(() => {
-    h((d) => !d);
-  }, [h]), S = _(
+    [h]
+  ), S = _(() => {
+    o((d) => !d);
+  }, [o]), b = _(
     (d) => {
-      f((p) => {
-        const u = new Set(p);
+      p((i) => {
+        const u = new Set(i);
         return u.has(d) ? u.delete(d) : u.add(d), u;
       });
     },
-    [f]
+    [p]
   );
   return {
-    handleToggle: x,
-    handleToggleCollapse: F,
-    handleCollapseAll: H,
-    handleToggleCategory: S
+    handleToggle: F,
+    handleToggleCollapse: H,
+    handleCollapseAll: S,
+    handleToggleCategory: b
   };
 };
 export {
   B as applyUpdatesToTree,
-  G as toggleItemAndChildrenNormalized,
-  J as updateParentsNormalized,
-  Q as useNestedListHandlers
+  J as toggleItemAndChildrenNormalized,
+  K as updateParentsNormalized,
+  V as useNestedListHandlers
 };

package/dist/components/data/nested-list/hooks/useNestedListState.d.ts

@@ -51,11 +51,10 @@ export declare const useNestedListState: ({ initialItems, enableApplyDiscard, en
     setSavedNormalizedState: import('react').Dispatch<import('react').SetStateAction<NormalizedItems>>;
     items: NestedListItem[];
     setItems: import('react').Dispatch<import('react').SetStateAction<NestedListItem[]>>;
+    itemsRef: import('react').RefObject<NestedListItem[]>;
     savedItems: NestedListItem[];
     setSavedItems: import('react').Dispatch<import('react').SetStateAction<NestedListItem[]>>;
-    isUserChangeRef: {
-        current: boolean;
-    };
+    markUserChange: () => void;
     searchText: string;
     setSearchText: import('react').Dispatch<import('react').SetStateAction<string>>;
     collapsedItems: Record<string, boolean>;