@solid2-aria/stately 0.0.0-stage → 0.0.1

package/dist/data/create-tree-data.js

@@ -0,0 +1,364 @@
+/*
+ * Copyright 2020 Adobe. 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 http://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.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-stately/src/data/useTreeData.ts.
+ * Modified for Solid Aria: adapted reactive state, getters, imports, and APIs for Solid 2.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */
+import { getItemKey } from "../utils/get-item-key.js";
+import { createMemo, createSignal, untrack } from "solid-js";
+// src/data/create-tree-data.ts
+/**
+* Manages state for an immutable tree data structure, and provides convenience methods to
+* update the data over time.
+*/
+function createTreeData(options) {
+	const initialItems = createMemo(() => options.initialItems ?? []);
+	const initialSelectedKeys = createMemo(() => options.initialSelectedKeys);
+	const getKey = createMemo(() => options.getKey ?? getItemKey);
+	const getChildren = createMemo(() => options.getChildren ?? ((item) => {
+		const children = "children" in item ? item.children : void 0;
+		return Array.isArray(children) ? children : [];
+	}));
+	const [tree, commitTree] = createSignal(untrack(() => (() => {
+		return buildTree(initialItems(), /* @__PURE__ */ new Map());
+	})()), { ownedWrite: true });
+	let pendingTree = untrack(tree);
+	const setItems = (update) => {
+		pendingTree = typeof update === "function" ? update(pendingTree) : update;
+		commitTree(pendingTree);
+	};
+	const derived1 = createMemo(() => tree());
+	const items = createMemo(() => {
+		return derived1().items;
+	});
+	const [selectedKeys, commitSelectedKeys] = createSignal(untrack(() => {
+		const currentInitialSelectedKeys = initialSelectedKeys();
+		return new Set(currentInitialSelectedKeys);
+	}), { ownedWrite: true });
+	let pendingSelectedKeys = untrack(selectedKeys);
+	const setSelectedKeys = (keys) => {
+		pendingSelectedKeys = keys;
+		commitSelectedKeys(keys);
+	};
+	function buildTree(initialInitialItems, map, parentKey) {
+		let localInitialItems = initialInitialItems;
+		localInitialItems ??= [];
+		return {
+			items: localInitialItems.map((item) => {
+				const currentGetKey = getKey();
+				const currentGetChildren = getChildren();
+				const node = {
+					children: null,
+					key: currentGetKey(item),
+					parentKey: parentKey ?? null,
+					value: item
+				};
+				node.children = buildTree(currentGetChildren(item), map, node.key).items;
+				map.set(node.key, node);
+				return node;
+			}),
+			nodeMap: map
+		};
+	}
+	function updateTree(localInitialItems, key, update, originalMap) {
+		const localItems = localInitialItems;
+		let node = key === null || key === void 0 ? null : originalMap.get(key);
+		if (node === null || node === void 0) return {
+			items: localItems,
+			nodeMap: originalMap
+		};
+		const map = new Map(originalMap);
+		let newNode = update(node);
+		if (newNode === null || newNode === void 0) deleteNode(node, map);
+		else addNode(newNode, map);
+		while (node.parentKey !== null && node.parentKey !== void 0) {
+			const nextParent = map.get(node.parentKey);
+			if (!nextParent) throw new Error(`Missing parent node: ${node.parentKey}`);
+			const copy = {
+				children: null,
+				key: nextParent.key,
+				parentKey: nextParent.parentKey,
+				value: nextParent.value
+			};
+			const previousNode = node;
+			const replacement = newNode;
+			copy.children = nextParent.children?.flatMap((child) => {
+				if (child !== previousNode) return [child];
+				return replacement === null ? [] : [replacement];
+			}) ?? null;
+			map.set(copy.key, copy);
+			newNode = copy;
+			node = nextParent;
+		}
+		const rootNode = node;
+		const rootReplacement = newNode;
+		return {
+			items: localItems.flatMap((item) => {
+				if (item !== rootNode) return [item];
+				return rootReplacement === null ? [] : [rootReplacement];
+			}),
+			nodeMap: map
+		};
+	}
+	function addNode(node, map) {
+		map.set(node.key, node);
+		if (node.children) for (const child of node.children) addNode(child, map);
+	}
+	function deleteNode(node, map) {
+		map.delete(node.key);
+		if (node.children) for (const child of node.children) deleteNode(child, map);
+	}
+	return {
+		append(parentKey, ...values) {
+			const currentItems = pendingTree.items;
+			const currentNodeMap = pendingTree.nodeMap;
+			if (parentKey === null || parentKey === void 0) this.insert(null, currentItems.length, ...values);
+			else {
+				const parentNode = currentNodeMap.get(parentKey);
+				if (!parentNode) return;
+				this.insert(parentKey, parentNode.children?.length ?? 0, ...values);
+			}
+		},
+		getItem(key) {
+			return pendingTree.nodeMap.get(key);
+		},
+		insert(parentKey, index, ...values) {
+			setItems(({ items: localItems, nodeMap: originalMap }) => {
+				const { items: newNodes, nodeMap: newMap } = buildTree(values, new Map(originalMap), parentKey);
+				if (parentKey === null || parentKey === void 0) return {
+					items: [
+						...localItems.slice(0, index),
+						...newNodes,
+						...localItems.slice(index)
+					],
+					nodeMap: newMap
+				};
+				return updateTree(localItems, parentKey, (parentNode) => ({
+					children: [
+						...(parentNode.children ?? []).slice(0, index),
+						...newNodes,
+						...(parentNode.children ?? []).slice(index)
+					],
+					key: parentNode.key,
+					parentKey: parentNode.parentKey,
+					value: parentNode.value
+				}), newMap);
+			});
+		},
+		insertAfter(key, ...values) {
+			const currentNodeMap = pendingTree.nodeMap;
+			const currentItems = pendingTree.items;
+			const node = currentNodeMap.get(key);
+			if (!node) return;
+			const parentNode = node.parentKey === null || node.parentKey === void 0 ? void 0 : currentNodeMap.get(node.parentKey);
+			const index = (parentNode?.children ?? currentItems).indexOf(node);
+			this.insert(parentNode?.key ?? null, index + 1, ...values);
+		},
+		insertBefore(key, ...values) {
+			const currentNodeMap = pendingTree.nodeMap;
+			const currentItems = pendingTree.items;
+			const node = currentNodeMap.get(key);
+			if (!node) return;
+			const parentNode = node.parentKey === null || node.parentKey === void 0 ? void 0 : currentNodeMap.get(node.parentKey);
+			const index = (parentNode?.children ?? currentItems).indexOf(node);
+			this.insert(parentNode?.key ?? null, index, ...values);
+		},
+		get items() {
+			return items();
+		},
+		move(key, toParentKey, index) {
+			setItems(({ items: localItems, nodeMap: originalMap }) => {
+				let current = toParentKey;
+				while (current !== null && current !== void 0) {
+					if (current === key) throw new Error("Cannot move an item to be a child of itself.");
+					current = originalMap.get(current)?.parentKey ?? null;
+				}
+				const node = originalMap.get(key);
+				if (!node) return {
+					items: localItems,
+					nodeMap: originalMap
+				};
+				const { items: newItems, nodeMap: newMap } = updateTree(localItems, key, () => null, originalMap);
+				const movedNode = {
+					...node,
+					parentKey: toParentKey
+				};
+				if (toParentKey === null || toParentKey === void 0) {
+					addNode(movedNode, newMap);
+					return {
+						items: [
+							...newItems.slice(0, index),
+							movedNode,
+							...newItems.slice(index)
+						],
+						nodeMap: newMap
+					};
+				}
+				return updateTree(newItems, toParentKey, (parentNode) => ({
+					children: [
+						...(parentNode.children ?? []).slice(0, index),
+						movedNode,
+						...(parentNode.children ?? []).slice(index)
+					],
+					key: parentNode.key,
+					parentKey: parentNode.parentKey,
+					value: parentNode.value
+				}), newMap);
+			});
+		},
+		moveAfter(key, keys) {
+			setItems((prevState) => {
+				const { items: localItems, nodeMap } = prevState;
+				const node = nodeMap.get(key);
+				if (!node) return prevState;
+				const toParentKey = node.parentKey ?? null;
+				let parent = null;
+				if (toParentKey !== null && toParentKey !== void 0) parent = nodeMap.get(toParentKey) ?? null;
+				let toIndex = parent?.children ? parent.children.indexOf(node) : localItems.indexOf(node);
+				toIndex += 1;
+				return moveItems(prevState, keys, parent, toIndex, updateTree, addNode);
+			});
+		},
+		moveBefore(key, keys) {
+			setItems((prevState) => {
+				const { items: localItems, nodeMap } = prevState;
+				const node = nodeMap.get(key);
+				if (!node) return prevState;
+				const toParentKey = node.parentKey ?? null;
+				let parent = null;
+				if (toParentKey !== null && toParentKey !== void 0) parent = nodeMap.get(toParentKey) ?? null;
+				const toIndex = parent?.children ? parent.children.indexOf(node) : localItems.indexOf(node);
+				return moveItems(prevState, keys, parent, toIndex, updateTree, addNode);
+			});
+		},
+		prepend(parentKey, ...values) {
+			this.insert(parentKey, 0, ...values);
+		},
+		remove(...keys) {
+			const currentItems = pendingTree.items;
+			const currentNodeMap = pendingTree.nodeMap;
+			const currentSelectedKeys = pendingSelectedKeys;
+			if (keys.length === 0) return;
+			let newItems = currentItems;
+			let prevMap = currentNodeMap;
+			let newTree = {
+				items: newItems,
+				nodeMap: prevMap
+			};
+			for (const key of keys) {
+				newTree = updateTree(newItems, key, () => null, prevMap);
+				prevMap = newTree.nodeMap;
+				newItems = newTree.items;
+			}
+			setItems(newTree);
+			const selection = new Set(currentSelectedKeys);
+			for (const key of currentSelectedKeys) if (!newTree.nodeMap.has(key)) selection.delete(key);
+			setSelectedKeys(selection);
+		},
+		removeSelectedItems() {
+			const currentSelectedKeys = pendingSelectedKeys;
+			this.remove(...currentSelectedKeys);
+		},
+		get selectedKeys() {
+			return selectedKeys();
+		},
+		setSelectedKeys,
+		update(oldKey, newValue) {
+			setItems(({ items: localItems, nodeMap: originalMap }) => updateTree(localItems, oldKey, (oldNode) => {
+				const currentGetChildren = getChildren();
+				const node = {
+					children: null,
+					key: oldNode.key,
+					parentKey: oldNode.parentKey,
+					value: newValue
+				};
+				node.children = buildTree(currentGetChildren(newValue), originalMap, node.key).items;
+				return node;
+			}, originalMap));
+		}
+	};
+}
+function moveItems(state, keys, toParent, initialToIndex, updateTree, addNode) {
+	let toIndex = initialToIndex;
+	const { items, nodeMap } = state;
+	let parent = toParent;
+	const removeKeys = new Set(keys);
+	while (parent !== null && parent !== void 0) {
+		if (removeKeys.has(parent.key)) throw new Error("Cannot move an item to be a child of itself.");
+		parent = parent.parentKey === null || parent.parentKey === void 0 ? null : nodeMap.get(parent.parentKey) ?? null;
+	}
+	const originalToIndex = toIndex;
+	const keyArray = new Set(keys);
+	const inOrderKeys = /* @__PURE__ */ new Map();
+	const removedItems = [];
+	let newItems = items;
+	let newMap = nodeMap;
+	let i = 0;
+	function traversal(node, { inorder: localInorder, postorder: localPostorder }) {
+		if (node === null || "key" in node) localInorder?.(node);
+		if (node !== null && node !== void 0) for (const child of node.children ?? []) {
+			traversal(child, {
+				inorder: localInorder,
+				postorder: localPostorder
+			});
+			localPostorder?.(child);
+		}
+	}
+	function inorder(child) {
+		if (child && keyArray.has(child.key)) {
+			inOrderKeys.set(child.key, i);
+			i += 1;
+		}
+	}
+	function postorder(child) {
+		if (Boolean(child) && keyArray.has(child.key)) {
+			removedItems.push({
+				...newMap.get(child.key) ?? child,
+				parentKey: toParent?.key ?? null
+			});
+			const { items: nextItems, nodeMap: nextMap } = updateTree(newItems, child.key, () => null, newMap);
+			newItems = nextItems;
+			newMap = nextMap;
+		}
+		if ((child.parentKey === toParent || child.parentKey === toParent?.key) && keyArray.has(child.key) && (toParent?.children ? toParent.children.indexOf(child) : items.indexOf(child)) < originalToIndex) toIndex -= 1;
+	}
+	traversal({ children: items }, {
+		inorder,
+		postorder
+	});
+	const inOrderItems = removedItems.toSorted((a, b) => (inOrderKeys.get(a.key) ?? 0) > (inOrderKeys.get(b.key) ?? 0) ? 1 : -1);
+	if (!toParent || toParent.key === null || toParent.key === void 0) {
+		for (const movedNode of inOrderItems) addNode(movedNode, newMap);
+		return {
+			items: [
+				...newItems.slice(0, toIndex),
+				...inOrderItems,
+				...newItems.slice(toIndex)
+			],
+			nodeMap: newMap
+		};
+	}
+	return updateTree(newItems, toParent.key, (parentNode) => ({
+		children: [
+			...(parentNode.children ?? []).slice(0, toIndex),
+			...inOrderItems,
+			...(parentNode.children ?? []).slice(toIndex)
+		],
+		key: parentNode.key,
+		parentKey: parentNode.parentKey,
+		value: parentNode.value
+	}), newMap);
+}
+export { createTreeData };
+
+//# sourceMappingURL=create-tree-data.js.map

