impact-nova 2.5.11 → 2.5.13

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

@@ -0,0 +1,128 @@
+import { useState as B, useRef as d, useEffect as w, useCallback as a } from "react";
+import { resolveVirtualDropTarget as M, clampPointerToScrollBounds as F } from "../nested-list-virtual-drop.js";
+function V({
+  items: S,
+  scrollElementRef: s,
+  virtualizer: L,
+  estimateRowSize: y,
+  onDrop: h,
+  collapsedItems: D = {}
+}) {
+  const [v, C] = B(null), f = d(null), p = d(S), x = d(L), X = d(y), b = d(D), c = d(null), g = d(null), E = d(null);
+  w(() => {
+    p.current = S;
+  }), w(() => {
+    x.current = L;
+  }), w(() => {
+    X.current = y;
+  }), w(() => {
+    b.current = D;
+  });
+  const I = a((e, r) => {
+    const n = s.current;
+    return n ? M({
+      clientX: e,
+      clientY: r,
+      scrollElement: n,
+      items: p.current,
+      virtualizer: x.current,
+      estimateRowSize: X.current,
+      offsetCacheHolder: E,
+      collapsedItems: b.current
+    }) : null;
+  }, [s]), m = a(() => {
+    f.current = null, C(null), g.current = null, c.current !== null && (cancelAnimationFrame(c.current), c.current = null);
+  }, []), R = a(() => {
+    const e = f.current;
+    e?.dropTarget && e.draggedId !== e.dropTarget.overId && h(e.draggedId, e.dropTarget.overId, e.dropTarget.insertAfter);
+  }, [h]), P = a((e, r) => {
+    const n = f.current;
+    if (!n)
+      return;
+    const t = s.current, o = t?.getBoundingClientRect(), i = o ? F(e, r, o) : {
+      pointerX: e,
+      pointerY: r,
+      isInsideScrollContainer: !0
+    }, l = I(e, r), u = i.isInsideScrollContainer ? null : n.dropTarget, T = {
+      ...n,
+      dropTarget: l ?? u,
+      pointerX: i.pointerX,
+      pointerY: i.pointerY,
+      isPointerInsideScrollContainer: i.isInsideScrollContainer
+    };
+    f.current = T, C(T), t && o && (r < o.top + 40 ? t.scrollTop -= 8 : r > o.bottom - 40 && (t.scrollTop += 8));
+  }, [I, s]), Y = a(() => {
+    c.current !== null && (cancelAnimationFrame(c.current), c.current = null);
+    const e = g.current;
+    e && (P(e.clientX, e.clientY), g.current = null);
+  }, [P]), A = a((e, r) => {
+    g.current = { clientX: e, clientY: r }, c.current === null && (c.current = requestAnimationFrame(() => {
+      c.current = null;
+      const n = g.current;
+      n && (P(n.clientX, n.clientY), g.current = null);
+    }));
+  }, [P]), k = a((e, r) => {
+    const n = p.current.findIndex((T) => T.item.id === r), t = p.current[n]?.item;
+    if (!t || n === -1 || t.isDragDisabled || t.category === "structure")
+      return;
+    e.preventDefault(), E.current = null, s.current?.setPointerCapture(e.pointerId);
+    const o = s.current?.getBoundingClientRect(), i = o ? F(e.clientX, e.clientY, o) : {
+      pointerX: e.clientX,
+      pointerY: e.clientY,
+      isInsideScrollContainer: !0
+    }, l = I(e.clientX, e.clientY) ?? {
+      overId: r,
+      insertAfter: !1,
+      flatIndex: n
+    }, u = {
+      draggedId: r,
+      draggedItem: t,
+      dropTarget: l,
+      pointerX: i.pointerX,
+      pointerY: i.pointerY,
+      isPointerInsideScrollContainer: i.isInsideScrollContainer
+    };
+    f.current = u, C(u);
+  }, [I, s]);
+  w(() => {
+    if (!v)
+      return;
+    const e = (u) => {
+      A(u.clientX, u.clientY);
+    }, r = () => {
+      Y(), R(), m();
+    }, n = () => {
+      m();
+    }, t = () => {
+      m();
+    }, o = (u) => {
+      u.key === "Escape" && m();
+    };
+    window.addEventListener("pointermove", e), window.addEventListener("pointerup", r), window.addEventListener("pointercancel", n), window.addEventListener("keydown", o);
+    const i = s.current;
+    i?.addEventListener("lostpointercapture", t);
+    const l = document.createElement("style");
+    return l.setAttribute("data-virtual-drag-cursor", "true"), l.textContent = "body, body * { cursor: grabbing !important; }", document.head.appendChild(l), () => {
+      window.removeEventListener("pointermove", e), window.removeEventListener("pointerup", r), window.removeEventListener("pointercancel", n), window.removeEventListener("keydown", o), i?.removeEventListener("lostpointercapture", t), l.remove(), c.current !== null && (cancelAnimationFrame(c.current), c.current = null);
+    };
+  }, [v, R, m, Y, A, s]);
+  const U = a((e, r) => {
+    const n = p.current.findIndex((i) => i.item.id === e);
+    if (n === -1)
+      return;
+    const t = r === "up" ? Math.max(0, n - 1) : Math.min(p.current.length - 1, n + 1);
+    if (t === n)
+      return;
+    const o = p.current[t];
+    o && h(e, o.item.id, r === "down");
+  }, [h]);
+  return {
+    dragSession: v,
+    handlePointerDown: k,
+    handleKeyboardReorder: U,
+    isDragging: v !== null
+  };
+}
+export {
+  V as useVirtualNestedListDrag
+};

