@accelint/design-toolkit 8.1.2 → 9.0.0

package/dist/hooks/kanban/index.js

@@ -1,2 +1,121 @@
-import {useDroppable,useDndContext}from'@dnd-kit/core';import {useSortable}from'@dnd-kit/sortable';import {CSS}from'@dnd-kit/utilities';import {calculateClosestEdge}from'./../../components/kanban/context.js';function I(t){const{setNodeRef:a,isOver:r,active:n}=useDroppable({id:t.id,data:t}),{over:s}=useDndContext(),o=r||s?.data?.current?.columnId===t.id,i=!!(o||n&&n.data.current?.columnId!==t.id&&t.canDrop!==false),e=o&&t.canDrop!==false;return {ref:a,isHighlighted:i,isActive:e}}function K(t){const{attributes:a,listeners:r,setNodeRef:n,transform:s,transition:o,isDragging:i,over:e,active:d}=useSortable({id:t.id,data:t}),c={transform:CSS.Transform.toString(s),transition:o};let f;return e&&e.id===t.id&&d&&(f=calculateClosestEdge(e,d)),{ref:n,isDragging:i,closestEdge:f,style:c,attributes:a,listeners:r}}export{K as useCardInteractions,I as useColumnInteractions};//# sourceMappingURL=index.js.map
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+import { calculateClosestEdge } from "../../components/kanban/context.js";
+import { useDndContext, useDroppable } from "@dnd-kit/core";
+import { useSortable } from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+
+//#region src/hooks/kanban/index.ts
+/**
+* Hook that provides drag-and-drop interactions for a kanban column.
+*
+* This hook integrates with `@dnd-kit/core` to enable dropping cards into columns.
+* It tracks hover states, validates drop targets based on the column's `canDrop` property,
+* and provides visual feedback states for both the column itself and cards within it.
+*
+* @param column - The kanban column data object containing the column's id, canDrop status, and other properties
+*
+* @returns An object containing:
+* - `ref` - Ref callback to attach to the droppable column DOM element
+* - `isHighlighted` - Boolean indicating if the column should be visually highlighted (when a card from another column is being dragged)
+* - `isActive` - Boolean indicating if the column is actively being hovered over and can accept the drop
+*
+* @example
+* ```tsx
+* function KanbanColumn({ column }: { column: KanbanColumnData }) {
+*   const { ref, isHighlighted, isActive } = useColumnInteractions(column);
+*
+*   return (
+*     <div
+*       ref={ref}
+*       className={cn({
+*         'ring-2 ring-blue-300': isHighlighted && !isActive, // Potential drop target
+*         'ring-2 ring-blue-500 bg-blue-50': isActive,        // Active drop target
+*       })}
+*     >
+*       <h2>{column.title}</h2>
+*       {column.cards.map(card => <Card key={card.id} card={card} />)}
+*     </div>
+*   );
+* }
+* ```
+*/
+function useColumnInteractions(column) {
+	const { setNodeRef, isOver, active } = useDroppable({
+		id: column.id,
+		data: column
+	});
+	const { over } = useDndContext();
+	const isOverColumn = isOver || over?.data?.current?.columnId === column.id;
+	return {
+		ref: setNodeRef,
+		isHighlighted: Boolean(isOverColumn || active && active.data.current?.columnId !== column.id && column.canDrop !== false),
+		isActive: isOverColumn && column.canDrop !== false
+	};
+}
+/**
+* Hook that provides drag-and-drop interactions for a kanban card.
+*
+* This hook integrates with `@dnd-kit/sortable` to enable dragging, dropping, and reordering
+* of cards within and between columns. It handles transform animations, drag state tracking,
+* and edge detection for insertion positioning.
+*
+* @param card - The kanban card data object containing the card's id and other properties
+*
+* @returns An object containing:
+* - `ref` - Ref callback to attach to the draggable card DOM element
+* - `isDragging` - Boolean indicating if this card is currently being dragged
+* - `closestEdge` - The closest edge ('top' or 'bottom') when another card is hovering over this card, or null if not hovering
+* - `style` - CSS style object with transform and transition properties for drag animations
+* - `attributes` - Accessibility and drag attributes to spread on the card element
+* - `listeners` - Event listeners to spread on the drag handle element
+*
+* @example
+* ```tsx
+* function KanbanCard({ card }: { card: KanbanCardData }) {
+*   const { ref, isDragging, closestEdge, style, attributes, listeners } = useCardInteractions(card);
+*
+*   return (
+*     <div ref={ref} style={style} {...attributes} {...listeners}>
+*       {card.title}
+*       {closestEdge && <DropIndicator edge={closestEdge} />}
+*     </div>
+*   );
+* }
+* ```
+*/
+function useCardInteractions(card) {
+	const { attributes, listeners, setNodeRef, transform, transition, isDragging, over, active } = useSortable({
+		id: card.id,
+		data: card
+	});
+	const style = {
+		transform: CSS.Transform.toString(transform),
+		transition
+	};
+	let closestEdge;
+	if (over && over.id === card.id && active) closestEdge = calculateClosestEdge(over, active);
+	return {
+		ref: setNodeRef,
+		isDragging,
+		closestEdge,
+		style,
+		attributes,
+		listeners
+	};
+}
+
+//#endregion
+export { useCardInteractions, useColumnInteractions };
 //# sourceMappingURL=index.js.map