package/dist/data/create-tree-data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-tree-data.js","names":[],"sources":["../../src/data/create-tree-data.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. 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 http://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/*\n * Derived from Adobe React Spectrum: packages/react-stately/src/data/useTreeData.ts.\n * Modified for Solid Aria: adapted reactive state, getters, imports, and APIs for Solid 2.\n * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.\n */\n\nimport type { Key } from \"@solid2-aria/types-shared\";\nimport { createMemo, createSignal, untrack } from \"solid-js\";\n\nimport { getItemKey } from \"../utils/get-item-key\";\n\nexport interface TreeOptions<T extends object> {\n  /** Initial root items in the tree. */\n  initialItems?: T[];\n  /** The keys for the initially selected items. */\n  initialSelectedKeys?: Iterable<Key>;\n  /** A function that returns a unique key for an item object. */\n  getKey?: (item: T) => Key;\n  /** A function that returns the children for an item object. */\n  getChildren?: (item: T) => T[];\n}\n\ninterface TreeNode<T extends object> {\n  /** A unique key for the tree node. */\n  key: Key;\n  /** The key of the parent node. */\n  parentKey?: Key | null;\n  /** The value object for the tree node. */\n  value: T;\n  /** Children of the tree node. */\n  children: TreeNode<T>[] | null;\n}\n\nexport interface TreeData<T extends object> {\n  /** The root nodes in the tree. */\n  items: TreeNode<T>[];\n  /** The keys of the currently selected items in the tree. */\n  selectedKeys: Set<Key>;\n  /** Sets the selected keys. */\n  setSelectedKeys: (keys: Set<Key>) => void;\n  /**\n   * Gets a node from the tree by key.\n   *\n   * @param key - The key of the item to retrieve.\n   */\n  getItem: (key: Key) => TreeNode<T> | undefined;\n  /**\n   * Inserts an item into a parent node as a child.\n   *\n   * @param parentKey - The key of the parent item to insert into. `null` for the root.\n   * @param index - The index within the parent to insert into.\n   * @param value - The value to insert.\n   */\n  insert: (parentKey: Key | null, index: number, ...values: T[]) => void;\n  /**\n   * Inserts items into the list before the item at the given key.\n   *\n   * @param key - The key of the item to insert before.\n   * @param values - The values to insert.\n   */\n  insertBefore: (key: Key, ...values: T[]) => void;\n  /**\n   * Inserts items into the list after the item at the given key.\n   *\n   * @param key - The key of the item to insert after.\n   * @param values - The values to insert.\n   */\n  insertAfter: (key: Key, ...values: T[]) => void;\n  /**\n   * Appends an item into a parent node as a child.\n   *\n   * @param parentKey - The key of the parent item to insert into. `null` for the root.\n   * @param value - The value to insert.\n   */\n  append: (parentKey: Key | null, ...values: T[]) => void;\n  /**\n   * Prepends an item into a parent node as a child.\n   *\n   * @param parentKey - The key of the parent item to insert into. `null` for the root.\n   * @param value - The value to insert.\n   */\n  prepend: (parentKey: Key | null, ...value: T[]) => void;\n  /**\n   * Removes an item from the tree by its key.\n   *\n   * @param key - The key of the item to remove.\n   */\n  remove: (...keys: Key[]) => void;\n  /**\n   * Removes all items from the tree that are currently\n   * in the set of selected items.\n   */\n  removeSelectedItems: () => void;\n  /**\n   * Moves an item within the tree.\n   *\n   * @param key - The key of the item to move.\n   * @param toParentKey - The key of the new parent to insert into. `null` for the root.\n   * @param index - The index within the new parent to insert at.\n   */\n  move: (key: Key, toParentKey: Key | null, index: number) => void;\n  /**\n   * Moves one or more items before a given key.\n   *\n   * @param key - The key of the item to move the items before.\n   * @param keys - The keys of the items to move.\n   */\n  moveBefore: (key: Key, keys: Iterable<Key>) => void;\n  /**\n   * Moves one or more items after a given key.\n   *\n   * @param key - The key of the item to move the items after.\n   * @param keys - The keys of the items to move.\n   */\n  moveAfter: (key: Key, keys: Iterable<Key>) => void;\n  /**\n   * Updates an item in the tree.\n   *\n   * @param key - The key of the item to update.\n   * @param newValue - The new value for the item.\n   */\n  update: (key: Key, newValue: T) => void;\n}\n\ninterface TreeDataState<T extends object> {\n  items: TreeNode<T>[];\n  nodeMap: Map<Key, TreeNode<T>>;\n}\n\n/**\n * Manages state for an immutable tree data structure, and provides convenience methods to\n * update the data over time.\n */\nexport function createTreeData<T extends object>(\n  options: TreeOptions<T>\n): TreeData<T> {\n  const initialItems = createMemo(() => options.initialItems ?? []);\n  const initialSelectedKeys = createMemo(() => options.initialSelectedKeys);\n  const getKey = createMemo(() => options.getKey ?? getItemKey);\n\n  const getChildren = createMemo(\n    () =>\n      options.getChildren ??\n      ((item: T) => {\n        const children = \"children\" in item ? item.children : undefined;\n\n        // SAFETY: without getChildren, TreeOptions uses the conventional recursive children: T[] shape.\n        // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n        return Array.isArray(children) ? (children as T[]) : [];\n      })\n  );\n\n  // We only want to compute this on initial render.\n  const [tree, commitTree] = createSignal<TreeDataState<T>>(\n    untrack(() =>\n      (() => {\n        const currentInitialItems = initialItems();\n\n        return buildTree(currentInitialItems, new Map());\n      })()\n    ),\n    { ownedWrite: true }\n  );\n\n  let pendingTree = untrack(tree);\n\n  const setItems = (\n    update: TreeDataState<T> | ((state: TreeDataState<T>) => TreeDataState<T>)\n  ) => {\n    pendingTree = typeof update === \"function\" ? update(pendingTree) : update;\n    commitTree(pendingTree);\n  };\n\n  const derived1 = createMemo(() => tree());\n\n  const items = createMemo(() => {\n    const currentDerived1 = derived1();\n\n    return currentDerived1.items;\n  });\n\n  const [selectedKeys, commitSelectedKeys] = createSignal(\n    untrack(() => {\n      const currentInitialSelectedKeys = initialSelectedKeys();\n\n      return new Set<Key>(currentInitialSelectedKeys);\n    }),\n    { ownedWrite: true }\n  );\n\n  let pendingSelectedKeys = untrack(selectedKeys);\n\n  const setSelectedKeys = (keys: Set<Key>) => {\n    pendingSelectedKeys = keys;\n    commitSelectedKeys(keys);\n  };\n\n  function buildTree(\n    initialInitialItems: T[] | null | undefined,\n    map: Map<Key, TreeNode<T>>,\n    parentKey?: Key | null\n  ) {\n    let localInitialItems = initialInitialItems;\n\n    localInitialItems ??= [];\n\n    return {\n      items: localInitialItems.map((item) => {\n        const currentGetKey = getKey();\n        const currentGetChildren = getChildren();\n\n        const node: TreeNode<T> = {\n          children: null,\n          key: currentGetKey(item),\n          parentKey: parentKey ?? null,\n          value: item,\n        };\n\n        node.children = buildTree(\n          currentGetChildren(item),\n          map,\n          node.key\n        ).items;\n        map.set(node.key, node);\n\n        return node;\n      }),\n      nodeMap: map,\n    };\n  }\n\n  function updateTree(\n    localInitialItems: TreeNode<T>[],\n    key: Key | null,\n    update: (node: TreeNode<T>) => TreeNode<T> | null,\n    originalMap: Map<Key, TreeNode<T>>\n  ) {\n    const localItems = localInitialItems;\n\n    let node = key === null || key === undefined ? null : originalMap.get(key);\n\n    if (node === null || node === undefined) {\n      return { items: localItems, nodeMap: originalMap };\n    }\n\n    const map = new Map<Key, TreeNode<T>>(originalMap);\n    // Create a new node. If null, then delete the node, otherwise replace.\n    let newNode = update(node);\n\n    if (newNode === null || newNode === undefined) {\n      deleteNode(node, map);\n    } else {\n      addNode(newNode, map);\n    }\n\n    // Walk up the tree and update each parent to refer to the new children.\n    while (node.parentKey !== null && node.parentKey !== undefined) {\n      const nextParent = map.get(node.parentKey);\n\n      if (!nextParent) {\n        throw new Error(`Missing parent node: ${node.parentKey}`);\n      }\n\n      const copy: TreeNode<T> = {\n        children: null,\n        key: nextParent.key,\n        parentKey: nextParent.parentKey,\n        value: nextParent.value,\n      };\n\n      const previousNode = node;\n      const replacement = newNode;\n      copy.children =\n        nextParent.children?.flatMap((child) => {\n          if (child !== previousNode) {\n            return [child];\n          }\n\n          return replacement === null ? [] : [replacement];\n        }) ?? null;\n      map.set(copy.key, copy);\n      newNode = copy;\n      node = nextParent;\n    }\n\n    const rootNode = node;\n    const rootReplacement = newNode;\n\n    return {\n      items: localItems.flatMap((item) => {\n        if (item !== rootNode) {\n          return [item];\n        }\n\n        return rootReplacement === null ? [] : [rootReplacement];\n      }),\n      nodeMap: map,\n    };\n  }\n\n  function addNode(node: TreeNode<T>, map: Map<Key, TreeNode<T>>) {\n    map.set(node.key, node);\n\n    if (node.children) {\n      for (const child of node.children) {\n        addNode(child, map);\n      }\n    }\n  }\n\n  function deleteNode(node: TreeNode<T>, map: Map<Key, TreeNode<T>>) {\n    map.delete(node.key);\n\n    if (node.children) {\n      for (const child of node.children) {\n        deleteNode(child, map);\n      }\n    }\n  }\n\n  return {\n    append(parentKey: Key | null, ...values: T[]) {\n      const currentItems = pendingTree.items;\n      const currentNodeMap = pendingTree.nodeMap;\n\n      if (parentKey === null || parentKey === undefined) {\n        this.insert(null, currentItems.length, ...values);\n      } else {\n        const parentNode = currentNodeMap.get(parentKey);\n\n        if (!parentNode) {\n          return;\n        }\n\n        this.insert(parentKey, parentNode.children?.length ?? 0, ...values);\n      }\n    },\n    getItem(key: Key) {\n      const currentNodeMap = pendingTree.nodeMap;\n\n      return currentNodeMap.get(key);\n    },\n    insert(parentKey: Key | null, index: number, ...values: T[]) {\n      setItems(({ items: localItems, nodeMap: originalMap }) => {\n        const { items: newNodes, nodeMap: newMap } = buildTree(\n          values,\n          new Map(originalMap),\n          parentKey\n        );\n\n        // If parentKey is null, insert into the root.\n        if (parentKey === null || parentKey === undefined) {\n          return {\n            items: [\n              ...localItems.slice(0, index),\n              ...newNodes,\n              ...localItems.slice(index),\n            ],\n            nodeMap: newMap,\n          };\n        }\n\n        // Otherwise, update the parent node and its ancestors.\n        return updateTree(\n          localItems,\n          parentKey,\n          (parentNode) => ({\n            children: [\n              ...(parentNode.children ?? []).slice(0, index),\n              ...newNodes,\n              ...(parentNode.children ?? []).slice(index),\n            ],\n            key: parentNode.key,\n            parentKey: parentNode.parentKey,\n            value: parentNode.value,\n          }),\n          newMap\n        );\n      });\n    },\n    insertAfter(key: Key, ...values: T[]): void {\n      const currentNodeMap = pendingTree.nodeMap;\n      const currentItems = pendingTree.items;\n      const node = currentNodeMap.get(key);\n\n      if (!node) {\n        return;\n      }\n\n      const parentNode =\n        node.parentKey === null || node.parentKey === undefined\n          ? undefined\n          : currentNodeMap.get(node.parentKey);\n\n      const nodes = parentNode?.children ?? currentItems;\n      const index = nodes.indexOf(node);\n      this.insert(parentNode?.key ?? null, index + 1, ...values);\n    },\n    insertBefore(key: Key, ...values: T[]): void {\n      const currentNodeMap = pendingTree.nodeMap;\n      const currentItems = pendingTree.items;\n      const node = currentNodeMap.get(key);\n\n      if (!node) {\n        return;\n      }\n\n      const parentNode =\n        node.parentKey === null || node.parentKey === undefined\n          ? undefined\n          : currentNodeMap.get(node.parentKey);\n\n      const nodes = parentNode?.children ?? currentItems;\n      const index = nodes.indexOf(node);\n      this.insert(parentNode?.key ?? null, index, ...values);\n    },\n    get items() {\n      return items();\n    },\n    move(key: Key, toParentKey: Key | null, index: number) {\n      setItems(({ items: localItems, nodeMap: originalMap }) => {\n        let current = toParentKey;\n\n        while (current !== null && current !== undefined) {\n          if (current === key) {\n            throw new Error(\"Cannot move an item to be a child of itself.\");\n          }\n\n          current = originalMap.get(current)?.parentKey ?? null;\n        }\n\n        const node = originalMap.get(key);\n\n        if (!node) {\n          return { items: localItems, nodeMap: originalMap };\n        }\n\n        const { items: newItems, nodeMap: newMap } = updateTree(\n          localItems,\n          key,\n          () => null,\n          originalMap\n        );\n\n        const movedNode = {\n          ...node,\n          parentKey: toParentKey,\n        };\n\n        // If parentKey is null, insert into the root.\n        if (toParentKey === null || toParentKey === undefined) {\n          addNode(movedNode, newMap);\n\n          return {\n            items: [\n              ...newItems.slice(0, index),\n              movedNode,\n              ...newItems.slice(index),\n            ],\n            nodeMap: newMap,\n          };\n        }\n\n        // Otherwise, update the parent node and its ancestors.\n        return updateTree(\n          newItems,\n          toParentKey,\n          (parentNode) => ({\n            children: [\n              ...(parentNode.children ?? []).slice(0, index),\n              movedNode,\n              ...(parentNode.children ?? []).slice(index),\n            ],\n            key: parentNode.key,\n            parentKey: parentNode.parentKey,\n            value: parentNode.value,\n          }),\n          newMap\n        );\n      });\n    },\n    moveAfter(key: Key, keys: Iterable<Key>) {\n      setItems((prevState) => {\n        const { items: localItems, nodeMap } = prevState;\n        const node = nodeMap.get(key);\n\n        if (!node) {\n          return prevState;\n        }\n\n        const toParentKey = node.parentKey ?? null;\n        let parent: null | TreeNode<T> = null;\n\n        if (toParentKey !== null && toParentKey !== undefined) {\n          parent = nodeMap.get(toParentKey) ?? null;\n        }\n\n        let toIndex = parent?.children\n          ? parent.children.indexOf(node)\n          : localItems.indexOf(node);\n\n        toIndex += 1;\n\n        return moveItems(prevState, keys, parent, toIndex, updateTree, addNode);\n      });\n    },\n    moveBefore(key: Key, keys: Iterable<Key>) {\n      setItems((prevState) => {\n        const { items: localItems, nodeMap } = prevState;\n        const node = nodeMap.get(key);\n\n        if (!node) {\n          return prevState;\n        }\n\n        const toParentKey = node.parentKey ?? null;\n        let parent: null | TreeNode<T> = null;\n\n        if (toParentKey !== null && toParentKey !== undefined) {\n          parent = nodeMap.get(toParentKey) ?? null;\n        }\n\n        const toIndex = parent?.children\n          ? parent.children.indexOf(node)\n          : localItems.indexOf(node);\n\n        return moveItems(prevState, keys, parent, toIndex, updateTree, addNode);\n      });\n    },\n    prepend(parentKey: Key | null, ...values: T[]) {\n      this.insert(parentKey, 0, ...values);\n    },\n    remove(...keys: Key[]) {\n      const currentItems = pendingTree.items;\n      const currentNodeMap = pendingTree.nodeMap;\n      const currentSelectedKeys = pendingSelectedKeys;\n\n      if (keys.length === 0) {\n        return;\n      }\n\n      let newItems = currentItems;\n      let prevMap = currentNodeMap;\n      let newTree: TreeDataState<T> = { items: newItems, nodeMap: prevMap };\n\n      for (const key of keys) {\n        newTree = updateTree(newItems, key, () => null, prevMap);\n        prevMap = newTree.nodeMap;\n        newItems = newTree.items;\n      }\n\n      setItems(newTree);\n      const selection = new Set(currentSelectedKeys);\n\n      for (const key of currentSelectedKeys) {\n        if (!newTree.nodeMap.has(key)) {\n          selection.delete(key);\n        }\n      }\n\n      setSelectedKeys(selection);\n    },\n    removeSelectedItems() {\n      const currentSelectedKeys = pendingSelectedKeys;\n      this.remove(...currentSelectedKeys);\n    },\n    get selectedKeys() {\n      return selectedKeys();\n    },\n    setSelectedKeys,\n    update(oldKey: Key, newValue: T) {\n      setItems(({ items: localItems, nodeMap: originalMap }) =>\n        updateTree(\n          localItems,\n          oldKey,\n          (oldNode) => {\n            const currentGetChildren = getChildren();\n\n            const node: TreeNode<T> = {\n              children: null,\n              key: oldNode.key,\n              parentKey: oldNode.parentKey,\n              value: newValue,\n            };\n\n            const localTree = buildTree(\n              currentGetChildren(newValue),\n              originalMap,\n              node.key\n            );\n\n            node.children = localTree.items;\n\n            return node;\n          },\n          originalMap\n        )\n      );\n    },\n  };\n}\n\nfunction moveItems<T extends object>(\n  state: TreeDataState<T>,\n  keys: Iterable<Key>,\n  toParent: TreeNode<T> | null,\n  initialToIndex: number,\n  updateTree: (\n    items: TreeNode<T>[],\n    key: Key | null,\n    update: (node: TreeNode<T>) => TreeNode<T> | null,\n    originalMap: Map<Key, TreeNode<T>>\n  ) => TreeDataState<T>,\n  addNode: (node: TreeNode<T>, map: Map<Key, TreeNode<T>>) => void\n): TreeDataState<T> {\n  let toIndex = initialToIndex;\n\n  const { items, nodeMap } = state;\n  let parent = toParent;\n  const removeKeys = new Set(keys);\n\n  while (parent !== null && parent !== undefined) {\n    if (removeKeys.has(parent.key)) {\n      throw new Error(\"Cannot move an item to be a child of itself.\");\n    }\n\n    parent =\n      parent.parentKey === null || parent.parentKey === undefined\n        ? null\n        : (nodeMap.get(parent.parentKey) ?? null);\n  }\n\n  const originalToIndex = toIndex;\n  const keyArray = new Set(keys);\n  // depth first search to put keys in order\n  const inOrderKeys = new Map<Key, number>();\n  const removedItems: TreeNode<T>[] = [];\n  let newItems = items;\n  let newMap = nodeMap;\n  let i = 0;\n\n  function traversal(\n    node:\n      | TreeNode<T>\n      | {\n          children: TreeNode<T>[];\n        }\n      | null,\n    {\n      inorder: localInorder,\n      postorder: localPostorder,\n    }: {\n      inorder?: (node: TreeNode<T> | null) => void;\n      postorder?: (node: TreeNode<T>) => void;\n    }\n  ) {\n    if (node === null || \"key\" in node) {\n      localInorder?.(node);\n    }\n\n    if (node !== null && node !== undefined) {\n      for (const child of node.children ?? []) {\n        traversal(child, { inorder: localInorder, postorder: localPostorder });\n        localPostorder?.(child);\n      }\n    }\n  }\n\n  function inorder(child: TreeNode<T> | null) {\n    // in-order so we add items as we encounter them in the tree, then we can insert them in expected order later\n    if (child && keyArray.has(child.key)) {\n      inOrderKeys.set(child.key, i);\n      i += 1;\n    }\n  }\n\n  function postorder(child: TreeNode<T>) {\n    // remove items and update the tree from the leaves and work upwards toward the root, this way\n    // we don't copy child node references from parents inadvertently\n    if (Boolean(child) && keyArray.has(child.key)) {\n      removedItems.push({\n        ...(newMap.get(child.key) ?? child),\n        parentKey: toParent?.key ?? null,\n      });\n\n      const { items: nextItems, nodeMap: nextMap } = updateTree(\n        newItems,\n        child.key,\n        () => null,\n        newMap\n      );\n\n      newItems = nextItems;\n      newMap = nextMap;\n    }\n\n    // decrement the index if the child being removed is in the target parent and before the target index\n    // the root node is special, it is null, and will not have a key, however, a parentKey can still point to it\n    if (\n      (child.parentKey === toParent || child.parentKey === toParent?.key) &&\n      keyArray.has(child.key) &&\n      (toParent?.children\n        ? toParent.children.indexOf(child)\n        : items.indexOf(child)) < originalToIndex\n    ) {\n      toIndex -= 1;\n    }\n  }\n\n  traversal({ children: items }, { inorder, postorder });\n\n  const inOrderItems = removedItems.toSorted((a, b) =>\n    (inOrderKeys.get(a.key) ?? 0) > (inOrderKeys.get(b.key) ?? 0) ? 1 : -1\n  );\n\n  // If parentKey is null, insert into the root.\n  if (!toParent || toParent.key === null || toParent.key === undefined) {\n    for (const movedNode of inOrderItems) {\n      addNode(movedNode, newMap);\n    }\n\n    return {\n      items: [\n        ...newItems.slice(0, toIndex),\n        ...inOrderItems,\n        ...newItems.slice(toIndex),\n      ],\n      nodeMap: newMap,\n    };\n  }\n\n  // Otherwise, update the parent node and its ancestors.\n  return updateTree(\n    newItems,\n    toParent.key,\n    (parentNode) => ({\n      children: [\n        ...(parentNode.children ?? []).slice(0, toIndex),\n        ...inOrderItems,\n        ...(parentNode.children ?? []).slice(toIndex),\n      ],\n      key: parentNode.key,\n      parentKey: parentNode.parentKey,\n      value: parentNode.value,\n    }),\n    newMap\n  );\n}\n"],"mappings":"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"}