package/dist/components/data/nested-list/nested-list-constants.d.ts

@@ -1,4 +1,7 @@
 /** Flat row count at or above which NestedListContent virtualizes rows. */
 export declare const NESTED_LIST_VIRTUALIZATION_THRESHOLD = 80;
-export declare const NESTED_LIST_VIRTUAL_ROW_ESTIMATE_PX = 32;
+export declare const NESTED_LIST_VIRTUAL_ROW_ESTIMATE_PX = 28;
 export declare const NESTED_LIST_VIRTUAL_OVERSCAN = 12;
+export declare const NESTED_LIST_ROOT_FROZEN_ID = "root-frozen";
+export declare const NESTED_LIST_ROOT_SCROLLABLE_ID = "root-scrollable";
+export declare const NESTED_LIST_SECTION_IDS: Set<string>;

package/dist/components/data/nested-list/nested-list-constants.js

@@ -1,6 +1,12 @@
-const T = 80, _ = 32, E = 12;
+const E = 80, S = 28, I = 12, T = "root-frozen", _ = "root-scrollable", o = /* @__PURE__ */ new Set([
+  T,
+  _
+]);
 export {
-  T as NESTED_LIST_VIRTUALIZATION_THRESHOLD,
-  E as NESTED_LIST_VIRTUAL_OVERSCAN,
-  _ as NESTED_LIST_VIRTUAL_ROW_ESTIMATE_PX
+  T as NESTED_LIST_ROOT_FROZEN_ID,
+  _ as NESTED_LIST_ROOT_SCROLLABLE_ID,
+  o as NESTED_LIST_SECTION_IDS,
+  E as NESTED_LIST_VIRTUALIZATION_THRESHOLD,
+  I as NESTED_LIST_VIRTUAL_OVERSCAN,
+  S as NESTED_LIST_VIRTUAL_ROW_ESTIMATE_PX
 };

package/dist/components/data/nested-list/nested-list-display-utils.d.ts

@@ -0,0 +1,11 @@
+import { NestedListItem } from './nested-list.types';
+export declare function filterNestedListItemsBySearch(items: NestedListItem[], searchText: string): NestedListItem[];
+export declare function updateNestedListParentCheckedState(items: NestedListItem[]): NestedListItem[];
+export declare function extractNestedListCategories(items: NestedListItem[], getCategory?: (item: NestedListItem) => string | undefined): string[];
+export declare function filterNestedListItemsByCategories(items: NestedListItem[], selectedCategories: Set<string>, getCategory?: (item: NestedListItem) => string | undefined): NestedListItem[];
+export type FlattenedNestedListRow = {
+    item: NestedListItem;
+    level: number;
+    indentLevel: number;
+};
+export declare function flattenNestedListTree(items: NestedListItem[], collapsedItems: Record<string, boolean>, activeId: string | null, level?: number, indentLevel?: number): FlattenedNestedListRow[];

