impact-nova 2.5.11 → 2.5.13

package/dist/components/data/nested-list/nested-list-row-estimates.js

@@ -0,0 +1,14 @@
+import { NESTED_LIST_VIRTUAL_ROW_ESTIMATE_PX as t, NESTED_LIST_ROOT_SCROLLABLE_ID as _ } from "./nested-list-constants.js";
+const E = 68, e = 37, n = 25;
+function u(r) {
+  return r.category !== "structure" || r.data?.hasVirtualColumnChildren === !0 ? !1 : !r.children || r.children.length === 0;
+}
+function T(r) {
+  return r ? r.category === "structure" ? u(r) ? E : r.id === _ ? e : n : t : t;
+}
+export {
+  E as NESTED_LIST_EMPTY_SECTION_ROW_PX,
+  n as NESTED_LIST_FROZEN_HEADER_ROW_PX,
+  e as NESTED_LIST_SCROLLABLE_HEADER_ROW_PX,
+  T as estimateNestedListRowHeight
+};

package/dist/components/data/nested-list/nested-list-scroll-anchor.d.ts

@@ -0,0 +1,36 @@
+import { VirtualDropRowGeometry } from './nested-list-virtual-drop';
+export interface NestedListScrollAnchorCapture {
+    anchorItemId: string;
+    anchorRowIndex: number;
+    anchorTopInViewport: number;
+}
+export declare function findNestedListRowIndexByItemId(options: {
+    rowCount: number;
+    getRowAtIndex: (index: number) => {
+        item: {
+            id: string;
+        };
+    } | undefined;
+    anchorItemId: string;
+}): number;
+export declare function resolveNestedListRowOffset(options: {
+    virtualizer: VirtualDropRowGeometry;
+    rowIndex: number;
+    estimateRowSize: (index: number) => number;
+}): number;
+export declare function captureNestedListScrollAnchor(options: {
+    scrollElement: HTMLElement;
+    anchorItemId: string;
+    anchorRowIndex: number;
+    rowOffset: number;
+}): NestedListScrollAnchorCapture | null;
+export declare function computeAnchoredScrollTop(options: {
+    newRowOffset: number;
+    anchorTopInViewport: number;
+}): number;
+export declare function restoreNestedListScrollAnchor(options: {
+    scrollElement: HTMLElement;
+    capture: NestedListScrollAnchorCapture;
+    virtualizer: VirtualDropRowGeometry;
+    estimateRowSize: (index: number) => number;
+}): void;

package/dist/components/data/nested-list/nested-list-scroll-anchor.js

@@ -0,0 +1,47 @@
+function u(e) {
+  for (let r = 0; r < e.rowCount; r += 1)
+    if (e.getRowAtIndex(r)?.item.id === e.anchorItemId)
+      return r;
+  return -1;
+}
+function c(e) {
+  if (e.rowIndex <= 0)
+    return 0;
+  const r = e.virtualizer.measurementsCache[e.rowIndex]?.start;
+  if (r !== void 0)
+    return r;
+  let n = 0;
+  for (let t = 0; t < e.rowIndex; t += 1) {
+    const o = e.virtualizer.measurementsCache[t]?.size;
+    n += o && o > 0 ? o : e.estimateRowSize(t);
+  }
+  return n;
+}
+function l(e) {
+  return e.anchorRowIndex < 0 ? null : {
+    anchorItemId: e.anchorItemId,
+    anchorRowIndex: e.anchorRowIndex,
+    anchorTopInViewport: e.rowOffset - e.scrollElement.scrollTop
+  };
+}
+function a(e) {
+  return Math.max(0, e.newRowOffset - e.anchorTopInViewport);
+}
+function w(e) {
+  const r = c({
+    virtualizer: e.virtualizer,
+    rowIndex: e.capture.anchorRowIndex,
+    estimateRowSize: e.estimateRowSize
+  });
+  e.scrollElement.scrollTop = a({
+    newRowOffset: r,
+    anchorTopInViewport: e.capture.anchorTopInViewport
+  });
+}
+export {
+  l as captureNestedListScrollAnchor,
+  a as computeAnchoredScrollTop,
+  u as findNestedListRowIndexByItemId,
+  c as resolveNestedListRowOffset,
+  w as restoreNestedListScrollAnchor
+};

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