package/dist/hooks/kanban/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/hooks/kanban/index.ts"],"names":["useColumnInteractions","isOver","active","useDroppable","column","p","over","useDndContext","isOverColumn","isActive","useCardInteractions","listeners","transform","useSortable","card","u","style","CSS","l","closestEdge","calculateClosestEdge","C","setNodeRef"],"mappings":"gNAuDgBA,SACR,CAAE,oBAAYC,CAAAA,CAAQ,CAAA,MAAAC,CAAO,CAAA,CAAIC,MACjCC,EAAO,CAAA,CAAAC,YACX,CAAA,CAAA,EAAA,CAAMD,CACR,CAAC,EAGK,CAAE,IAAA,CAAAE,CAAK,EAAIC,CAAAA,CAAc,IAGVN,CAAAA,CAAAA,CAAUK,gBAAM,CAAA,CAAA,CAAA,CAAA,EAAM,CAAA,EAAA,IAAA,EAAS,OAAA,EAAA,QAE9B,GACpBE,CAAAA,CAAAA,EACGN,CAAAA,CACCA,EAAO,EAAA,CAAA,EAAK,CAAA,EAAA,CAAA,CAAA,IAAS,CAAA,OAAA,EAAA,QACrBE,GAAO,CAAA,CAAA,EAAA,EAAA,CAAA,CAAY,UAGQA,KAAO,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,CAAY,OAEpD,GACE,KAAA,CAAA,OACA,CAAA,GAAA,CAAA,CAAA,CAAA,aACA,CAAA,CAAAK,CACF,WAkCcC,CAAAA,SACR,CACJ,CAAA,CAAA,CAAA,CAAA,KAAA,CAAA,UACA,CAAA,CAAA,CAAAC,sBAEA,CAAA,CAAA,CAAAC,SACA,CAAA,CAAA,CAAA,UACA,CAAA,CAAA,CAAA,UAEA,OAAAV,CACF,CAAA,CAAIW,MACEC,CAAAA,CAAK,CAAA,CAAAC,WACT,CAAA,CAAA,EAAA,CAAMD,CACR,CAAC,EAEKE,CAAAA,IACJ,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAWC,SAAI,CAAAC,GAAA,CAAU,SAASN,CAAS,QAC3C,CAAA,CAAA,CAAA,CAAA,UAMF,CAAA,CAAA,CAAA,CAAA,IAAIN,CAAAA,CAAQA,OAAYQ,GAAK,CAAA,CAAA,EAAMZ,GACjCiB,CAAAA,CAAcC,EAAqBd,EAAMJ,CAAM,GAG1C,CACL,CAAAmB,oBAAA,CAAA,CAAKC,EACL,CAAA,CAAA,CAAA,CAAA,GAAA,CAAA,CAAA,CAAA,UACA,CAAA,CAAA,CAAA,WACAN,CACA,CAAA,CAAA,KAAA,CAAA,CAAA,CAAA,UACA,CAAA,CAAA,CAAAL,SAEJ,CAAA,CAAA,CAAA","file":"index.js","sourcesContent":["/*\n * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { useDndContext, useDroppable } from '@dnd-kit/core';\nimport { useSortable } from '@dnd-kit/sortable';\nimport { CSS } from '@dnd-kit/utilities';\nimport { calculateClosestEdge } from '@/components/kanban/context';\nimport type {\n  KanbanCardData,\n  KanbanColumnData,\n} from '@/components/kanban/types';\n\n/**\n * Hook that provides drag-and-drop interactions for a kanban column.\n *\n * This hook integrates with `@dnd-kit/core` to enable dropping cards into columns.\n * It tracks hover states, validates drop targets based on the column's `canDrop` property,\n * and provides visual feedback states for both the column itself and cards within it.\n *\n * @param column - The kanban column data object containing the column's id, canDrop status, and other properties\n *\n * @returns An object containing:\n * - `ref` - Ref callback to attach to the droppable column DOM element\n * - `isHighlighted` - Boolean indicating if the column should be visually highlighted (when a card from another column is being dragged)\n * - `isActive` - Boolean indicating if the column is actively being hovered over and can accept the drop\n *\n * @example\n * ```tsx\n * function KanbanColumn({ column }: { column: KanbanColumnData }) {\n *   const { ref, isHighlighted, isActive } = useColumnInteractions(column);\n *\n *   return (\n *     <div\n *       ref={ref}\n *       className={cn({\n *         'ring-2 ring-blue-300': isHighlighted && !isActive, // Potential drop target\n *         'ring-2 ring-blue-500 bg-blue-50': isActive,        // Active drop target\n *       })}\n *     >\n *       <h2>{column.title}</h2>\n *       {column.cards.map(card => <Card key={card.id} card={card} />)}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useColumnInteractions(column: KanbanColumnData) {\n  const { setNodeRef, isOver, active } = useDroppable({\n    id: column.id,\n    data: column,\n  });\n\n  // Get the global over state to detect when hovering over cards in this column\n  const { over } = useDndContext();\n\n  // Check if we're over the column itself OR over a card that belongs to this column\n  const isOverColumn = isOver || over?.data?.current?.columnId === column.id;\n\n  const isHighlighted = Boolean(\n    isOverColumn ||\n      (active &&\n        active.data.current?.columnId !== column.id &&\n        column.canDrop !== false),\n  );\n\n  const isActive = isOverColumn && column.canDrop !== false;\n\n  return {\n    ref: setNodeRef,\n    isHighlighted,\n    isActive,\n  };\n}\n\n/**\n * Hook that provides drag-and-drop interactions for a kanban card.\n *\n * This hook integrates with `@dnd-kit/sortable` to enable dragging, dropping, and reordering\n * of cards within and between columns. It handles transform animations, drag state tracking,\n * and edge detection for insertion positioning.\n *\n * @param card - The kanban card data object containing the card's id and other properties\n *\n * @returns An object containing:\n * - `ref` - Ref callback to attach to the draggable card DOM element\n * - `isDragging` - Boolean indicating if this card is currently being dragged\n * - `closestEdge` - The closest edge ('top' or 'bottom') when another card is hovering over this card, or null if not hovering\n * - `style` - CSS style object with transform and transition properties for drag animations\n * - `attributes` - Accessibility and drag attributes to spread on the card element\n * - `listeners` - Event listeners to spread on the drag handle element\n *\n * @example\n * ```tsx\n * function KanbanCard({ card }: { card: KanbanCardData }) {\n *   const { ref, isDragging, closestEdge, style, attributes, listeners } = useCardInteractions(card);\n *\n *   return (\n *     <div ref={ref} style={style} {...attributes} {...listeners}>\n *       {card.title}\n *       {closestEdge && <DropIndicator edge={closestEdge} />}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useCardInteractions(card: KanbanCardData) {\n  const {\n    attributes,\n    listeners,\n    setNodeRef,\n    transform,\n    transition,\n    isDragging,\n    over,\n    active,\n  } = useSortable({\n    id: card.id,\n    data: card,\n  });\n\n  const style = {\n    transform: CSS.Transform.toString(transform),\n    transition,\n  };\n\n  // Determine closest edge based on over position\n  let closestEdge: 'top' | 'bottom' | undefined;\n\n  if (over && over.id === card.id && active) {\n    closestEdge = calculateClosestEdge(over, active);\n  }\n\n  return {\n    ref: setNodeRef,\n    isDragging,\n    closestEdge,\n    style,\n    attributes,\n    listeners,\n  };\n}\n"]}
+{"version":3,"file":"index.js","names":["closestEdge: 'top' | 'bottom' | undefined"],"sources":["../../../src/hooks/kanban/index.ts"],"sourcesContent":["/*\n * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { useDndContext, useDroppable } from '@dnd-kit/core';\nimport { useSortable } from '@dnd-kit/sortable';\nimport { CSS } from '@dnd-kit/utilities';\nimport { calculateClosestEdge } from '@/components/kanban/context';\nimport type {\n  KanbanCardData,\n  KanbanColumnData,\n} from '@/components/kanban/types';\n\n/**\n * Hook that provides drag-and-drop interactions for a kanban column.\n *\n * This hook integrates with `@dnd-kit/core` to enable dropping cards into columns.\n * It tracks hover states, validates drop targets based on the column's `canDrop` property,\n * and provides visual feedback states for both the column itself and cards within it.\n *\n * @param column - The kanban column data object containing the column's id, canDrop status, and other properties\n *\n * @returns An object containing:\n * - `ref` - Ref callback to attach to the droppable column DOM element\n * - `isHighlighted` - Boolean indicating if the column should be visually highlighted (when a card from another column is being dragged)\n * - `isActive` - Boolean indicating if the column is actively being hovered over and can accept the drop\n *\n * @example\n * ```tsx\n * function KanbanColumn({ column }: { column: KanbanColumnData }) {\n *   const { ref, isHighlighted, isActive } = useColumnInteractions(column);\n *\n *   return (\n *     <div\n *       ref={ref}\n *       className={cn({\n *         'ring-2 ring-blue-300': isHighlighted && !isActive, // Potential drop target\n *         'ring-2 ring-blue-500 bg-blue-50': isActive,        // Active drop target\n *       })}\n *     >\n *       <h2>{column.title}</h2>\n *       {column.cards.map(card => <Card key={card.id} card={card} />)}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useColumnInteractions(column: KanbanColumnData) {\n  const { setNodeRef, isOver, active } = useDroppable({\n    id: column.id,\n    data: column,\n  });\n\n  // Get the global over state to detect when hovering over cards in this column\n  const { over } = useDndContext();\n\n  // Check if we're over the column itself OR over a card that belongs to this column\n  const isOverColumn = isOver || over?.data?.current?.columnId === column.id;\n\n  const isHighlighted = Boolean(\n    isOverColumn ||\n      (active &&\n        active.data.current?.columnId !== column.id &&\n        column.canDrop !== false),\n  );\n\n  const isActive = isOverColumn && column.canDrop !== false;\n\n  return {\n    ref: setNodeRef,\n    isHighlighted,\n    isActive,\n  };\n}\n\n/**\n * Hook that provides drag-and-drop interactions for a kanban card.\n *\n * This hook integrates with `@dnd-kit/sortable` to enable dragging, dropping, and reordering\n * of cards within and between columns. It handles transform animations, drag state tracking,\n * and edge detection for insertion positioning.\n *\n * @param card - The kanban card data object containing the card's id and other properties\n *\n * @returns An object containing:\n * - `ref` - Ref callback to attach to the draggable card DOM element\n * - `isDragging` - Boolean indicating if this card is currently being dragged\n * - `closestEdge` - The closest edge ('top' or 'bottom') when another card is hovering over this card, or null if not hovering\n * - `style` - CSS style object with transform and transition properties for drag animations\n * - `attributes` - Accessibility and drag attributes to spread on the card element\n * - `listeners` - Event listeners to spread on the drag handle element\n *\n * @example\n * ```tsx\n * function KanbanCard({ card }: { card: KanbanCardData }) {\n *   const { ref, isDragging, closestEdge, style, attributes, listeners } = useCardInteractions(card);\n *\n *   return (\n *     <div ref={ref} style={style} {...attributes} {...listeners}>\n *       {card.title}\n *       {closestEdge && <DropIndicator edge={closestEdge} />}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useCardInteractions(card: KanbanCardData) {\n  const {\n    attributes,\n    listeners,\n    setNodeRef,\n    transform,\n    transition,\n    isDragging,\n    over,\n    active,\n  } = useSortable({\n    id: card.id,\n    data: card,\n  });\n\n  const style = {\n    transform: CSS.Transform.toString(transform),\n    transition,\n  };\n\n  // Determine closest edge based on over position\n  let closestEdge: 'top' | 'bottom' | undefined;\n\n  if (over && over.id === card.id && active) {\n    closestEdge = calculateClosestEdge(over, active);\n  }\n\n  return {\n    ref: setNodeRef,\n    isDragging,\n    closestEdge,\n    style,\n    attributes,\n    listeners,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,SAAgB,sBAAsB,QAA0B;CAC9D,MAAM,EAAE,YAAY,QAAQ,WAAW,aAAa;EAClD,IAAI,OAAO;EACX,MAAM;EACP,CAAC;CAGF,MAAM,EAAE,SAAS,eAAe;CAGhC,MAAM,eAAe,UAAU,MAAM,MAAM,SAAS,aAAa,OAAO;AAWxE,QAAO;EACL,KAAK;EACL,eAXoB,QACpB,gBACG,UACC,OAAO,KAAK,SAAS,aAAa,OAAO,MACzC,OAAO,YAAY,MACxB;EAOC,UALe,gBAAgB,OAAO,YAAY;EAMnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCH,SAAgB,oBAAoB,MAAsB;CACxD,MAAM,EACJ,YACA,WACA,YACA,WACA,YACA,YACA,MACA,WACE,YAAY;EACd,IAAI,KAAK;EACT,MAAM;EACP,CAAC;CAEF,MAAM,QAAQ;EACZ,WAAW,IAAI,UAAU,SAAS,UAAU;EAC5C;EACD;CAGD,IAAIA;AAEJ,KAAI,QAAQ,KAAK,OAAO,KAAK,MAAM,OACjC,eAAc,qBAAqB,MAAM,OAAO;AAGlD,QAAO;EACL,KAAK;EACL;EACA;EACA;EACA;EACA;EACD"}

package/dist/hooks/use-tree/actions/cache.d.ts

@@ -1,10 +1,21 @@
-import { Key } from '@react-types/shared';
-import { TreeNode } from '../types.js';
-import 'react';
-import 'react-aria-components';
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
 
+import { TreeNode } from "../types.js";
+import { Key } from "@react-types/shared";
+
+//#region src/hooks/use-tree/actions/cache.d.ts
 type CacheTreeNode<T> = Omit<TreeNode<T>, 'children'> & {
-    children?: Key[];
+  children?: Key[];
 };
 /**
  * This is a cache created only for performance reasons and is considered
@@ -16,63 +27,68 @@ type CacheTreeNode<T> = Omit<TreeNode<T>, 'children'> & {
  * updated with each tree operation.
  */
 declare class Cache<T> {
-    protected cache: {
-        lookup: Map<Key, CacheTreeNode<T>>;
-        roots: Key[];
-    };
-    constructor(nodes?: TreeNode<T>[]);
-    /**
-     * Recursively creates the cache object from tree data
-     */
-    rebuild(nodes: TreeNode<T>[], lookup?: Map<Key, CacheTreeNode<T>>, parentKey?: Key | null): {
-        lookup: Map<Key, CacheTreeNode<T>>;
-        roots: Key[];
-    };
-    protected get(key: Key): CacheTreeNode<T>;
-    protected set(key: Key, node: CacheTreeNode<T>): void;
-    protected delete(key: Key): void;
-    protected addToParent(parentKey: Key, childKey: Key, idx: number): void;
-    protected addToRoot(key: Key, idx: number): void;
-    protected removeFromParent(parentKey: Key, childKey: Key): void;
-    protected removeFromRoot(key: Key): void;
-    protected parentOrSibling(target: Key | null, position: 'before' | 'after'): {
-        parentKey: Key | null;
-        index: number;
-    };
-    protected traverse(key: Key): void;
-    protected calculateVisibility(key: Key): boolean;
-    protected deriveVisibility(): void[];
-    /**
-     * Recursively builds a TreeNode from a key
-     *
-     * @param key
-     */
-    protected buildNode(key: Key): TreeNode<T>;
-    /**
-     * Builds a tree structure from cache
-     *
-     * TODO: optimization - rebuild only from change to root
-     * Rebuild only from the changed node up the tree to avoid
-     * rebuilding the entire tree
-     *
-     * @param deriveVisible boolean - if true, will recompute visibility for nodes based on ancestry
-     */
-    toTree(deriveVisible?: boolean): TreeNode<T>[];
-    /**
-     * CACHE FUNCTIONS
-     * These manage cache operations. No cache operations should ever be done
-     * outside this file.
-     **/
-    getNode(key: Key): TreeNode<T>;
-    getAllKeys(): MapIterator<Key>;
-    getAllNodes(): MapIterator<CacheTreeNode<T>>;
-    setNode(key: Key, node: TreeNode<T>): void;
-    setAllNodes({ parentKey, children, ...rest }: Partial<TreeNode<T>>): void;
-    deleteNode(key: Key): void;
-    addNodes(target: Key | null, nodes: TreeNode<T>[], position: 'before' | 'after'): void;
-    insertNode(parentKey: Key | null, node: TreeNode<T>, idx: number): void;
-    moveNodes(target: Key | null, nodes: Set<Key>, position: 'before' | 'after'): void;
-    moveNode(parentKey: Key | null, key: Key, idx: number): void;
+  protected cache: {
+    lookup: Map<Key, CacheTreeNode<T>>;
+    roots: Key[];
+  };
+  constructor(nodes?: TreeNode<T>[]);
+  /**
+   * Recursively creates the cache object from tree data
+   */
+  rebuild(nodes: TreeNode<T>[], lookup?: Map<Key, CacheTreeNode<T>>, parentKey?: Key | null): {
+    lookup: Map<Key, CacheTreeNode<T>>;
+    roots: Key[];
+  };
+  protected get(key: Key): CacheTreeNode<T>;
+  protected set(key: Key, node: CacheTreeNode<T>): void;
+  protected delete(key: Key): void;
+  protected addToParent(parentKey: Key, childKey: Key, idx: number): void;
+  protected addToRoot(key: Key, idx: number): void;
+  protected removeFromParent(parentKey: Key, childKey: Key): void;
+  protected removeFromRoot(key: Key): void;
+  protected parentOrSibling(target: Key | null, position: 'before' | 'after'): {
+    parentKey: Key | null;
+    index: number;
+  };
+  protected traverse(key: Key): void;
+  protected calculateVisibility(key: Key): boolean;
+  protected deriveVisibility(): void[];
+  /**
+   * Recursively builds a TreeNode from a key
+   *
+   * @param key
+   */
+  protected buildNode(key: Key): TreeNode<T>;
+  /**
+   * Builds a tree structure from cache
+   *
+   * TODO: optimization - rebuild only from change to root
+   * Rebuild only from the changed node up the tree to avoid
+   * rebuilding the entire tree
+   *
+   * @param deriveVisible boolean - if true, will recompute visibility for nodes based on ancestry
+   */
+  toTree(deriveVisible?: boolean): TreeNode<T>[];
+  /**
+   * CACHE FUNCTIONS
+   * These manage cache operations. No cache operations should ever be done
+   * outside this file.
+   **/
+  getNode(key: Key): TreeNode<T>;
+  getAllKeys(): MapIterator<Key>;
+  getAllNodes(): MapIterator<CacheTreeNode<T>>;
+  setNode(key: Key, node: TreeNode<T>): void;
+  setAllNodes({
+    parentKey,
+    children,
+    ...rest
+  }: Partial<TreeNode<T>>): void;
+  deleteNode(key: Key): void;
+  addNodes(target: Key | null, nodes: TreeNode<T>[], position: 'before' | 'after'): void;
+  insertNode(parentKey: Key | null, node: TreeNode<T>, idx: number): void;
+  moveNodes(target: Key | null, nodes: Set<Key>, position: 'before' | 'after'): void;
+  moveNode(parentKey: Key | null, key: Key, idx: number): void;
 }