package/dist/components/data/nested-list/nested-list-display-utils.js

@@ -0,0 +1,74 @@
+function l(o, r) {
+  if (!r || typeof r != "string")
+    return o;
+  const c = r.toLowerCase(), t = [];
+  return o.forEach((n) => {
+    const s = n.label.toLowerCase().includes(c), e = n.children ? l(n.children, r) : void 0;
+    (s || e && e.length > 0) && t.push({
+      ...n,
+      children: e || n.children
+    });
+  }), t;
+}
+function i(o) {
+  return o.map((r) => {
+    if (r.children && r.children.length > 0) {
+      const c = i(r.children), t = c.every((n) => n.checked);
+      return {
+        ...r,
+        checked: t,
+        children: c
+      };
+    }
+    return r;
+  });
+}
+function f(o, r) {
+  const c = /* @__PURE__ */ new Set(), t = (n) => {
+    n.forEach((s) => {
+      const e = r ? r(s) : s.category;
+      e && c.add(e), s.children && t(s.children);
+    });
+  };
+  return t(o), Array.from(c).sort();
+}
+function u(o, r, c) {
+  if (r.size === 0)
+    return o;
+  const t = [];
+  return o.forEach((n) => {
+    const s = c ? c(n) : n.category, e = s && r.has(s), d = n.children ? u(n.children, r, c) : void 0;
+    (e || d && d.length > 0) && t.push({
+      ...n,
+      children: d
+    });
+  }), t;
+}
+function a(o, r, c, t = 0, n = 0) {
+  const s = [];
+  return o.forEach((e) => {
+    if (s.push({
+      item: e,
+      level: t,
+      indentLevel: e.category === "structure" ? 0 : n
+    }), !r[e.id] && e.children && e.children.length > 0 && e.id !== c) {
+      const h = e.category === "structure" ? 0 : n + 1;
+      s.push(
+        ...a(
+          e.children,
+          r,
+          c,
+          t + 1,
+          h
+        )
+      );
+    }
+  }), s;
+}
+export {
+  f as extractNestedListCategories,
+  u as filterNestedListItemsByCategories,
+  l as filterNestedListItemsBySearch,
+  a as flattenNestedListTree,
+  i as updateNestedListParentCheckedState
+};

package/dist/components/data/nested-list/nested-list-drop-engine.d.ts

@@ -0,0 +1,31 @@
+import { DragEndEvent } from '@dnd-kit/core';
+import { NestedListItem } from './nested-list.types';
+export { NESTED_LIST_SECTION_IDS } from './nested-list-constants';
+export declare function getSectionIdFromDroppable(droppableId: string): string | null;
+export declare function findNestedListItemById(items: NestedListItem[], id: string): NestedListItem | undefined;
+export declare function findNestedListItemLevel(items: NestedListItem[], itemId: string, currentLevel?: number): number | null;
+export declare function findNestedListParentId(items: NestedListItem[], itemId: string, parentId?: string | null): string | null;
+export interface ApplyNestedListDropOptions {
+    activeId: string;
+    overId: string;
+    insertAfter: boolean;
+    collapsedItems?: Record<string, boolean>;
+    canDrag?: (item: NestedListItem, level: number) => boolean;
+    isValidDropTarget?: (options: {
+        activeItemId: string;
+        overItemId: string;
+        items: NestedListItem[];
+        insertAfter?: boolean;
+    }) => boolean;
+}
+export declare function applyNestedListDrop(prevItems: NestedListItem[], options: ApplyNestedListDropOptions): NestedListItem[];
+export declare function applyNestedListDragEndEvent(prevItems: NestedListItem[], event: DragEndEvent, options?: {
+    collapsedItems?: Record<string, boolean>;
+    canDrag?: (item: NestedListItem, level: number) => boolean;
+    isValidDropTarget?: (options: {
+        activeItemId: string;
+        overItemId: string;
+        items: NestedListItem[];
+        insertAfter?: boolean;
+    }) => boolean;
+}): NestedListItem[];

