dawn-ui-react 1.0.0-alpha.1 → 1.0.0-alpha.3

package/dist/components/layer-tree/layer-tree-utils.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Base constraint for tree node data types used by layer tree utilities.
+ */
+export type LayerTreeNodeData = {
+    id: string;
+    children?: LayerTreeNodeData[];
+};
+/**
+ * Recursively searches for a node by ID in a nested tree structure.
+ *
+ * @param nodes - The array of nodes to search through
+ * @param nodeId - The ID of the node to find
+ * @returns The matching node or `null` if not found
+ *
+ * @example
+ * ```ts
+ * const node = findLayerTreeNode(layers, 'layer-001')
+ * if (node) console.log(node.name)
+ * ```
+ */
+export declare const findLayerTreeNode: <TData extends LayerTreeNodeData>(nodes: TData[], nodeId: string) => TData | null;
+/**
+ * Removes a node from a nested tree structure by ID.
+ *
+ * @param nodes - The array of nodes to remove from
+ * @param nodeId - The ID of the node to remove
+ * @returns An object containing the updated tree and the removed node (if found)
+ *
+ * @example
+ * ```ts
+ * const { nextNodes, removedNode } = removeLayerTreeNode(layers, 'layer-001')
+ * if (removedNode) setLayers(nextNodes)
+ * ```
+ */
+export declare const removeLayerTreeNode: <TData extends LayerTreeNodeData>(nodes: TData[], nodeId: string) => {
+    nextNodes: TData[];
+    removedNode: TData | null;
+};
+/**
+ * Inserts a node as a child of the specified folder node.
+ *
+ * @param nodes - The array of nodes to search through
+ * @param folderId - The ID of the folder to insert into
+ * @param nodeToInsert - The node to insert
+ * @returns A new tree with the node inserted
+ *
+ * @example
+ * ```ts
+ * const newTree = insertLayerTreeNode(layers, 'folder-001', newLayer)
+ * setLayers(newTree)
+ * ```
+ */
+export declare const insertLayerTreeNode: <TData extends LayerTreeNodeData>(nodes: TData[], folderId: string, nodeToInsert: TData) => TData[];
+/**
+ * Moves a node from its current position into a target folder.
+ * Prevents circular references by checking if target is a descendant of source.
+ *
+ * @param nodes - The array of nodes
+ * @param sourceId - The ID of the node to move
+ * @param targetId - The ID of the folder to move into
+ * @returns A new tree with the node moved, or the original tree if the move is invalid
+ *
+ * @example
+ * ```ts
+ * const newTree = moveLayerTreeNode(layers, 'layer-001', 'folder-002')
+ * setLayers(newTree)
+ * ```
+ */
+export declare const moveLayerTreeNode: <TData extends LayerTreeNodeData>(nodes: TData[], sourceId: string, targetId: string) => TData[];
+/**
+ * Moves a node to the root level of the tree.
+ *
+ * @param nodes - The array of nodes
+ * @param sourceId - The ID of the node to move
+ * @returns A new tree with the node at root level
+ *
+ * @example
+ * ```ts
+ * const newTree = moveLayerTreeNodeToRoot(layers, 'layer-001')
+ * setLayers(newTree)
+ * ```
+ */
+export declare const moveLayerTreeNodeToRoot: <TData extends LayerTreeNodeData>(nodes: TData[], sourceId: string) => TData[];

package/dist/components/layer-tree/layer-tree.d.ts

@@ -1,5 +1,10 @@
-import { LayerTreeProps } from './layer-tree.types';
-type LayerTreeContextType = LayerTreeProps;
-export declare const LayerTree: ({ table, className, children, ref, ...props }: LayerTreeProps) => import("react/jsx-runtime").JSX.Element;
-export declare const useLayerTree: () => LayerTreeContextType;
+import { default as React } from 'react';
+import { LayerTreeDataSet, LayerTreeProps } from './layer-tree.types';
+type LayerTreeContextType<TData> = LayerTreeProps<TData> & {
+    dataSet: LayerTreeDataSet<TData>;
+    setDataSet: React.Dispatch<React.SetStateAction<LayerTreeDataSet<TData>>>;
+    draggingNodeId: string | null;
+};
+export declare const LayerTree: <TData>({ table, dataSet, setDataSet, className, children, ref, ...props }: LayerTreeProps<TData>) => import("react/jsx-runtime").JSX.Element;
+export declare const useLayerTree: <TData>() => LayerTreeContextType<TData>;
 export {};

package/dist/components/layer-tree/layer-tree.types.d.ts

@@ -1,24 +1,31 @@
 import { Button } from '../button';
 import { Row, Table as TanstackTable } from '@tanstack/react-table';
-export type LayerTreeProps<TData = any> = React.ComponentProps<'div'> & {
+export type LayerTreeDataSet<TData> = {
+    data: TData[];
+};
+export type LayerTreeProps<TData> = React.ComponentProps<'div'> & {
     table: TanstackTable<TData>;
+    dataSet?: LayerTreeDataSet<TData>;
+    setDataSet?: React.Dispatch<React.SetStateAction<LayerTreeDataSet<TData>>>;
 };
 export type LayerTreeBodyProps = React.ComponentProps<'div'>;
-export type LayerTreeRowProps<TData = any> = React.ComponentProps<'div'> & {
+export type LayerTreeRowProps<TData> = React.ComponentProps<'div'> & {
     row: Row<TData>;
 };
-export type LayerTreeNodeToggleProps<TData = any> = Omit<React.ComponentProps<typeof Button>, 'value' | 'children'> & {
+export type LayerTreeNodeToggleProps<TData> = Omit<React.ComponentProps<typeof Button>, 'value' | 'children'> & {
     value: boolean;
     columnId: {
         [K in keyof TData]: TData[K] extends boolean ? K : never;
     }[keyof TData];
     rows: Row<TData>[];
-    onToggle: () => void;
     children: (value: boolean) => React.ReactNode;
 };
 export type LayerTreeNodeProps<TData> = React.ComponentProps<'button'> & {
     row: Row<TData>;
     icon?: React.ElementType;
+    dndDisabled?: boolean;
 };
 export type LayerTreeSearchProps = React.ComponentProps<'input'>;
 export type LayerTreeExpandAllProps = React.ComponentProps<'button'>;
+export type LayerTreeNodeActionProps = React.ComponentProps<'button'>;
+export type LayerTreeFooterProps = React.ComponentProps<'div'>;