-
+//#endregion
 export { Cache };
+//# sourceMappingURL=cache.d.ts.map

package/dist/hooks/use-tree/actions/cache.js

@@ -1,2 +1,255 @@
-class d{cache={lookup:new Map,roots:[]};constructor(e=[]){this.rebuild(e);}rebuild(e,t=new Map,s=null){e.forEach(r=>{const{children:o,...n}=r;t.set(r.key,{isDisabled:false,isExpanded:false,isSelected:false,isVisible:false,isVisibleComputed:false,...n,parentKey:s,...o?{children:o.map(l=>l.key)}:{}}),r.children&&this.rebuild(r.children,t,r.key);});const i={lookup:t,roots:e.map(r=>r.key)};return s||(this.cache=i),this.deriveVisibility(),i}get(e){const t=this.cache.lookup.get(e);if(t===void 0)throw new Error(`Key of ${e} does not exist in tree`);return t}set(e,t){this.cache.lookup.set(e,t);}delete(e){this.cache.lookup.delete(e);}addToParent(e,t,s){const i=this.get(e),r=this.get(t),o=Math.max(0,s);this.set(t,{...r,parentKey:e});const n=(i.children??[]).slice(0);n.splice(o,0,t),this.set(e,{...i,children:n});}addToRoot(e,t){const s=this.get(e),i=Math.max(0,t);this.set(e,{...s,parentKey:null}),this.cache.roots.splice(i,0,e);}removeFromParent(e,t){const s=this.get(e),i=this.get(t);this.set(t,{...i,parentKey:null}),this.cache.lookup.set(e,{...s,children:s.children?.filter(r=>r!==t)});}removeFromRoot(e){const t=this.get(e),s=this.cache.roots.indexOf(e);s>=0&&(this.set(e,{...t,parentKey:null}),this.cache.roots.splice(s,1));}parentOrSibling(e,t){let s,i=null;if(e===null)s=t==="before"?0:this.cache.roots.length;else {const r=this.get(e);if(r.parentKey){const o=this.get(r.parentKey);i=o.key,s=o.children?.indexOf(e)??0;}else s=this.cache.roots.indexOf(e);}return {parentKey:i,index:s}}traverse(e){const t=this.get(e);this.cache.lookup.set(e,{...t,isVisibleComputed:this.calculateVisibility(e)}),t.children?.map(s=>this.traverse(s));}calculateVisibility(e){let t=this.get(e);const s=[t];for(;t.parentKey;){const i=this.get(t.parentKey);i&&s.push(i),t=i;}return s.every(i=>i.isVisible)}deriveVisibility(){return this.cache.roots.map(e=>this.traverse(e))}buildNode(e){const t=this.get(e),s=(t.children??[]).reduce((i,r)=>{const o=this.cache.lookup.get(r);return o&&o.parentKey===e&&i.push(this.buildNode(r)),i},[]);return {...t,children:s}}toTree(e){return e&&this.deriveVisibility(),this.cache.roots.map(t=>this.buildNode(t))}getNode(e){const t=this.get(e);return {...t,children:t.children?.map(s=>this.buildNode(s))}}getAllKeys(){return this.cache.lookup.keys()}getAllNodes(){return this.cache.lookup.values()}setNode(e,t){this.set(e,{...t,children:(t.children??[]).map(s=>s.key)});}setAllNodes({parentKey:e,children:t,...s}){for(const i of this.cache.lookup.values())this.set(i.key,{...i,...s});}deleteNode(e){const t=this.cache.lookup.get(e);t&&(t.children?.map(s=>this.deleteNode(s)),t.parentKey?this.removeFromParent(t.parentKey,e):this.removeFromRoot(e),this.delete(e));}addNodes(e,t,s){const{parentKey:i,index:r}=this.parentOrSibling(e,s),o=r+(s==="before"?0:1);t.map((n,l)=>this.insertNode(i,n,o+l));}insertNode(e,t,s){const{children:i,...r}=t;this.set(t.key,{isDisabled:false,isExpanded:false,isSelected:false,isVisible:false,isVisibleComputed:false,...r,parentKey:e,...i?{children:i.map(o=>o.key)}:{}}),t.children?.map((o,n)=>this.insertNode(t.key,o,n)),e===null?this.addToRoot(t.key,s):this.addToParent(e,t.key,s);}moveNodes(e,t,s){const{parentKey:i,index:r}=this.parentOrSibling(e,s),o=r+(s==="before"?0:1);Array.from(t).map((n,l)=>this.moveNode(i,n,o+l));}moveNode(e,t,s){const i=this.get(t);i.parentKey?this.removeFromParent(i.parentKey,t):this.removeFromRoot(t),e?this.addToParent(e,t,s):this.addToRoot(t,s);}}export{d as Cache};//# sourceMappingURL=cache.js.map
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+//#region src/hooks/use-tree/actions/cache.ts
+/**
+* This is a cache created only for performance reasons and is considered
+* to be only a temporary mirror of the data. The data is *always* correct
+* cache should be updated according to the data, only. If the data and
+* the cache do not match, the cache is invalidated and rebuilt.
+*
+* This will initialize once on load with data, then
+* updated with each tree operation.
+*/
+var Cache = class {
+	cache = {
+		lookup: /* @__PURE__ */ new Map(),
+		roots: []
+	};
+	constructor(nodes = []) {
+		this.rebuild(nodes);
+	}
+	/**
+	* Recursively creates the cache object from tree data
+	*/
+	rebuild(nodes, lookup = /* @__PURE__ */ new Map(), parentKey = null) {
+		nodes.forEach((node) => {
+			const { children, ...rest } = node;
+			lookup.set(node.key, {
+				isDisabled: false,
+				isExpanded: false,
+				isSelected: false,
+				isVisible: false,
+				isVisibleComputed: false,
+				...rest,
+				parentKey,
+				...children ? { children: children.map((child) => child.key) } : {}
+			});
+			if (node.children) this.rebuild(node.children, lookup, node.key);
+		});
+		const cache = {
+			lookup,
+			roots: nodes.map((node) => node.key)
+		};
+		if (!parentKey) this.cache = cache;
+		this.deriveVisibility();
+		return cache;
+	}
+	get(key) {
+		const node = this.cache.lookup.get(key);
+		if (node === void 0) throw new Error(`Key of ${key} does not exist in tree`);
+		return node;
+	}
+	set(key, node) {
+		this.cache.lookup.set(key, node);
+	}
+	delete(key) {
+		this.cache.lookup.delete(key);
+	}
+	addToParent(parentKey, childKey, idx) {
+		const parent = this.get(parentKey);
+		const child = this.get(childKey);
+		const index = Math.max(0, idx);
+		this.set(childKey, {
+			...child,
+			parentKey
+		});
+		const children = (parent.children ?? []).slice(0);
+		children.splice(index, 0, childKey);
+		this.set(parentKey, {
+			...parent,
+			children
+		});
+	}
+	addToRoot(key, idx) {
+		const node = this.get(key);
+		const index = Math.max(0, idx);
+		this.set(key, {
+			...node,
+			parentKey: null
+		});
+		this.cache.roots.splice(index, 0, key);
+	}
+	removeFromParent(parentKey, childKey) {
+		const parent = this.get(parentKey);
+		const child = this.get(childKey);
+		this.set(childKey, {
+			...child,
+			parentKey: null
+		});
+		this.cache.lookup.set(parentKey, {
+			...parent,
+			children: parent.children?.filter((key) => key !== childKey)
+		});
+	}
+	removeFromRoot(key) {
+		const node = this.get(key);
+		const idx = this.cache.roots.indexOf(key);
+		if (idx >= 0) {
+			this.set(key, {
+				...node,
+				parentKey: null
+			});
+			this.cache.roots.splice(idx, 1);
+		}
+	}
+	parentOrSibling(target, position) {
+		let index;
+		let parentKey = null;
+		if (target === null) index = position === "before" ? 0 : this.cache.roots.length;
+		else {
+			const targetNode = this.get(target);
+			if (targetNode.parentKey) {
+				const parent = this.get(targetNode.parentKey);
+				parentKey = parent.key;
+				index = parent.children?.indexOf(target) ?? 0;
+			} else index = this.cache.roots.indexOf(target);
+		}
+		return {
+			parentKey,
+			index
+		};
+	}
+	traverse(key) {
+		const node = this.get(key);
+		this.cache.lookup.set(key, {
+			...node,
+			isVisibleComputed: this.calculateVisibility(key)
+		});
+		node.children?.map((child) => this.traverse(child));
+	}
+	calculateVisibility(key) {
+		let current = this.get(key);
+		const ancestry = [current];
+		while (current.parentKey) {
+			const parent = this.get(current.parentKey);
+			if (parent) ancestry.push(parent);
+			current = parent;
+		}
+		return ancestry.every((n) => n.isVisible);
+	}
+	deriveVisibility() {
+		return this.cache.roots.map((key) => this.traverse(key));
+	}
+	/**
+	* Recursively builds a TreeNode from a key
+	*
+	* @param key
+	*/
+	buildNode(key) {
+		const node = this.get(key);
+		const children = (node.children ?? []).reduce((acc, child) => {
+			const childNode = this.cache.lookup.get(child);
+			if (childNode && childNode.parentKey === key) acc.push(this.buildNode(child));
+			return acc;
+		}, []);
+		return {
+			...node,
+			children
+		};
+	}
+	/**
+	* Builds a tree structure from cache
+	*
+	* TODO: optimization - rebuild only from change to root
+	* Rebuild only from the changed node up the tree to avoid
+	* rebuilding the entire tree
+	*
+	* @param deriveVisible boolean - if true, will recompute visibility for nodes based on ancestry
+	*/
+	toTree(deriveVisible) {
+		if (deriveVisible) this.deriveVisibility();
+		return this.cache.roots.map((key) => this.buildNode(key));
+	}
+	/**
+	* CACHE FUNCTIONS
+	* These manage cache operations. No cache operations should ever be done
+	* outside this file.
+	**/
+	getNode(key) {
+		const node = this.get(key);
+		return {
+			...node,
+			children: node.children?.map((key$1) => this.buildNode(key$1))
+		};
+	}
+	getAllKeys() {
+		return this.cache.lookup.keys();
+	}
+	getAllNodes() {
+		return this.cache.lookup.values();
+	}
+	setNode(key, node) {
+		this.set(key, {
+			...node,
+			children: (node.children ?? []).map((child) => child.key)
+		});
+	}
+	setAllNodes({ parentKey, children, ...rest }) {
+		for (const node of this.cache.lookup.values()) this.set(node.key, {
+			...node,
+			...rest
+		});
+	}
+	deleteNode(key) {
+		const node = this.cache.lookup.get(key);
+		if (!node) return;
+		node.children?.map((key$1) => this.deleteNode(key$1));
+		node.parentKey ? this.removeFromParent(node.parentKey, key) : this.removeFromRoot(key);
+		this.delete(key);
+	}
+	addNodes(target, nodes, position) {
+		const { parentKey, index } = this.parentOrSibling(target, position);
+		const idx = index + (position === "before" ? 0 : 1);
+		nodes.map((node, i) => this.insertNode(parentKey, node, idx + i));
+	}
+	insertNode(parentKey, node, idx) {
+		const { children, ...rest } = node;
+		this.set(node.key, {
+			isDisabled: false,
+			isExpanded: false,
+			isSelected: false,
+			isVisible: false,
+			isVisibleComputed: false,
+			...rest,
+			parentKey,
+			...children ? { children: children.map((child) => child.key) } : {}
+		});
+		node.children?.map((child, i) => this.insertNode(node.key, child, i));
+		parentKey === null ? this.addToRoot(node.key, idx) : this.addToParent(parentKey, node.key, idx);
+	}
+	moveNodes(target, nodes, position) {
+		const { parentKey, index } = this.parentOrSibling(target, position);
+		const idx = index + (position === "before" ? 0 : 1);
+		Array.from(nodes).map((key, i) => this.moveNode(parentKey, key, idx + i));
+	}
+	moveNode(parentKey, key, idx) {
+		const node = this.get(key);
+		node.parentKey ? this.removeFromParent(node.parentKey, key) : this.removeFromRoot(key);
+		parentKey ? this.addToParent(parentKey, key, idx) : this.addToRoot(key, idx);
+	}
+};
+
+//#endregion
+export { Cache };
 //# sourceMappingURL=cache.js.map