package/dist/components/data/nested-list/nested-list-drop-engine.js

@@ -0,0 +1,209 @@
+import { arrayMove as C } from "@dnd-kit/sortable";
+import { NESTED_LIST_SECTION_IDS as O } from "./nested-list-constants.js";
+const N = "droppable-";
+function A(n) {
+  if (n.startsWith(N)) {
+    const c = n.slice(N.length);
+    if (O.has(c)) return c;
+  }
+  return null;
+}
+function D(n, c) {
+  for (const e of n) {
+    if (e.id === c) return e;
+    if (e.children) {
+      const r = D(e.children, c);
+      if (r) return r;
+    }
+  }
+}
+function P(n, c, e = 0) {
+  for (const r of n) {
+    if (r.id === c) return e;
+    if (r.children) {
+      const t = P(r.children, c, e + 1);
+      if (t !== null) return t;
+    }
+  }
+  return null;
+}
+function I(n, c, e = null) {
+  for (const r of n) {
+    if (r.id === c) return e;
+    if (r.children) {
+      const t = I(r.children, c, r.id);
+      if (t !== null) return t;
+    }
+  }
+  return null;
+}
+function R(n, c) {
+  for (const e of n) {
+    if (e.id === c) return null;
+    if (e.children && D(e.children, c))
+      return e.id;
+  }
+  return null;
+}
+function _(n, c, e) {
+  return n.map((r) => {
+    if (r.children && r.children.length > 0) {
+      const t = r.children.findIndex((i) => i.id === c), l = r.children.findIndex((i) => i.id === e);
+      return t !== -1 && l !== -1 ? {
+        ...r,
+        children: C(r.children, t, l)
+      } : {
+        ...r,
+        children: _(r.children, c, e)
+      };
+    }
+    return r;
+  });
+}
+function v(n, c, e, r) {
+  return n.map((t) => {
+    if (t.children && t.children.length > 0) {
+      const l = t.children.findIndex((d) => d.id === c), i = t.children.findIndex((d) => d.id === e);
+      if (l !== -1 && i !== -1) {
+        let d = i;
+        return r ? d = l < i ? i : i + 1 : d = l < i ? i - 1 : i, d = Math.max(0, Math.min(d, t.children.length - 1)), {
+          ...t,
+          children: C(t.children, l, d)
+        };
+      }
+      return {
+        ...t,
+        children: v(
+          t.children,
+          c,
+          e,
+          r
+        )
+      };
+    }
+    return t;
+  });
+}
+function G(n, c, e) {
+  const r = I(n, e);
+  if (!r) return null;
+  const t = n.findIndex((i) => i.id === r), l = n.findIndex((i) => i.id === c);
+  return t !== -1 && l !== -1 ? C(n, l, t) : null;
+}
+function V(n, c, e) {
+  const r = n.findIndex((l) => l.id === c), t = n.findIndex((l) => l.id === e);
+  return r !== -1 && t !== -1 ? C(n, r, t) : null;
+}
+function y(n, c, e, r, t) {
+  const l = D(n, c);
+  if (!l) return null;
+  const i = (u) => u.filter((o) => o.id !== c).map(
+    (o) => o.children ? { ...o, children: i(o.children) } : o
+  ).filter((o) => !(o.children && o.children.length === 0 && o.category === "group")), d = D(n, e), a = !l.children || l.children.length === 0, f = !!(d?.children && d.children.length > 0), h = t[e] === !0, g = a && f && !h && r, L = (u) => {
+    for (let o = 0; o < u.length; o += 1) {
+      if (u[o].id === e) {
+        if (g) {
+          const F = {
+            ...u[o],
+            children: [l, ...u[o].children || []]
+          }, E = [...u];
+          return E[o] = F, { nodes: E, inserted: !0 };
+        }
+        const T = [...u], S = r ? o + 1 : o;
+        return T.splice(S, 0, l), { nodes: T, inserted: !0 };
+      }
+      if (u[o].children) {
+        const T = L(u[o].children);
+        if (T.inserted) {
+          const S = [...u];
+          return S[o] = { ...u[o], children: T.nodes }, { nodes: S, inserted: !0 };
+        }
+      }
+    }
+    return { nodes: u, inserted: !1 };
+  }, s = i(n), { nodes: x, inserted: B } = L(s);
+  return B ? x : null;
+}
+function M(n, c, e) {
+  const r = D(n, c);
+  if (!r) return n;
+  const t = (l) => l.filter((i) => i.id !== c).map(
+    (i) => i.children ? { ...i, children: t(i.children) } : i
+  );
+  return n.map((l) => {
+    let i = l.children ? t(l.children) : [];
+    return l.id === e && (i = [r, ...i]), { ...l, children: i };
+  });
+}
+function W(n, c) {
+  const {
+    activeId: e,
+    overId: r,
+    insertAfter: t,
+    collapsedItems: l = {},
+    canDrag: i,
+    isValidDropTarget: d
+  } = c;
+  if (!r || e === r || d && !d({
+    activeItemId: e,
+    overItemId: r,
+    items: n,
+    insertAfter: t
+  }))
+    return n;
+  if (i) {
+    const s = D(n, e), x = P(n, e);
+    if (s && x !== null && !i(s, x))
+      return n;
+  }
+  const a = A(r);
+  if (a)
+    return M(n, e, a);
+  const f = P(n, e), h = P(n, r), g = I(n, e), L = I(n, r);
+  if (O.has(r) && f !== null && f > 0)
+    return M(n, e, r);
+  if (f === 0 && h !== null && h > 0)
+    return G(n, e, r) ?? n;
+  if (f === null || h === null)
+    return n;
+  if (f > 0 && h > 0 && g !== L) {
+    const s = R(n, e), x = R(n, r);
+    return y(
+      n,
+      e,
+      r,
+      t,
+      l
+    ) ?? n;
+  }
+  return f === 0 ? V(n, e, r) ?? n : g === L ? v(n, e, r, t) : _(n, e, r);
+}
+function w(n, c, e = {}) {
+  const { active: r, over: t } = c;
+  if (!t || r.id === t.id)
+    return n;
+  const l = r.id, i = t.id, d = r.rect?.current?.translated, a = t.rect;
+  let f = !1;
+  if (d && a) {
+    const s = d.top + d.height / 2, x = a.top + a.height / 2;
+    f = s > x;
+  }
+  const h = P(n, l), g = P(n, i), L = h !== null && g !== null && h > 0 && g > 0 && !!(d && a);
+  return W(n, {
+    activeId: l,
+    overId: i,
+    insertAfter: L ? f : !1,
+    collapsedItems: e.collapsedItems,
+    canDrag: e.canDrag,
+    isValidDropTarget: e.isValidDropTarget
+  });
+}
+export {
+  O as NESTED_LIST_SECTION_IDS,
+  w as applyNestedListDragEndEvent,
+  W as applyNestedListDrop,
+  D as findNestedListItemById,
+  P as findNestedListItemLevel,
+  I as findNestedListParentId,
+  A as getSectionIdFromDroppable
+};