package/dist/datepicker/create-date-field-state.d.ts

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2020 Adobe. 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 http://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.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-stately/src/datepicker/useDateFieldState.ts.
+ * Modified for Solid Aria: adapted reactive state, getters, imports, and APIs for Solid 2.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */
+import { FormValidationState } from "../form/create-form-validation-state.js";
+import { DatePickerProps, DateValue, Granularity } from "./types.js";
+import { FieldOptions, FormatterOptions } from "./utils.js";
+import { Calendar, CalendarIdentifier, DateFormatter } from "@internationalized/date";
+import { ValidationState } from "@solid2-aria/types-shared";
+export type DateSegmentType = "era" | "year" | "month" | "day" | "hour" | "minute" | "second" | "dayPeriod" | "literal" | "timeZoneName";
+export interface DateSegment {
+  /** The type of segment. */
+  type: DateSegmentType;
+  /** The formatted text for the segment. */
+  text: string;
+  /** The numeric value for the segment, if applicable. */
+  value?: number | null;
+  /** The minimum numeric value for the segment, if applicable. */
+  minValue?: number;
+  /** The maximum numeric value for the segment, if applicable. */
+  maxValue?: number;
+  /** Whether the value is a placeholder. */
+  isPlaceholder: boolean;
+  /** A placeholder string for the segment. */
+  placeholder: string;
+  /** Whether the segment is editable. */
+  isEditable: boolean;
+}
+export interface DateFieldState extends FormValidationState {
+  /** The current field value. */
+  value: DateValue | null;
+  /** The default field value. */
+  defaultValue: DateValue | null;
+  /** The current value, converted to a native JavaScript `Date` object. */
+  dateValue: Date;
+  /** The calendar system currently in use. */
+  calendar: Calendar;
+  /** Sets the field's value. */
+  setValue: (value: DateValue | null) => void;
+  /** A list of segments for the current value. */
+  segments: DateSegment[];
+  /** A date formatter configured for the current locale and format. */
+  dateFormatter: DateFormatter;
+  /**
+   * The current validation state of the date field, based on the `validationState`, `minValue`, and
+   * `maxValue` props.
+   *
+   * @deprecated Use `isInvalid` instead.
+   */
+  validationState: ValidationState | null;
+  /** Whether the date field is invalid, based on the `isInvalid`, `minValue`, and `maxValue` props. */
+  isInvalid: boolean;
+  /** The granularity for the field, based on the `granularity` prop and current value. */
+  granularity: Granularity;
+  /** The maximum date or time unit that is displayed in the field. */
+  maxGranularity: "year" | "month" | Granularity;
+  /** Whether the field is disabled. */
+  isDisabled: boolean;
+  /** Whether the field is read only. */
+  isReadOnly: boolean;
+  /** Whether the field is required. */
+  isRequired: boolean;
+  /**
+   * Increments the given segment. Upon reaching the minimum or maximum value, the value wraps
+   * around to the opposite limit.
+   */
+  increment: (type: DateSegmentType) => void;
+  /**
+   * Decrements the given segment. Upon reaching the minimum or maximum value, the value wraps
+   * around to the opposite limit.
+   */
+  decrement: (type: DateSegmentType) => void;
+  /**
+   * Increments the given segment by a larger amount, rounding it to the nearest increment.
+   * The amount to increment by depends on the field, for example 15 minutes, 7 days, and 5 years.
+   * Upon reaching the minimum or maximum value, the value wraps around to the opposite limit.
+   */
+  incrementPage: (type: DateSegmentType) => void;
+  /**
+   * Decrements the given segment by a larger amount, rounding it to the nearest increment.
+   * The amount to decrement by depends on the field, for example 15 minutes, 7 days, and 5 years.
+   * Upon reaching the minimum or maximum value, the value wraps around to the opposite limit.
+   */
+  decrementPage: (type: DateSegmentType) => void;
+  /** Increments the given segment to its maxiumum value. */
+  incrementToMax: (type: DateSegmentType) => void;
+  /** Decrements the given segment to its minimum value. */
+  decrementToMin: (type: DateSegmentType) => void;
+  /** Sets the value of the given segment. */
+  setSegment: {
+    (type: "era", value: string): void;
+    (type: DateSegmentType, value: number): void;
+  };
+  /** Updates the remaining unfilled segments with the placeholder value. */
+  confirmPlaceholder: () => void;
+  /** Clears the value of the given segment, reverting it to the placeholder. */
+  clearSegment: (type: DateSegmentType) => void;
+  /** Formats the current date value using the given options. */
+  formatValue: (fieldOptions: FieldOptions) => string;
+  /** Gets a formatter based on state's props. */
+  getDateFormatter: (locale: string, formatOptions: FormatterOptions) => DateFormatter;
+}
+export interface DateFieldStateOptions<T extends DateValue = DateValue> extends DatePickerProps<T> {
+  /**
+   * The maximum unit to display in the date field.
+   *
+   * @default 'year'
+   */
+  maxGranularity?: "year" | "month" | Granularity;
+  /** The locale to display and edit the value according to. */
+  locale: string;
+  /**
+   * A function that creates a [Calendar](../internationalized/date/Calendar.html)
+   * object for a given calendar identifier. Such a function may be imported from the
+   * `@internationalized/date` package, or manually implemented to include support for
+   * only certain calendars.
+   */
+  createCalendar: (name: CalendarIdentifier) => Calendar;
+}
+/**
+ * Provides state management for a date field component.
+ * A date field allows users to enter and edit date and time values using a keyboard.
+ * Each part of a date value is displayed in an individually editable segment.
+ */
+export declare function createDateFieldState<T extends DateValue = DateValue>(props: DateFieldStateOptions<T>): DateFieldState;
+//# sourceMappingURL=create-date-field-state.d.ts.map