@@ -0,0 +1,59 @@
+import { NestedListItem } from './nested-list.types';
+export type FlatNestedListRow = {
+    item: NestedListItem;
+    level: number;
+    indentLevel: number;
+};
+export type VirtualDropTarget = {
+    overId: string;
+    insertAfter: boolean;
+    flatIndex: number;
+};
+export declare function resolveSectionHeaderDropTarget(items: FlatNestedListRow[], sectionId: string): {
+    overId: string;
+    insertAfter: boolean;
+} | null;
+/**
+ * Maps group-header pointer targets to commit-safe drop targets.
+ * insertAfter on a group header (gap before first child) must target the first
+ * child leaf so cross-group moves pass column-picker validation.
+ */
+export declare function resolveGroupHeaderDropTarget(items: FlatNestedListRow[], groupId: string, insertAfter: boolean, collapsedItems?: Record<string, boolean>): {
+    overId: string;
+    insertAfter: boolean;
+};
+export declare function resolveSectionDroppableFromDomHit(clientX: number, clientY: number, scrollElement: HTMLElement): string | null;
+export interface VirtualDropRowGeometry {
+    measurementsCache: Array<{
+        start: number;
+        size: number;
+    }>;
+    getTotalSize: () => number;
+}
+export interface ResolveVirtualDropTargetOptions {
+    clientX: number;
+    clientY: number;
+    scrollElement: HTMLElement;
+    items: FlatNestedListRow[];
+    virtualizer: VirtualDropRowGeometry;
+    estimateRowSize: (index: number) => number;
+    offsetCacheHolder?: {
+        current: VirtualDropRowOffsetCache | null;
+    };
+    collapsedItems?: Record<string, boolean>;
+}
+export interface VirtualDropRowOffsetCache {
+    rowCount: number;
+    measurementFingerprint: number;
+    offsets: number[];
+    sizes: number[];
+}
+export declare function resolveVirtualDropTarget(options: ResolveVirtualDropTargetOptions): VirtualDropTarget | null;
+export declare function insertGapIndexFromDropTarget(items: FlatNestedListRow[], target: Pick<VirtualDropTarget, 'overId' | 'insertAfter'>): number | null;
+export declare function getInsertGapOffsetY(insertGapIndex: number, virtualizer: VirtualDropRowGeometry, estimateRowSize: (index: number) => number, rowCount: number): number;
+export declare function isInsertGapVisibleOnMountedRows(insertGapIndex: number, mountedRowIndices: number[], rowCount: number): boolean;
+export declare function clampPointerToScrollBounds(clientX: number, clientY: number, scrollRect: DOMRect): {
+    pointerX: number;
+    pointerY: number;
+    isInsideScrollContainer: boolean;
+};

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