package/dist/components/data/nested-list/nested-list-flat-virtual-handlers.d.ts

@@ -0,0 +1,26 @@
+import { FlatVirtualRowModel, NestedListItem } from './nested-list.types';
+import { FlattenedNestedListRow } from './nested-list-display-utils';
+export declare function computeFlatVirtualHeaderSelection(flatVirtualRowModel: FlatVirtualRowModel): {
+    allChecked: boolean;
+    someChecked: boolean;
+};
+export declare function findFlatVirtualRowIndexByItemId(flatVirtualRowModel: FlatVirtualRowModel, itemId: string): number;
+export interface ResolveVirtualDropReorderOptions {
+    activeId: string;
+    overId: string;
+    insertAfter: boolean;
+    flatVirtualRowModel: FlatVirtualRowModel | null;
+    displayItems: FlattenedNestedListRow[];
+    onVirtualReorder?: (fromIndex: number, toIndex: number) => void;
+}
+export declare function resolveVirtualDropReorderIndices(options: ResolveVirtualDropReorderOptions): {
+    fromIndex: number;
+    toIndex: number;
+} | null;
+export interface FlatVirtualToggleChange {
+    itemId: string;
+    checked: boolean;
+}
+export declare function resolveFlatVirtualToggleChange(flatVirtualRowModel: FlatVirtualRowModel, sectionItems: NestedListItem[], itemId: string): FlatVirtualToggleChange | null;
+export declare function triggerFlatVirtualSelectAll(flatVirtualRowModel: FlatVirtualRowModel | null, allChecked: boolean, onFlatVirtualSelectAll?: (shouldSelectAll: boolean) => void): boolean;
+export declare function triggerFlatVirtualItemToggle(flatVirtualRowModel: FlatVirtualRowModel | null, sectionItems: NestedListItem[], itemId: string, onItemToggle?: (changes: FlatVirtualToggleChange[]) => void): boolean;

