nuance-ui 0.1.7 → 0.1.8

package/dist/runtime/utils/tree.d.ts

@@ -0,0 +1,88 @@
+/** Represents a tree node with a value and optional children. */
+export interface TreeNode<T extends string = string> {
+    /** The value stored in this tree node */
+    value: string;
+    /** Optional array of child nodes */
+    children?: TreeNode<T>[];
+}
+/**
+ * Searches for a tree item by its value using depth-first search.
+ * @template T - The type of node values
+ * @param {TreeNode<T>[]} items - The array of tree nodes to search in
+ * @param {T} value - The value to search for
+ * @returns {TreeNode<T> | null} The found node or null if not found
+ * @example
+ * const tree = [{ value: 'folder', children: [{ value: 'file' }] }]
+ * findTreeItem(tree, 'file') // { value: 'file' }
+ * findTreeItem(tree, 'missing') // null
+ */
+export declare function findTreeItem<T extends string = string>(items: TreeNode<T>[], value: T): TreeNode<T> | null;
+/**
+ * Flattens a tree structure into a single-level array in depth-first order.
+ * @template T - The type of node values
+ * @param {TreeNode<T>[]} tree - The tree to flatten
+ * @returns {TreeNode<T>[]} Flattened array containing all nodes
+ * @example
+ * const tree = [
+ *   { value: 'root', children: [
+ *     { value: 'child1' },
+ *     { value: 'child2' }
+ *   ]}
+ * ]
+ * flatTree(tree) // [{ value: 'root', ... }, { value: 'child1' }, { value: 'child2' }]
+ */
+export declare function flatTree<T extends string = string>(tree: TreeNode<T>[]): TreeNode<T>[];
+/**
+ * Gets all descendant values of a specific node in the tree.
+ *
+ * @template T - The type of node values
+ * @param {TreeNode<T>[]} tree - The tree to search in
+ * @param {T} value - The value of the parent node
+ * @returns {T[]} Array of all descendant values (empty if node not found or has no children)
+ * @example
+ * const tree = [
+ *   { value: 'folder', children: [
+ *     { value: 'file1' },
+ *     { value: 'subfolder', children: [{ value: 'file2' }] }
+ *   ]}
+ * ]
+ * getBranchChildren(tree, 'folder') // ['file1', 'subfolder', 'file2']
+ * getBranchChildren(tree, 'file1') // []
+ */
+export declare function getBranchChildren<T extends string = string>(tree: TreeNode<T>[], value: T): T[];
+/**
+ * Gets all node values between two specified values (inclusive) in tree traversal order.
+ * If start comes after end in traversal order, the range is automatically reversed.
+ * Uses a single-pass algorithm that flattens and searches simultaneously.
+ * @template T - The type of node values
+ * @param {TreeNode<T>[]} tree - The tree to search in
+ * @param {T} start - The starting value
+ * @param {T} end - The ending value
+ * @returns {T[]} Array of values between start and end (inclusive), empty if either value not found
+ * @example
+ * const tree = [
+ *   { value: 'a', children: [{ value: 'b' }, { value: 'c' }] },
+ *   { value: 'd' }
+ * ]
+ * getItemsBetween(tree, 'b', 'd') // ['b', 'c', 'd']
+ * getItemsBetween(tree, 'd', 'b') // ['b', 'c', 'd'] (auto-reversed)
+ * getItemsBetween(tree, 'a', 'missing') // []
+ */
+export declare function getTreeItemsBetween<T extends string = string>(tree: TreeNode<T>[], start: T, end: T): T[];
+/**
+ * Removes nodes with specified values from the tree, including their subtrees.
+ * Returns a new tree without modifying the original.
+ *
+ * @template T - The type of node values
+ * @param {TreeNode<T>[]} tree - The original tree (array of root nodes)
+ * @param {T[]} valuesToRemove - Array of values to remove
+ * @returns {TreeNode<T>[]} New tree with specified nodes and their subtrees removed
+ * @example
+ * const tree = [
+ *   { value: 'a', children: [{ value: 'b' }, { value: 'c' }] },
+ *   { value: 'd' }
+ * ]
+ * removeTreeNodes(tree, ['b', 'd']) // [{ value: 'a', children: [{ value: 'c' }] }]
+ * removeTreeNodes(tree, ['a']) // [{ value: 'd' }]
+ */
+export declare function removeTreeNodes<Node extends TreeNode = TreeNode, Value extends string = string>(tree: Node[], valuesToRemove: Value[]): Node[];

package/dist/runtime/utils/tree.js

@@ -0,0 +1,85 @@
+function traverse(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    result.push(node);
+    if (node.children?.length)
+      result.push(...traverse(node.children));
+  }
+  return result;
+}
+export function findTreeItem(items, value) {
+  for (const item of items) {
+    if (item.value === value)
+      return item;
+    if (item.children?.length) {
+      const found = findTreeItem(item.children, value);
+      if (found)
+        return found;
+    }
+  }
+  return null;
+}
+export function flatTree(tree) {
+  return traverse(tree);
+}
+export function getBranchChildren(tree, value) {
+  const children = [];
+  function findAndExtract(nodes) {
+    for (const node of nodes) {
+      if (node.value === value) {
+        if (node.children?.length) {
+          const extracted = traverse(node.children);
+          children.push(...extracted.map((i) => i.value));
+        }
+        return true;
+      }
+      if (node.children?.length && findAndExtract(node.children))
+        return true;
+    }
+    return false;
+  }
+  findAndExtract(tree);
+  return children;
+}
+export function getTreeItemsBetween(tree, start, end) {
+  const result = [];
+  let startIdx = -1;
+  let endIdx = -1;
+  let currentIdx = 0;
+  function traverseAndFind(nodes) {
+    for (const node of nodes) {
+      if (node.value === start)
+        startIdx = currentIdx;
+      if (node.value === end)
+        endIdx = currentIdx;
+      result.push(node.value);
+      currentIdx++;
+      if (node.children?.length)
+        traverseAndFind(node.children);
+    }
+  }
+  traverseAndFind(tree);
+  if (startIdx === -1 || endIdx === -1)
+    return [];
+  const [from, to] = startIdx < endIdx ? [startIdx, endIdx] : [endIdx, startIdx];
+  return result.slice(from, to + 1);
+}
+export function removeTreeNodes(tree, valuesToRemove) {
+  const removeSet = new Set(valuesToRemove);
+  function recurse(nodes) {
+    const result = [];
+    for (const node of nodes) {
+      if (removeSet.has(node.value))
+        continue;
+      const newNode = { ...node };
+      if (node.children?.length) {
+        const filteredChildren = recurse(node.children);
+        if (filteredChildren.length > 0)
+          newNode.children = filteredChildren;
+      }
+      result.push(newNode);
+    }
+    return result;
+  }
+  return recurse(tree);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nuance-ui",
-	"version": "0.1.7",
+	"version": "0.1.8",
 	"description": "A UI Library for Modern Web Apps, powered by Vue.",
 	"repository": {
 		"type": "git",

package/dist/runtime/composals/use-mod.d.ts

@@ -1,2 +0,0 @@
-export type Mod = Record<string, any>;
-export declare function useMod(mod: Mod | Mod[] | Mod[][] | null | undefined): Mod | null;