@@ -0,0 +1,341 @@
+import { getSectionIdFromDroppable as w } from "./nested-list-drop-engine.js";
+import { NESTED_LIST_SECTION_IDS as p } from "./nested-list-constants.js";
+function z(t, e) {
+  for (let n = e + 1; n < t.length; n += 1) {
+    const r = t[n];
+    if (p.has(r.item.id))
+      return !1;
+    if (r.item.category !== "structure")
+      return !0;
+  }
+  return !1;
+}
+function A(t, e) {
+  const n = t.findIndex((o) => o.item.id === e);
+  if (n === -1)
+    return null;
+  if (!z(t, n))
+    return { overId: `droppable-${e}`, insertAfter: !1 };
+  for (let o = n + 1; o < t.length; o += 1) {
+    const i = t[o];
+    if (p.has(i.item.id))
+      break;
+    if (i.item.category !== "structure")
+      return { overId: i.item.id, insertAfter: !1 };
+  }
+  const r = t.slice(0, n).filter(
+    (o) => !p.has(o.item.id)
+  );
+  return r.length > 0 ? {
+    overId: r[r.length - 1].item.id,
+    insertAfter: !0
+  } : null;
+}
+function M(t, e) {
+  const n = t[e].level;
+  for (let r = e + 1; r < t.length; r += 1) {
+    const o = t[r];
+    if (o.level <= n)
+      return !1;
+    if (o.item.category !== "structure")
+      return !0;
+  }
+  return !1;
+}
+function R(t, e, n, r = {}) {
+  if (!n)
+    return { overId: e, insertAfter: n };
+  if (r[e] === !0)
+    return { overId: e, insertAfter: !0 };
+  const o = t.findIndex((s) => s.item.id === e);
+  if (o === -1 || !M(t, o))
+    return { overId: e, insertAfter: n };
+  const i = t[o].level;
+  for (let s = o + 1; s < t.length; s += 1) {
+    const l = t[s];
+    if (l.level <= i)
+      break;
+    if (l.item.category !== "structure")
+      return { overId: l.item.id, insertAfter: !1 };
+  }
+  return { overId: e, insertAfter: !0 };
+}
+function y(t, e, n) {
+  const r = document.elementFromPoint(t, e);
+  if (!r || !n.contains(r))
+    return null;
+  const o = r.closest("[data-section-droppable]");
+  if (!(o instanceof HTMLElement) || !n.contains(o))
+    return null;
+  const i = o.getAttribute("data-section-droppable");
+  return !i || !p.has(i) ? null : `droppable-${i}`;
+}
+function D(t, e, n, r) {
+  if (e <= 0)
+    return 0;
+  let o = 0, i = e - 1;
+  for (; o < i; ) {
+    const s = Math.floor((o + i) / 2), l = n(s), u = Math.max(r(s), 1), f = l + u;
+    if (t < l)
+      i = s - 1;
+    else if (t >= f)
+      o = s + 1;
+    else
+      return s;
+  }
+  return Math.max(0, Math.min(o, e - 1));
+}
+function E(t, e, n, r, o, i) {
+  const s = e.querySelector(`[data-index="${r}"]`);
+  if (s instanceof HTMLElement) {
+    const c = s.getBoundingClientRect(), d = c.top + c.height / 2;
+    return t >= d;
+  }
+  const l = e.querySelector(`[data-item-id="${n}"]`);
+  if (l instanceof HTMLElement) {
+    const c = l.getBoundingClientRect(), d = c.top + c.height / 2;
+    return t >= d;
+  }
+  const f = e.getBoundingClientRect().top + o(r) - e.scrollTop, h = i(r), a = f + h / 2;
+  return t >= a;
+}
+function O(t) {
+  let e = 0;
+  for (let n = 0; n < t.measurementsCache.length; n += 1)
+    e = e * 31 + t.measurementsCache[n].size | 0;
+  return e;
+}
+function H(t, e, n, r) {
+  const o = e.measurementsCache.some(
+    (u) => u.size > 0
+  ), i = O(e), s = r?.current;
+  if (s && s.rowCount === t && s.measurementFingerprint === i)
+    return {
+      offsets: s.offsets,
+      sizes: s.sizes
+    };
+  const l = o ? L(e, t, n) : C(t, n);
+  return r && (r.current = {
+    rowCount: t,
+    measurementFingerprint: i,
+    offsets: l.offsets,
+    sizes: l.sizes
+  }), l;
+}
+function C(t, e) {
+  const n = new Array(t), r = new Array(t);
+  let o = 0;
+  for (let i = 0; i < t; i += 1) {
+    const s = e(i);
+    n[i] = o, r[i] = s, o += s;
+  }
+  return { offsets: n, sizes: r };
+}
+function L(t, e, n) {
+  const r = t.measurementsCache, o = new Array(e), i = new Array(e);
+  let s = 0;
+  for (let l = 0; l < e; l += 1) {
+    const u = r[l]?.size, f = u && u > 0 ? u : n(l);
+    o[l] = s, i[l] = f, s += f;
+  }
+  return { offsets: o, sizes: i };
+}
+function B(t) {
+  for (let e = t.length - 1; e >= 0; e -= 1) {
+    const n = t[e];
+    if (!(!n || p.has(n.item.id)) && n.item.category !== "structure")
+      return e;
+  }
+  return Math.max(0, t.length - 1);
+}
+function V(t, e, n) {
+  const r = document.elementFromPoint(t, e);
+  if (!r || !n.contains(r) || r.closest('[data-slot="drag-drop-tail"]'))
+    return null;
+  const o = r.closest("[data-index]");
+  if (!(o instanceof HTMLElement) || !n.contains(o))
+    return null;
+  const i = Number(o.getAttribute("data-index"));
+  return Number.isFinite(i) ? i : null;
+}
+function P(t, e, n, r) {
+  const o = r.getTotalSize();
+  if (o > 0)
+    return o;
+  if (t <= 0)
+    return 0;
+  const i = t - 1;
+  return e(i) + n(i);
+}
+function N(t, e, n, r) {
+  if (document.elementFromPoint(t, e)?.closest('[data-slot="drag-drop-tail"]'))
+    return !0;
+  const i = n.getBoundingClientRect();
+  return e - i.top + n.scrollTop >= r;
+}
+function v(t) {
+  const {
+    clientY: e,
+    scrollElement: n,
+    items: r,
+    flatIndex: o,
+    getRowOffset: i,
+    getRowSize: s,
+    forceInsertAfter: l = !1,
+    collapsedItems: u = {}
+  } = t, f = Math.max(0, Math.min(o, r.length - 1)), h = r[f];
+  if (!h)
+    return null;
+  let a = h.item.id, c = l || E(
+    e,
+    n,
+    a,
+    f,
+    i,
+    s
+  ), d = f;
+  if (p.has(a)) {
+    const g = A(r, a);
+    if (!g)
+      return null;
+    a = g.overId, c = g.insertAfter;
+    const I = r.findIndex((x) => x.item.id === a);
+    d = I === -1 ? f : I;
+  } else if (h.item.category === "group") {
+    const g = R(
+      r,
+      a,
+      c,
+      u
+    );
+    a = g.overId, c = g.insertAfter;
+    const I = r.findIndex((x) => x.item.id === a);
+    d = I === -1 ? f : I;
+  }
+  return {
+    overId: a,
+    insertAfter: c,
+    flatIndex: d
+  };
+}
+function _(t) {
+  const {
+    clientX: e,
+    clientY: n,
+    scrollElement: r,
+    items: o,
+    virtualizer: i,
+    estimateRowSize: s,
+    offsetCacheHolder: l,
+    collapsedItems: u = {}
+  } = t;
+  if (o.length === 0)
+    return null;
+  const f = y(
+    e,
+    n,
+    r
+  );
+  if (f) {
+    const m = w(f), S = m ? o.findIndex((b) => b.item.id === m) : -1;
+    return {
+      overId: f,
+      insertAfter: !1,
+      flatIndex: S === -1 ? 0 : S
+    };
+  }
+  const { offsets: h, sizes: a } = H(
+    o.length,
+    i,
+    s,
+    l
+  ), c = (m) => h[m] ?? 0, d = (m) => a[m] ?? s(m), g = P(
+    o.length,
+    c,
+    d,
+    i
+  );
+  if (N(e, n, r, g)) {
+    const m = B(o);
+    return v({
+      clientY: n,
+      scrollElement: r,
+      items: o,
+      flatIndex: m,
+      getRowOffset: c,
+      getRowSize: d,
+      forceInsertAfter: !0,
+      collapsedItems: u
+    });
+  }
+  const I = V(e, n, r);
+  if (I !== null)
+    return v({
+      clientY: n,
+      scrollElement: r,
+      items: o,
+      flatIndex: I,
+      getRowOffset: c,
+      getRowSize: d,
+      collapsedItems: u
+    });
+  const x = r.getBoundingClientRect(), F = n - x.top + r.scrollTop, T = D(
+    F,
+    o.length,
+    c,
+    d
+  );
+  return v({
+    clientY: n,
+    scrollElement: r,
+    items: o,
+    flatIndex: T,
+    getRowOffset: c,
+    getRowSize: d,
+    collapsedItems: u
+  });
+}
+function k(t, e) {
+  const n = w(e.overId);
+  if (n) {
+    const o = t.findIndex((i) => i.item.id === n);
+    return o === -1 ? null : e.insertAfter ? o + 1 : o;
+  }
+  const r = t.findIndex((o) => o.item.id === e.overId);
+  return r === -1 ? null : e.insertAfter ? r + 1 : r;
+}
+function q(t, e, n, r) {
+  if (t <= 0)
+    return 0;
+  if (t >= r)
+    return e.getTotalSize();
+  const o = e.measurementsCache[t]?.start;
+  if (o !== void 0)
+    return o;
+  let i = 0;
+  for (let s = 0; s < t; s += 1) {
+    const l = e.measurementsCache[s]?.size;
+    i += l && l > 0 ? l : n(s);
+  }
+  return i;
+}
+function G(t, e, n) {
+  return t < n ? e.includes(t) : t === n ? e.includes(n - 1) : !1;
+}
+function Z(t, e, n) {
+  return t >= n.left && t <= n.right && e >= n.top && e <= n.bottom ? { pointerX: t, pointerY: e, isInsideScrollContainer: !0 } : {
+    pointerX: Math.min(Math.max(t, n.left + 12), n.right - 12),
+    pointerY: Math.min(Math.max(e, n.top + 12), n.bottom - 12),
+    isInsideScrollContainer: !1
+  };
+}
+export {
+  Z as clampPointerToScrollBounds,
+  q as getInsertGapOffsetY,
+  k as insertGapIndexFromDropTarget,
+  G as isInsertGapVisibleOnMountedRows,
+  R as resolveGroupHeaderDropTarget,
+  y as resolveSectionDroppableFromDomHit,
+  A as resolveSectionHeaderDropTarget,
+  _ as resolveVirtualDropTarget
+};