package/dist/components/data/nested-list/nested-list-flat-virtual-handlers.js

@@ -0,0 +1,67 @@
+import { NESTED_LIST_ROOT_FROZEN_ID as g, NESTED_LIST_ROOT_SCROLLABLE_ID as x } from "./nested-list-constants.js";
+function h(r) {
+  let t = !0, e = !1;
+  for (let n = 0; n < r.rowCount; n += 1) {
+    const o = r.getRowAt(n);
+    if (o.item.category !== "structure" && (o.item.checked ? e = !0 : t = !1, e && !t))
+      break;
+  }
+  return { allChecked: t && e, someChecked: e };
+}
+function I(r, t) {
+  for (let e = 0; e < r.rowCount; e += 1)
+    if (r.getRowAt(e).item.id === t)
+      return e;
+  return -1;
+}
+function w(r) {
+  const {
+    activeId: t,
+    overId: e,
+    insertAfter: n,
+    flatVirtualRowModel: o,
+    displayItems: l,
+    onVirtualReorder: a
+  } = r;
+  if (!a)
+    return null;
+  if (o) {
+    const i = I(o, t), s = I(o, e), f = n ? s + 1 : s;
+    return i !== -1 && f !== -1 && i !== f ? { fromIndex: i, toIndex: f } : null;
+  }
+  const u = l.findIndex((i) => i.item.id === t), d = l.findIndex((i) => i.item.id === e), c = n ? d + 1 : d;
+  return u !== -1 && c !== -1 && u !== c ? { fromIndex: u, toIndex: c } : null;
+}
+function m(r, t, e) {
+  if (e === g || e === x) {
+    const n = t.find((o) => o.id === e);
+    return { itemId: e, checked: !(n?.checked ?? !1) };
+  }
+  for (let n = 0; n < r.rowCount; n += 1) {
+    const o = r.getRowAt(n);
+    if (o.item.id === e)
+      return { itemId: e, checked: !o.item.checked };
+  }
+  return null;
+}
+function k(r, t, e) {
+  return !r || !e ? !1 : (e(!t), !0);
+}
+function C(r, t, e, n) {
+  if (!r)
+    return !1;
+  const o = m(
+    r,
+    t,
+    e
+  );
+  return o ? (n?.([o]), !0) : !1;
+}
+export {
+  h as computeFlatVirtualHeaderSelection,
+  I as findFlatVirtualRowIndexByItemId,
+  m as resolveFlatVirtualToggleChange,
+  w as resolveVirtualDropReorderIndices,
+  C as triggerFlatVirtualItemToggle,
+  k as triggerFlatVirtualSelectAll
+};

package/dist/components/data/nested-list/nested-list-item-tree-mutations.d.ts