package/dist/hooks/use-tree/actions/cache.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/hooks/use-tree/actions/cache.ts"],"names":["Cache","nodes","lookup","parentKey","node","children","rest","child","cache","key","childKey","idx","parent","index","target","position","targetNode","current","ancestry","n","acc","childNode","deriveVisible","i"],"mappings":"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","file":"cache.js","sourcesContent":["// __private-exports\n/*\n * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport type { Key } from '@react-types/shared';\nimport type { TreeNode } from '../types';\n\ntype CacheTreeNode<T> = Omit<TreeNode<T>, 'children'> & {\n  children?: Key[];\n};\n\n/**\n * This is a cache created only for performance reasons and is considered\n * to be only a temporary mirror of the data. The data is *always* correct\n * cache should be updated according to the data, only. If the data and\n * the cache do not match, the cache is invalidated and rebuilt.\n *\n * This will initialize once on load with data, then\n * updated with each tree operation.\n */\nexport class Cache<T> {\n  protected cache: { lookup: Map<Key, CacheTreeNode<T>>; roots: Key[] } = {\n    lookup: new Map(),\n    roots: [],\n  };\n\n  constructor(nodes: TreeNode<T>[] = []) {\n    this.rebuild(nodes);\n  }\n\n  /**\n   * Recursively creates the cache object from tree data\n   */\n  rebuild(\n    nodes: TreeNode<T>[],\n    lookup: Map<Key, CacheTreeNode<T>> = new Map(),\n    parentKey: Key | null = null,\n  ) {\n    nodes.forEach((node) => {\n      const { children, ...rest } = node;\n\n      lookup.set(node.key, {\n        isDisabled: false,\n        isExpanded: false,\n        isSelected: false,\n        isVisible: false,\n        isVisibleComputed: false,\n        ...rest,\n        parentKey,\n        ...(children ? { children: children.map((child) => child.key) } : {}),\n      });\n\n      if (node.children) {\n        this.rebuild(node.children, lookup, node.key);\n      }\n    });\n\n    const cache = { lookup, roots: nodes.map((node) => node.key) };\n\n    if (!parentKey) {\n      this.cache = cache;\n    }\n\n    this.deriveVisibility();\n    return cache;\n  }\n\n  protected get(key: Key) {\n    const node = this.cache.lookup.get(key);\n\n    if (node === undefined) {\n      throw new Error(`Key of ${key} does not exist in tree`);\n    }\n\n    return node;\n  }\n\n  protected set(key: Key, node: CacheTreeNode<T>) {\n    this.cache.lookup.set(key, node);\n  }\n\n  protected delete(key: Key) {\n    this.cache.lookup.delete(key);\n  }\n\n  protected addToParent(parentKey: Key, childKey: Key, idx: number) {\n    const parent = this.get(parentKey);\n    const child = this.get(childKey);\n    const index = Math.max(0, idx);\n\n    this.set(childKey, {\n      ...child,\n      parentKey,\n    });\n\n    const children = (parent.children ?? []).slice(0);\n\n    children.splice(index, 0, childKey);\n\n    this.set(parentKey, {\n      ...parent,\n      children,\n    });\n  }\n\n  protected addToRoot(key: Key, idx: number) {\n    const node = this.get(key);\n    const index = Math.max(0, idx);\n\n    this.set(key, {\n      ...node,\n      parentKey: null,\n    });\n\n    this.cache.roots.splice(index, 0, key);\n  }\n\n  protected removeFromParent(parentKey: Key, childKey: Key) {\n    const parent = this.get(parentKey);\n    const child = this.get(childKey);\n\n    this.set(childKey, {\n      ...child,\n      parentKey: null,\n    });\n\n    this.cache.lookup.set(parentKey, {\n      ...parent,\n      children: parent.children?.filter((key) => key !== childKey),\n    });\n  }\n\n  protected removeFromRoot(key: Key) {\n    const node = this.get(key);\n    const idx = this.cache.roots.indexOf(key);\n\n    if (idx >= 0) {\n      this.set(key, {\n        ...node,\n        parentKey: null,\n      });\n\n      this.cache.roots.splice(idx, 1);\n    }\n  }\n\n  protected parentOrSibling(target: Key | null, position: 'before' | 'after') {\n    let index: number;\n    let parentKey: Key | null = null;\n\n    if (target === null) {\n      index = position === 'before' ? 0 : this.cache.roots.length;\n    } else {\n      const targetNode = this.get(target);\n\n      if (targetNode.parentKey) {\n        const parent = this.get(targetNode.parentKey);\n\n        parentKey = parent.key;\n        index = parent.children?.indexOf(target) ?? 0;\n      } else {\n        index = this.cache.roots.indexOf(target);\n      }\n    }\n\n    return { parentKey, index };\n  }\n\n  protected traverse(key: Key) {\n    const node = this.get(key);\n\n    this.cache.lookup.set(key, {\n      ...node,\n      isVisibleComputed: this.calculateVisibility(key),\n    });\n\n    node.children?.map((child) => this.traverse(child));\n  }\n\n  protected calculateVisibility(key: Key) {\n    let current = this.get(key);\n    const ancestry = [current];\n\n    while (current.parentKey) {\n      const parent = this.get(current.parentKey);\n      if (parent) {\n        ancestry.push(parent);\n      }\n      current = parent;\n    }\n\n    return ancestry.every((n) => n.isVisible);\n  }\n\n  protected deriveVisibility() {\n    return this.cache.roots.map((key) => this.traverse(key));\n  }\n  /**\n   * Recursively builds a TreeNode from a key\n   *\n   * @param key\n   */\n  protected buildNode(key: Key): TreeNode<T> {\n    const node = this.get(key);\n\n    const children = (node.children ?? []).reduce(\n      (acc: TreeNode<T>[], child) => {\n        const childNode = this.cache.lookup.get(child);\n\n        if (childNode && childNode.parentKey === key) {\n          acc.push(this.buildNode(child));\n        }\n\n        return acc;\n      },\n      [],\n    );\n\n    return {\n      ...node,\n      children,\n    };\n  }\n\n  /**\n   * Builds a tree structure from cache\n   *\n   * TODO: optimization - rebuild only from change to root\n   * Rebuild only from the changed node up the tree to avoid\n   * rebuilding the entire tree\n   *\n   * @param deriveVisible boolean - if true, will recompute visibility for nodes based on ancestry\n   */\n  toTree(deriveVisible?: boolean): TreeNode<T>[] {\n    if (deriveVisible) {\n      this.deriveVisibility();\n    }\n    return this.cache.roots.map((key) => this.buildNode(key));\n  }\n\n  /**\n   * CACHE FUNCTIONS\n   * These manage cache operations. No cache operations should ever be done\n   * outside this file.\n   **/\n  getNode(key: Key): TreeNode<T> {\n    const node = this.get(key);\n\n    return {\n      ...node,\n      children: node.children?.map((key) => this.buildNode(key)),\n    };\n  }\n\n  getAllKeys() {\n    return this.cache.lookup.keys();\n  }\n\n  getAllNodes() {\n    return this.cache.lookup.values();\n  }\n\n  setNode(key: Key, node: TreeNode<T>) {\n    this.set(key, {\n      ...node,\n      children: (node.children ?? []).map((child) => child.key),\n    });\n  }\n\n  setAllNodes({ parentKey, children, ...rest }: Partial<TreeNode<T>>) {\n    for (const node of this.cache.lookup.values()) {\n      this.set(node.key, {\n        ...node,\n        ...rest,\n      });\n    }\n  }\n\n  deleteNode(key: Key) {\n    const node = this.cache.lookup.get(key);\n\n    if (!node) {\n      return;\n    }\n\n    // remove children\n    node.children?.map((key) => this.deleteNode(key));\n\n    // remove node from previous parent or root\n    node.parentKey\n      ? this.removeFromParent(node.parentKey, key)\n      : this.removeFromRoot(key);\n\n    // remove the actual node\n    this.delete(key);\n  }\n\n  addNodes(\n    target: Key | null,\n    nodes: TreeNode<T>[],\n    position: 'before' | 'after',\n  ) {\n    const { parentKey, index } = this.parentOrSibling(target, position);\n    const idx = index + (position === 'before' ? 0 : 1);\n\n    nodes.map((node, i) => this.insertNode(parentKey, node, idx + i));\n  }\n\n  insertNode(parentKey: Key | null, node: TreeNode<T>, idx: number) {\n    const { children, ...rest } = node;\n\n    this.set(node.key, {\n      isDisabled: false,\n      isExpanded: false,\n      isSelected: false,\n      isVisible: false,\n      isVisibleComputed: false,\n      ...rest,\n      parentKey,\n      ...(children ? { children: children.map((child) => child.key) } : {}),\n    });\n\n    node.children?.map((child, i) => this.insertNode(node.key, child, i));\n\n    parentKey === null\n      ? this.addToRoot(node.key, idx)\n      : this.addToParent(parentKey, node.key, idx);\n  }\n\n  moveNodes(target: Key | null, nodes: Set<Key>, position: 'before' | 'after') {\n    const { parentKey, index } = this.parentOrSibling(target, position);\n    const idx = index + (position === 'before' ? 0 : 1);\n\n    Array.from(nodes).map((key, i) => this.moveNode(parentKey, key, idx + i));\n  }\n\n  moveNode(parentKey: Key | null, key: Key, idx: number) {\n    const node = this.get(key);\n\n    // remove from previous parent\n    node.parentKey\n      ? this.removeFromParent(node.parentKey, key)\n      : this.removeFromRoot(key);\n\n    // add as child to new parent or root at position\n    parentKey\n      ? this.addToParent(parentKey, key, idx)\n      : this.addToRoot(key, idx);\n  }\n}\n"]}
+{"version":3,"file":"cache.js","names":["index: number","parentKey: Key | null","key"],"sources":["../../../../src/hooks/use-tree/actions/cache.ts"],"sourcesContent":["// __private-exports\n/*\n * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport type { Key } from '@react-types/shared';\nimport type { TreeNode } from '../types';\n\ntype CacheTreeNode<T> = Omit<TreeNode<T>, 'children'> & {\n  children?: Key[];\n};\n\n/**\n * This is a cache created only for performance reasons and is considered\n * to be only a temporary mirror of the data. The data is *always* correct\n * cache should be updated according to the data, only. If the data and\n * the cache do not match, the cache is invalidated and rebuilt.\n *\n * This will initialize once on load with data, then\n * updated with each tree operation.\n */\nexport class Cache<T> {\n  protected cache: { lookup: Map<Key, CacheTreeNode<T>>; roots: Key[] } = {\n    lookup: new Map(),\n    roots: [],\n  };\n\n  constructor(nodes: TreeNode<T>[] = []) {\n    this.rebuild(nodes);\n  }\n\n  /**\n   * Recursively creates the cache object from tree data\n   */\n  rebuild(\n    nodes: TreeNode<T>[],\n    lookup: Map<Key, CacheTreeNode<T>> = new Map(),\n    parentKey: Key | null = null,\n  ) {\n    nodes.forEach((node) => {\n      const { children, ...rest } = node;\n\n      lookup.set(node.key, {\n        isDisabled: false,\n        isExpanded: false,\n        isSelected: false,\n        isVisible: false,\n        isVisibleComputed: false,\n        ...rest,\n        parentKey,\n        ...(children ? { children: children.map((child) => child.key) } : {}),\n      });\n\n      if (node.children) {\n        this.rebuild(node.children, lookup, node.key);\n      }\n    });\n\n    const cache = { lookup, roots: nodes.map((node) => node.key) };\n\n    if (!parentKey) {\n      this.cache = cache;\n    }\n\n    this.deriveVisibility();\n    return cache;\n  }\n\n  protected get(key: Key) {\n    const node = this.cache.lookup.get(key);\n\n    if (node === undefined) {\n      throw new Error(`Key of ${key} does not exist in tree`);\n    }\n\n    return node;\n  }\n\n  protected set(key: Key, node: CacheTreeNode<T>) {\n    this.cache.lookup.set(key, node);\n  }\n\n  protected delete(key: Key) {\n    this.cache.lookup.delete(key);\n  }\n\n  protected addToParent(parentKey: Key, childKey: Key, idx: number) {\n    const parent = this.get(parentKey);\n    const child = this.get(childKey);\n    const index = Math.max(0, idx);\n\n    this.set(childKey, {\n      ...child,\n      parentKey,\n    });\n\n    const children = (parent.children ?? []).slice(0);\n\n    children.splice(index, 0, childKey);\n\n    this.set(parentKey, {\n      ...parent,\n      children,\n    });\n  }\n\n  protected addToRoot(key: Key, idx: number) {\n    const node = this.get(key);\n    const index = Math.max(0, idx);\n\n    this.set(key, {\n      ...node,\n      parentKey: null,\n    });\n\n    this.cache.roots.splice(index, 0, key);\n  }\n\n  protected removeFromParent(parentKey: Key, childKey: Key) {\n    const parent = this.get(parentKey);\n    const child = this.get(childKey);\n\n    this.set(childKey, {\n      ...child,\n      parentKey: null,\n    });\n\n    this.cache.lookup.set(parentKey, {\n      ...parent,\n      children: parent.children?.filter((key) => key !== childKey),\n    });\n  }\n\n  protected removeFromRoot(key: Key) {\n    const node = this.get(key);\n    const idx = this.cache.roots.indexOf(key);\n\n    if (idx >= 0) {\n      this.set(key, {\n        ...node,\n        parentKey: null,\n      });\n\n      this.cache.roots.splice(idx, 1);\n    }\n  }\n\n  protected parentOrSibling(target: Key | null, position: 'before' | 'after') {\n    let index: number;\n    let parentKey: Key | null = null;\n\n    if (target === null) {\n      index = position === 'before' ? 0 : this.cache.roots.length;\n    } else {\n      const targetNode = this.get(target);\n\n      if (targetNode.parentKey) {\n        const parent = this.get(targetNode.parentKey);\n\n        parentKey = parent.key;\n        index = parent.children?.indexOf(target) ?? 0;\n      } else {\n        index = this.cache.roots.indexOf(target);\n      }\n    }\n\n    return { parentKey, index };\n  }\n\n  protected traverse(key: Key) {\n    const node = this.get(key);\n\n    this.cache.lookup.set(key, {\n      ...node,\n      isVisibleComputed: this.calculateVisibility(key),\n    });\n\n    node.children?.map((child) => this.traverse(child));\n  }\n\n  protected calculateVisibility(key: Key) {\n    let current = this.get(key);\n    const ancestry = [current];\n\n    while (current.parentKey) {\n      const parent = this.get(current.parentKey);\n      if (parent) {\n        ancestry.push(parent);\n      }\n      current = parent;\n    }\n\n    return ancestry.every((n) => n.isVisible);\n  }\n\n  protected deriveVisibility() {\n    return this.cache.roots.map((key) => this.traverse(key));\n  }\n  /**\n   * Recursively builds a TreeNode from a key\n   *\n   * @param key\n   */\n  protected buildNode(key: Key): TreeNode<T> {\n    const node = this.get(key);\n\n    const children = (node.children ?? []).reduce(\n      (acc: TreeNode<T>[], child) => {\n        const childNode = this.cache.lookup.get(child);\n\n        if (childNode && childNode.parentKey === key) {\n          acc.push(this.buildNode(child));\n        }\n\n        return acc;\n      },\n      [],\n    );\n\n    return {\n      ...node,\n      children,\n    };\n  }\n\n  /**\n   * Builds a tree structure from cache\n   *\n   * TODO: optimization - rebuild only from change to root\n   * Rebuild only from the changed node up the tree to avoid\n   * rebuilding the entire tree\n   *\n   * @param deriveVisible boolean - if true, will recompute visibility for nodes based on ancestry\n   */\n  toTree(deriveVisible?: boolean): TreeNode<T>[] {\n    if (deriveVisible) {\n      this.deriveVisibility();\n    }\n    return this.cache.roots.map((key) => this.buildNode(key));\n  }\n\n  /**\n   * CACHE FUNCTIONS\n   * These manage cache operations. No cache operations should ever be done\n   * outside this file.\n   **/\n  getNode(key: Key): TreeNode<T> {\n    const node = this.get(key);\n\n    return {\n      ...node,\n      children: node.children?.map((key) => this.buildNode(key)),\n    };\n  }\n\n  getAllKeys() {\n    return this.cache.lookup.keys();\n  }\n\n  getAllNodes() {\n    return this.cache.lookup.values();\n  }\n\n  setNode(key: Key, node: TreeNode<T>) {\n    this.set(key, {\n      ...node,\n      children: (node.children ?? []).map((child) => child.key),\n    });\n  }\n\n  setAllNodes({ parentKey, children, ...rest }: Partial<TreeNode<T>>) {\n    for (const node of this.cache.lookup.values()) {\n      this.set(node.key, {\n        ...node,\n        ...rest,\n      });\n    }\n  }\n\n  deleteNode(key: Key) {\n    const node = this.cache.lookup.get(key);\n\n    if (!node) {\n      return;\n    }\n\n    // remove children\n    node.children?.map((key) => this.deleteNode(key));\n\n    // remove node from previous parent or root\n    node.parentKey\n      ? this.removeFromParent(node.parentKey, key)\n      : this.removeFromRoot(key);\n\n    // remove the actual node\n    this.delete(key);\n  }\n\n  addNodes(\n    target: Key | null,\n    nodes: TreeNode<T>[],\n    position: 'before' | 'after',\n  ) {\n    const { parentKey, index } = this.parentOrSibling(target, position);\n    const idx = index + (position === 'before' ? 0 : 1);\n\n    nodes.map((node, i) => this.insertNode(parentKey, node, idx + i));\n  }\n\n  insertNode(parentKey: Key | null, node: TreeNode<T>, idx: number) {\n    const { children, ...rest } = node;\n\n    this.set(node.key, {\n      isDisabled: false,\n      isExpanded: false,\n      isSelected: false,\n      isVisible: false,\n      isVisibleComputed: false,\n      ...rest,\n      parentKey,\n      ...(children ? { children: children.map((child) => child.key) } : {}),\n    });\n\n    node.children?.map((child, i) => this.insertNode(node.key, child, i));\n\n    parentKey === null\n      ? this.addToRoot(node.key, idx)\n      : this.addToParent(parentKey, node.key, idx);\n  }\n\n  moveNodes(target: Key | null, nodes: Set<Key>, position: 'before' | 'after') {\n    const { parentKey, index } = this.parentOrSibling(target, position);\n    const idx = index + (position === 'before' ? 0 : 1);\n\n    Array.from(nodes).map((key, i) => this.moveNode(parentKey, key, idx + i));\n  }\n\n  moveNode(parentKey: Key | null, key: Key, idx: number) {\n    const node = this.get(key);\n\n    // remove from previous parent\n    node.parentKey\n      ? this.removeFromParent(node.parentKey, key)\n      : this.removeFromRoot(key);\n\n    // add as child to new parent or root at position\n    parentKey\n      ? this.addToParent(parentKey, key, idx)\n      : this.addToRoot(key, idx);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,QAAb,MAAsB;CACpB,AAAU,QAA8D;EACtE,wBAAQ,IAAI,KAAK;EACjB,OAAO,EAAE;EACV;CAED,YAAY,QAAuB,EAAE,EAAE;AACrC,OAAK,QAAQ,MAAM;;;;;CAMrB,QACE,OACA,yBAAqC,IAAI,KAAK,EAC9C,YAAwB,MACxB;AACA,QAAM,SAAS,SAAS;GACtB,MAAM,EAAE,UAAU,GAAG,SAAS;AAE9B,UAAO,IAAI,KAAK,KAAK;IACnB,YAAY;IACZ,YAAY;IACZ,YAAY;IACZ,WAAW;IACX,mBAAmB;IACnB,GAAG;IACH;IACA,GAAI,WAAW,EAAE,UAAU,SAAS,KAAK,UAAU,MAAM,IAAI,EAAE,GAAG,EAAE;IACrE,CAAC;AAEF,OAAI,KAAK,SACP,MAAK,QAAQ,KAAK,UAAU,QAAQ,KAAK,IAAI;IAE/C;EAEF,MAAM,QAAQ;GAAE;GAAQ,OAAO,MAAM,KAAK,SAAS,KAAK,IAAI;GAAE;AAE9D,MAAI,CAAC,UACH,MAAK,QAAQ;AAGf,OAAK,kBAAkB;AACvB,SAAO;;CAGT,AAAU,IAAI,KAAU;EACtB,MAAM,OAAO,KAAK,MAAM,OAAO,IAAI,IAAI;AAEvC,MAAI,SAAS,OACX,OAAM,IAAI,MAAM,UAAU,IAAI,yBAAyB;AAGzD,SAAO;;CAGT,AAAU,IAAI,KAAU,MAAwB;AAC9C,OAAK,MAAM,OAAO,IAAI,KAAK,KAAK;;CAGlC,AAAU,OAAO,KAAU;AACzB,OAAK,MAAM,OAAO,OAAO,IAAI;;CAG/B,AAAU,YAAY,WAAgB,UAAe,KAAa;EAChE,MAAM,SAAS,KAAK,IAAI,UAAU;EAClC,MAAM,QAAQ,KAAK,IAAI,SAAS;EAChC,MAAM,QAAQ,KAAK,IAAI,GAAG,IAAI;AAE9B,OAAK,IAAI,UAAU;GACjB,GAAG;GACH;GACD,CAAC;EAEF,MAAM,YAAY,OAAO,YAAY,EAAE,EAAE,MAAM,EAAE;AAEjD,WAAS,OAAO,OAAO,GAAG,SAAS;AAEnC,OAAK,IAAI,WAAW;GAClB,GAAG;GACH;GACD,CAAC;;CAGJ,AAAU,UAAU,KAAU,KAAa;EACzC,MAAM,OAAO,KAAK,IAAI,IAAI;EAC1B,MAAM,QAAQ,KAAK,IAAI,GAAG,IAAI;AAE9B,OAAK,IAAI,KAAK;GACZ,GAAG;GACH,WAAW;GACZ,CAAC;AAEF,OAAK,MAAM,MAAM,OAAO,OAAO,GAAG,IAAI;;CAGxC,AAAU,iBAAiB,WAAgB,UAAe;EACxD,MAAM,SAAS,KAAK,IAAI,UAAU;EAClC,MAAM,QAAQ,KAAK,IAAI,SAAS;AAEhC,OAAK,IAAI,UAAU;GACjB,GAAG;GACH,WAAW;GACZ,CAAC;AAEF,OAAK,MAAM,OAAO,IAAI,WAAW;GAC/B,GAAG;GACH,UAAU,OAAO,UAAU,QAAQ,QAAQ,QAAQ,SAAS;GAC7D,CAAC;;CAGJ,AAAU,eAAe,KAAU;EACjC,MAAM,OAAO,KAAK,IAAI,IAAI;EAC1B,MAAM,MAAM,KAAK,MAAM,MAAM,QAAQ,IAAI;AAEzC,MAAI,OAAO,GAAG;AACZ,QAAK,IAAI,KAAK;IACZ,GAAG;IACH,WAAW;IACZ,CAAC;AAEF,QAAK,MAAM,MAAM,OAAO,KAAK,EAAE;;;CAInC,AAAU,gBAAgB,QAAoB,UAA8B;EAC1E,IAAIA;EACJ,IAAIC,YAAwB;AAE5B,MAAI,WAAW,KACb,SAAQ,aAAa,WAAW,IAAI,KAAK,MAAM,MAAM;OAChD;GACL,MAAM,aAAa,KAAK,IAAI,OAAO;AAEnC,OAAI,WAAW,WAAW;IACxB,MAAM,SAAS,KAAK,IAAI,WAAW,UAAU;AAE7C,gBAAY,OAAO;AACnB,YAAQ,OAAO,UAAU,QAAQ,OAAO,IAAI;SAE5C,SAAQ,KAAK,MAAM,MAAM,QAAQ,OAAO;;AAI5C,SAAO;GAAE;GAAW;GAAO;;CAG7B,AAAU,SAAS,KAAU;EAC3B,MAAM,OAAO,KAAK,IAAI,IAAI;AAE1B,OAAK,MAAM,OAAO,IAAI,KAAK;GACzB,GAAG;GACH,mBAAmB,KAAK,oBAAoB,IAAI;GACjD,CAAC;AAEF,OAAK,UAAU,KAAK,UAAU,KAAK,SAAS,MAAM,CAAC;;CAGrD,AAAU,oBAAoB,KAAU;EACtC,IAAI,UAAU,KAAK,IAAI,IAAI;EAC3B,MAAM,WAAW,CAAC,QAAQ;AAE1B,SAAO,QAAQ,WAAW;GACxB,MAAM,SAAS,KAAK,IAAI,QAAQ,UAAU;AAC1C,OAAI,OACF,UAAS,KAAK,OAAO;AAEvB,aAAU;;AAGZ,SAAO,SAAS,OAAO,MAAM,EAAE,UAAU;;CAG3C,AAAU,mBAAmB;AAC3B,SAAO,KAAK,MAAM,MAAM,KAAK,QAAQ,KAAK,SAAS,IAAI,CAAC;;;;;;;CAO1D,AAAU,UAAU,KAAuB;EACzC,MAAM,OAAO,KAAK,IAAI,IAAI;EAE1B,MAAM,YAAY,KAAK,YAAY,EAAE,EAAE,QACpC,KAAoB,UAAU;GAC7B,MAAM,YAAY,KAAK,MAAM,OAAO,IAAI,MAAM;AAE9C,OAAI,aAAa,UAAU,cAAc,IACvC,KAAI,KAAK,KAAK,UAAU,MAAM,CAAC;AAGjC,UAAO;KAET,EAAE,CACH;AAED,SAAO;GACL,GAAG;GACH;GACD;;;;;;;;;;;CAYH,OAAO,eAAwC;AAC7C,MAAI,cACF,MAAK,kBAAkB;AAEzB,SAAO,KAAK,MAAM,MAAM,KAAK,QAAQ,KAAK,UAAU,IAAI,CAAC;;;;;;;CAQ3D,QAAQ,KAAuB;EAC7B,MAAM,OAAO,KAAK,IAAI,IAAI;AAE1B,SAAO;GACL,GAAG;GACH,UAAU,KAAK,UAAU,KAAK,UAAQ,KAAK,UAAUC,MAAI,CAAC;GAC3D;;CAGH,aAAa;AACX,SAAO,KAAK,MAAM,OAAO,MAAM;;CAGjC,cAAc;AACZ,SAAO,KAAK,MAAM,OAAO,QAAQ;;CAGnC,QAAQ,KAAU,MAAmB;AACnC,OAAK,IAAI,KAAK;GACZ,GAAG;GACH,WAAW,KAAK,YAAY,EAAE,EAAE,KAAK,UAAU,MAAM,IAAI;GAC1D,CAAC;;CAGJ,YAAY,EAAE,WAAW,UAAU,GAAG,QAA8B;AAClE,OAAK,MAAM,QAAQ,KAAK,MAAM,OAAO,QAAQ,CAC3C,MAAK,IAAI,KAAK,KAAK;GACjB,GAAG;GACH,GAAG;GACJ,CAAC;;CAIN,WAAW,KAAU;EACnB,MAAM,OAAO,KAAK,MAAM,OAAO,IAAI,IAAI;AAEvC,MAAI,CAAC,KACH;AAIF,OAAK,UAAU,KAAK,UAAQ,KAAK,WAAWA,MAAI,CAAC;AAGjD,OAAK,YACD,KAAK,iBAAiB,KAAK,WAAW,IAAI,GAC1C,KAAK,eAAe,IAAI;AAG5B,OAAK,OAAO,IAAI;;CAGlB,SACE,QACA,OACA,UACA;EACA,MAAM,EAAE,WAAW,UAAU,KAAK,gBAAgB,QAAQ,SAAS;EACnE,MAAM,MAAM,SAAS,aAAa,WAAW,IAAI;AAEjD,QAAM,KAAK,MAAM,MAAM,KAAK,WAAW,WAAW,MAAM,MAAM,EAAE,CAAC;;CAGnE,WAAW,WAAuB,MAAmB,KAAa;EAChE,MAAM,EAAE,UAAU,GAAG,SAAS;AAE9B,OAAK,IAAI,KAAK,KAAK;GACjB,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,WAAW;GACX,mBAAmB;GACnB,GAAG;GACH;GACA,GAAI,WAAW,EAAE,UAAU,SAAS,KAAK,UAAU,MAAM,IAAI,EAAE,GAAG,EAAE;GACrE,CAAC;AAEF,OAAK,UAAU,KAAK,OAAO,MAAM,KAAK,WAAW,KAAK,KAAK,OAAO,EAAE,CAAC;AAErE,gBAAc,OACV,KAAK,UAAU,KAAK,KAAK,IAAI,GAC7B,KAAK,YAAY,WAAW,KAAK,KAAK,IAAI;;CAGhD,UAAU,QAAoB,OAAiB,UAA8B;EAC3E,MAAM,EAAE,WAAW,UAAU,KAAK,gBAAgB,QAAQ,SAAS;EACnE,MAAM,MAAM,SAAS,aAAa,WAAW,IAAI;AAEjD,QAAM,KAAK,MAAM,CAAC,KAAK,KAAK,MAAM,KAAK,SAAS,WAAW,KAAK,MAAM,EAAE,CAAC;;CAG3E,SAAS,WAAuB,KAAU,KAAa;EACrD,MAAM,OAAO,KAAK,IAAI,IAAI;AAG1B,OAAK,YACD,KAAK,iBAAiB,KAAK,WAAW,IAAI,GAC1C,KAAK,eAAe,IAAI;AAG5B,cACI,KAAK,YAAY,WAAW,KAAK,IAAI,GACrC,KAAK,UAAU,KAAK,IAAI"}