@@ -0,0 +1,4 @@
+import { NestedListItem, SelectionMode } from './nested-list.types';
+export declare function findNestedListItemById(items: NestedListItem[], targetId: string): NestedListItem | null;
+export declare function collectNestedListGroupItemIds(itemsToCollect: NestedListItem[]): string[];
+export declare function updateNestedListParentsUpward(items: NestedListItem[], targetItemId: string, selectionMode: SelectionMode): NestedListItem[];

package/dist/components/data/nested-list/nested-list-item-tree-mutations.js

@@ -0,0 +1,43 @@
+import { SelectionMode as h } from "./nested-list.types.js";
+function o(c, n) {
+  for (const r of c) {
+    if (r.id === n)
+      return r;
+    if (r.children) {
+      const d = o(r.children, n);
+      if (d)
+        return d;
+    }
+  }
+  return null;
+}
+function l(c) {
+  const n = [];
+  return c.forEach((r) => {
+    r.children && r.children.length > 0 && (n.push(r.id), n.push(...l(r.children)));
+  }), n;
+}
+function a(c, n, r) {
+  if (r === h.INDEPENDENT)
+    return c;
+  const d = (u, e) => u.id === e ? !0 : u.children ? u.children.some((t) => d(t, e)) : !1, f = (u) => u.map((e) => {
+    if (e.id === n)
+      return e;
+    if (e.children && d(e, n)) {
+      const t = f(e.children);
+      let i;
+      return r === h.CASCADE_UP_DOWN ? i = t.some((s) => s.checked) : i = t.every((s) => s.checked), {
+        ...e,
+        checked: i,
+        children: t
+      };
+    }
+    return e;
+  });
+  return f(c);
+}
+export {
+  l as collectNestedListGroupItemIds,
+  o as findNestedListItemById,
+  a as updateNestedListParentsUpward
+};

package/dist/components/data/nested-list/nested-list-lazy-flat-rows.d.ts

@@ -0,0 +1,3 @@
+import { FlatNestedListRow } from './nested-list-virtual-drop';
+import { FlatVirtualRowModel } from './nested-list.types';
+export declare function createLazyFlatRowList(flatVirtualRowModel: FlatVirtualRowModel): FlatNestedListRow[];

package/dist/components/data/nested-list/nested-list-lazy-flat-rows.js

@@ -0,0 +1,34 @@
+function u(e) {
+  const s = {
+    length: e.rowCount,
+    findIndex: (o) => {
+      for (let n = 0; n < e.rowCount; n += 1) {
+        const t = e.getRowAt(n);
+        if (o(t, n, s))
+          return n;
+      }
+      return -1;
+    },
+    slice: (o = 0, n = e.rowCount) => {
+      const t = [];
+      for (let r = o; r < n; r += 1)
+        t.push(e.getRowAt(r));
+      return t;
+    }
+  };
+  return new Proxy(s, {
+    get(o, n) {
+      if (n === "length")
+        return e.rowCount;
+      if (n in o) {
+        const t = o[n];
+        return typeof t == "function" ? t.bind(o) : t;
+      }
+      if (typeof n == "string" && /^\d+$/.test(n))
+        return e.getRowAt(Number(n));
+    }
+  });
+}
+export {
+  u as createLazyFlatRowList
+};

package/dist/components/data/nested-list/nested-list-row-estimates.d.ts

@@ -0,0 +1,9 @@
+import { NestedListItem } from './nested-list.types';
+/** Empty section header + dashed drop zone (measured in column picker). */
+export declare const NESTED_LIST_EMPTY_SECTION_ROW_PX = 68;
+/** root-scrollable header only when children render as separate flat rows. */
+export declare const NESTED_LIST_SCROLLABLE_HEADER_ROW_PX = 37;
+/** root-frozen header only when children render as separate flat rows. */
+export declare const NESTED_LIST_FROZEN_HEADER_ROW_PX = 25;
+export declare function estimateNestedListRowHeight(item: NestedListItem | undefined): number;
+export declare function sumNestedListRowHeightsUpTo(items: NestedListItem[], endIndexExclusive: number): number;