@wirekyt/react 0.0.1 → 0.0.3

package/dist/collapsible.d.ts

@@ -0,0 +1,56 @@
+import { a as PropTypes } from "./index-CxWYgVJk.js";
+import { r as Optional } from "./types-BQQfrr86.js";
+import { r as PolymorphicProps, t as HTMLProps } from "./factory--dkoVnFK.js";
+import { r as RenderStrategyProps } from "./index-srZfUQNt.js";
+import { ReactNode } from "react";
+import * as collapsible from "@wirekyt/dom/machines/collapsible";
+import { OpenChangeDetails, OpenChangeDetails as CollapsibleOpenChangeDetails, anatomy as collapsibleAnatomy } from "@wirekyt/dom/machines/collapsible";
+//#region src/components/collapsible/content.d.ts
+interface CollapsibleContentBaseProps extends PolymorphicProps {}
+interface CollapsibleContentProps extends HTMLProps<"div">, CollapsibleContentBaseProps {}
+declare const CollapsibleContent: import("react").ForwardRefExoticComponent<CollapsibleContentProps & import("react").RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/collapsible/use-collapsible.d.ts
+interface UseCollapsibleProps extends Optional<Omit<collapsible.Props, "dir" | "getRootNode">, "id">, RenderStrategyProps {}
+interface UseCollapsibleReturn extends collapsible.Api<PropTypes> {
+  isUnmounted?: boolean | undefined;
+}
+declare const useCollapsible: (props?: UseCollapsibleProps) => UseCollapsibleReturn;
+//#endregion
+//#region src/components/collapsible/use-context.d.ts
+interface UseCollapsibleContext extends UseCollapsibleReturn {}
+declare const CollapsibleProvider: import("react").Provider<UseCollapsibleContext>, useCollapsibleContext: () => UseCollapsibleContext;
+//#endregion
+//#region src/components/collapsible/context.d.ts
+interface CollapsibleContextProps {
+  children: (context: UseCollapsibleContext) => ReactNode;
+}
+declare const CollapsibleContext: (props: CollapsibleContextProps) => ReactNode;
+//#endregion
+//#region src/components/collapsible/indicator.d.ts
+interface CollapsibleIndicatorBaseProps extends PolymorphicProps {}
+interface CollapsibleIndicatorProps extends HTMLProps<"div">, CollapsibleIndicatorBaseProps {}
+declare const CollapsibleIndicator: import("react").ForwardRefExoticComponent<CollapsibleIndicatorProps & import("react").RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/collapsible/root.d.ts
+interface CollapsibleRootBaseProps extends UseCollapsibleProps, PolymorphicProps {}
+interface CollapsibleRootProps extends HTMLProps<"div">, CollapsibleRootBaseProps {}
+declare const CollapsibleRoot: import("react").ForwardRefExoticComponent<CollapsibleRootProps & import("react").RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/collapsible/root-provider.d.ts
+interface RootProviderProps {
+  value: UseCollapsibleReturn;
+}
+interface CollapsibleRootProviderBaseProps extends RootProviderProps, PolymorphicProps {}
+interface CollapsibleRootProviderProps extends HTMLProps<"div">, CollapsibleRootProviderBaseProps {}
+declare const CollapsibleRootProvider: import("react").ForwardRefExoticComponent<CollapsibleRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/collapsible/trigger.d.ts
+interface CollapsibleTriggerBaseProps extends PolymorphicProps {}
+interface CollapsibleTriggerProps extends HTMLProps<"button">, CollapsibleTriggerBaseProps {}
+declare const CollapsibleTrigger: import("react").ForwardRefExoticComponent<CollapsibleTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+declare namespace collapsible_d_exports {
+  export { CollapsibleContent as Content, CollapsibleContentBaseProps as ContentBaseProps, CollapsibleContentProps as ContentProps, CollapsibleContext as Context, CollapsibleContextProps as ContextProps, CollapsibleIndicator as Indicator, CollapsibleIndicatorBaseProps as IndicatorBaseProps, CollapsibleIndicatorProps as IndicatorProps, OpenChangeDetails, CollapsibleRoot as Root, CollapsibleRootBaseProps as RootBaseProps, CollapsibleRootProps as RootProps, CollapsibleRootProvider as RootProvider, CollapsibleRootProviderBaseProps as RootProviderBaseProps, CollapsibleRootProviderProps as RootProviderProps, CollapsibleTrigger as Trigger, CollapsibleTriggerBaseProps as TriggerBaseProps, CollapsibleTriggerProps as TriggerProps };
+}
+//#endregion
+export { collapsible_d_exports as Collapsible, CollapsibleContent, type CollapsibleContentBaseProps, type CollapsibleContentProps, CollapsibleContext, type CollapsibleContextProps, CollapsibleIndicator, type CollapsibleIndicatorBaseProps, type CollapsibleIndicatorProps, type CollapsibleOpenChangeDetails, CollapsibleRoot, type CollapsibleRootBaseProps, type CollapsibleRootProps, CollapsibleRootProvider, type CollapsibleRootProviderBaseProps, type CollapsibleRootProviderProps, CollapsibleTrigger, type CollapsibleTriggerBaseProps, type CollapsibleTriggerProps, type UseCollapsibleContext, type UseCollapsibleProps, type UseCollapsibleReturn, collapsibleAnatomy, useCollapsible, useCollapsibleContext };

package/dist/collapsible.js

@@ -0,0 +1,2 @@
+import { a as CollapsibleRoot, c as CollapsibleContext, i as CollapsibleRootProvider, l as CollapsibleContent, n as collapsibleAnatomy, o as useCollapsible, r as CollapsibleTrigger, s as CollapsibleIndicator, t as collapsible_exports, u as useCollapsibleContext } from "./collapsible-CiTNjCNf.js";
+export { collapsible_exports as Collapsible, CollapsibleContent, CollapsibleContext, CollapsibleIndicator, CollapsibleRoot, CollapsibleRootProvider, CollapsibleTrigger, collapsibleAnatomy, useCollapsible, useCollapsibleContext };

package/dist/collection-BFjWNdUS.cjs

@@ -0,0 +1,223 @@
+const require_rolldown_runtime = require("./rolldown-runtime-DakpK96I.cjs");
+const require_utils = require("./utils-Cfwm9WW1.cjs");
+const require_core = require("./core-CBFAnVIP.cjs");
+let react = require("react");
+let _wirekyt_dom_collection = require("@wirekyt/dom/collection");
+let _wirekyt_dom_machines_async_list = require("@wirekyt/dom/machines/async-list");
+_wirekyt_dom_machines_async_list = require_rolldown_runtime.__toESM(_wirekyt_dom_machines_async_list, 1);
+//#region src/components/collection/grid.ts
+const createGridCollection = (options) => new _wirekyt_dom_collection.GridCollection(options);
+//#endregion
+//#region src/components/collection/list.ts
+const createListCollection = (options) => new _wirekyt_dom_collection.ListCollection(options);
+//#endregion
+//#region src/components/collection/tree.ts
+const createTreeCollection = (options) => new _wirekyt_dom_collection.TreeCollection(options);
+const createFileTreeCollection = (paths) => (0, _wirekyt_dom_collection.filePathToTree)(paths);
+//#endregion
+//#region src/components/collection/use-async-list.ts
+function useAsyncList(props) {
+	const service = require_core.useMachine(_wirekyt_dom_machines_async_list.machine, props);
+	return _wirekyt_dom_machines_async_list.connect(service);
+}
+//#endregion
+//#region src/components/collection/use-list.ts
+function useListCollection(props) {
+	const { initialItems = [], filter, limit, ...collectionOptions } = props;
+	const [items, setItemsImpl] = (0, react.useState)(initialItems);
+	const [filterText, setFilterText] = (0, react.useState)("");
+	const setItems = require_utils.useEvent((items) => {
+		setItemsImpl(items);
+		setFilterText("");
+	});
+	const collectionOptionsRef = (0, react.useRef)(collectionOptions);
+	collectionOptionsRef.current = collectionOptions;
+	const create = (0, react.useCallback)((items) => {
+		return createListCollection({
+			...collectionOptionsRef.current,
+			items
+		});
+	}, []);
+	return {
+		collection: (0, react.useMemo)(() => {
+			let activeItems = items;
+			if (filterText && filter) activeItems = create(items).filter((itemString, _index, item) => filter(itemString, filterText, item)).items;
+			const limitedItems = limit == null ? activeItems : activeItems.slice(0, limit);
+			return createListCollection({
+				...collectionOptionsRef.current,
+				items: limitedItems
+			});
+		}, [
+			items,
+			filterText,
+			filter,
+			limit,
+			create
+		]),
+		filter: require_utils.useEvent((inputValue) => {
+			setFilterText(inputValue || "");
+		}),
+		set: require_utils.useEvent((newItems) => {
+			setItems(newItems);
+		}),
+		reset: require_utils.useEvent(() => {
+			setItems(initialItems);
+		}),
+		clear: require_utils.useEvent(() => {
+			setItems([]);
+		}),
+		insert: require_utils.useEvent((index, ...itemsToInsert) => {
+			const newItems = create(items).insert(index, ...itemsToInsert).items;
+			setItems(newItems);
+		}),
+		insertBefore: require_utils.useEvent((value, ...itemsToInsert) => {
+			const newItems = create(items).insertBefore(value, ...itemsToInsert).items;
+			setItems(newItems);
+		}),
+		insertAfter: require_utils.useEvent((value, ...itemsToInsert) => {
+			const newItems = create(items).insertAfter(value, ...itemsToInsert).items;
+			setItems(newItems);
+		}),
+		remove: require_utils.useEvent((...itemOrValues) => {
+			const newItems = create(items).remove(...itemOrValues).items;
+			setItems(newItems);
+		}),
+		move: require_utils.useEvent((value, to) => {
+			const newItems = create(items).move(value, to).items;
+			setItems(newItems);
+		}),
+		moveBefore: require_utils.useEvent((value, ...values) => {
+			const newItems = create(items).moveBefore(value, ...values).items;
+			setItems(newItems);
+		}),
+		moveAfter: require_utils.useEvent((value, ...values) => {
+			const newItems = create(items).moveAfter(value, ...values).items;
+			setItems(newItems);
+		}),
+		reorder: require_utils.useEvent((from, to) => {
+			const newItems = create(items).reorder(from, to).items;
+			setItems(newItems);
+		}),
+		append: require_utils.useEvent((...itemsToAppend) => {
+			const newItems = create(items).append(...itemsToAppend).items;
+			setItems(newItems);
+		}),
+		upsert: require_utils.useEvent((value, item, mode = "append") => {
+			const newItems = create(items).upsert(value, item, mode).items;
+			setItems(newItems);
+		}),
+		prepend: require_utils.useEvent((...itemsToPrepend) => {
+			const newItems = create(items).prepend(...itemsToPrepend).items;
+			setItems(newItems);
+		}),
+		update: require_utils.useEvent((value, item) => {
+			const newItems = create(items).update(value, item).items;
+			setItems(newItems);
+		})
+	};
+}
+//#endregion
+//#region src/components/collection/use-list-selection.ts
+function useListSelection(props) {
+	const { collection, selectionMode = "single", deselectable = true, initialSelectedValues = [], resetOnCollectionChange = false } = props;
+	const createSelection = (0, react.useCallback)((values = []) => {
+		const selection = new _wirekyt_dom_collection.Selection(values);
+		selection.selectionMode = selectionMode;
+		selection.deselectable = deselectable;
+		return selection;
+	}, [selectionMode, deselectable]);
+	const [selection, setSelectionState] = (0, react.useState)(() => createSelection(initialSelectedValues));
+	(0, react.useEffect)(() => {
+		if (resetOnCollectionChange) setSelectionState(createSelection());
+	}, [
+		collection.toString(),
+		resetOnCollectionChange,
+		createSelection
+	]);
+	return {
+		selectedValues: (0, react.useMemo)(() => Array.from(selection), [selection]),
+		isEmpty: (0, react.useMemo)(() => selection.isEmpty(), [selection]),
+		firstSelectedValue: (0, react.useMemo)(() => selection.firstSelectedValue(collection), [selection, collection]),
+		lastSelectedValue: (0, react.useMemo)(() => selection.lastSelectedValue(collection), [selection, collection]),
+		isSelected: require_utils.useEvent((value) => {
+			return selection.isSelected(value);
+		}),
+		isAllSelected: require_utils.useEvent(() => {
+			const allValues = collection.getValues();
+			return allValues.length > 0 && allValues.every((value) => selection.isSelected(value));
+		}),
+		isSomeSelected: require_utils.useEvent(() => {
+			return collection.getValues().some((value) => selection.isSelected(value));
+		}),
+		canSelect: require_utils.useEvent((value) => {
+			return selection.canSelect(collection, value);
+		}),
+		select: require_utils.useEvent((value, forceToggle) => {
+			setSelectionState(selection.select(collection, value, forceToggle));
+		}),
+		deselect: require_utils.useEvent((value) => {
+			setSelectionState(selection.deselect(value));
+		}),
+		toggle: require_utils.useEvent((value) => {
+			setSelectionState(selection.toggleSelection(collection, value));
+		}),
+		replace: require_utils.useEvent((value) => {
+			setSelectionState(selection.replaceSelection(collection, value));
+		}),
+		extend: require_utils.useEvent((anchorValue, targetValue) => {
+			setSelectionState(selection.extendSelection(collection, anchorValue, targetValue));
+		}),
+		setSelectedValues: require_utils.useEvent((values) => {
+			setSelectionState(selection.setSelection(values));
+		}),
+		clear: require_utils.useEvent(() => {
+			setSelectionState(selection.clearSelection());
+		}),
+		resetSelection: require_utils.useEvent(() => {
+			setSelectionState(createSelection());
+		})
+	};
+}
+//#endregion
+Object.defineProperty(exports, "createFileTreeCollection", {
+	enumerable: true,
+	get: function() {
+		return createFileTreeCollection;
+	}
+});
+Object.defineProperty(exports, "createGridCollection", {
+	enumerable: true,
+	get: function() {
+		return createGridCollection;
+	}
+});
+Object.defineProperty(exports, "createListCollection", {
+	enumerable: true,
+	get: function() {
+		return createListCollection;
+	}
+});
+Object.defineProperty(exports, "createTreeCollection", {
+	enumerable: true,
+	get: function() {
+		return createTreeCollection;
+	}
+});
+Object.defineProperty(exports, "useAsyncList", {
+	enumerable: true,
+	get: function() {
+		return useAsyncList;
+	}
+});
+Object.defineProperty(exports, "useListCollection", {
+	enumerable: true,
+	get: function() {
+		return useListCollection;
+	}
+});
+Object.defineProperty(exports, "useListSelection", {
+	enumerable: true,
+	get: function() {
+		return useListSelection;
+	}
+});

package/dist/collection-BJOl6a4H.js

@@ -0,0 +1,180 @@
+import { r as useEvent } from "./utils-CqLmqrgj.js";
+import { a as useMachine } from "./core-CEYOEcVI.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { GridCollection, ListCollection, Selection, TreeCollection, filePathToTree } from "@wirekyt/dom/collection";
+import * as asyncList from "@wirekyt/dom/machines/async-list";
+//#region src/components/collection/grid.ts
+const createGridCollection = (options) => new GridCollection(options);
+//#endregion
+//#region src/components/collection/list.ts
+const createListCollection = (options) => new ListCollection(options);
+//#endregion
+//#region src/components/collection/tree.ts
+const createTreeCollection = (options) => new TreeCollection(options);
+const createFileTreeCollection = (paths) => filePathToTree(paths);
+//#endregion
+//#region src/components/collection/use-async-list.ts
+function useAsyncList(props) {
+	const service = useMachine(asyncList.machine, props);
+	return asyncList.connect(service);
+}
+//#endregion
+//#region src/components/collection/use-list.ts
+function useListCollection(props) {
+	const { initialItems = [], filter, limit, ...collectionOptions } = props;
+	const [items, setItemsImpl] = useState(initialItems);
+	const [filterText, setFilterText] = useState("");
+	const setItems = useEvent((items) => {
+		setItemsImpl(items);
+		setFilterText("");
+	});
+	const collectionOptionsRef = useRef(collectionOptions);
+	collectionOptionsRef.current = collectionOptions;
+	const create = useCallback((items) => {
+		return createListCollection({
+			...collectionOptionsRef.current,
+			items
+		});
+	}, []);
+	return {
+		collection: useMemo(() => {
+			let activeItems = items;
+			if (filterText && filter) activeItems = create(items).filter((itemString, _index, item) => filter(itemString, filterText, item)).items;
+			const limitedItems = limit == null ? activeItems : activeItems.slice(0, limit);
+			return createListCollection({
+				...collectionOptionsRef.current,
+				items: limitedItems
+			});
+		}, [
+			items,
+			filterText,
+			filter,
+			limit,
+			create
+		]),
+		filter: useEvent((inputValue) => {
+			setFilterText(inputValue || "");
+		}),
+		set: useEvent((newItems) => {
+			setItems(newItems);
+		}),
+		reset: useEvent(() => {
+			setItems(initialItems);
+		}),
+		clear: useEvent(() => {
+			setItems([]);
+		}),
+		insert: useEvent((index, ...itemsToInsert) => {
+			const newItems = create(items).insert(index, ...itemsToInsert).items;
+			setItems(newItems);
+		}),
+		insertBefore: useEvent((value, ...itemsToInsert) => {
+			const newItems = create(items).insertBefore(value, ...itemsToInsert).items;
+			setItems(newItems);
+		}),
+		insertAfter: useEvent((value, ...itemsToInsert) => {
+			const newItems = create(items).insertAfter(value, ...itemsToInsert).items;
+			setItems(newItems);
+		}),
+		remove: useEvent((...itemOrValues) => {
+			const newItems = create(items).remove(...itemOrValues).items;
+			setItems(newItems);
+		}),
+		move: useEvent((value, to) => {
+			const newItems = create(items).move(value, to).items;
+			setItems(newItems);
+		}),
+		moveBefore: useEvent((value, ...values) => {
+			const newItems = create(items).moveBefore(value, ...values).items;
+			setItems(newItems);
+		}),
+		moveAfter: useEvent((value, ...values) => {
+			const newItems = create(items).moveAfter(value, ...values).items;
+			setItems(newItems);
+		}),
+		reorder: useEvent((from, to) => {
+			const newItems = create(items).reorder(from, to).items;
+			setItems(newItems);
+		}),
+		append: useEvent((...itemsToAppend) => {
+			const newItems = create(items).append(...itemsToAppend).items;
+			setItems(newItems);
+		}),
+		upsert: useEvent((value, item, mode = "append") => {
+			const newItems = create(items).upsert(value, item, mode).items;
+			setItems(newItems);
+		}),
+		prepend: useEvent((...itemsToPrepend) => {
+			const newItems = create(items).prepend(...itemsToPrepend).items;
+			setItems(newItems);
+		}),
+		update: useEvent((value, item) => {
+			const newItems = create(items).update(value, item).items;
+			setItems(newItems);
+		})
+	};
+}
+//#endregion
+//#region src/components/collection/use-list-selection.ts
+function useListSelection(props) {
+	const { collection, selectionMode = "single", deselectable = true, initialSelectedValues = [], resetOnCollectionChange = false } = props;
+	const createSelection = useCallback((values = []) => {
+		const selection = new Selection(values);
+		selection.selectionMode = selectionMode;
+		selection.deselectable = deselectable;
+		return selection;
+	}, [selectionMode, deselectable]);
+	const [selection, setSelectionState] = useState(() => createSelection(initialSelectedValues));
+	useEffect(() => {
+		if (resetOnCollectionChange) setSelectionState(createSelection());
+	}, [
+		collection.toString(),
+		resetOnCollectionChange,
+		createSelection
+	]);
+	return {
+		selectedValues: useMemo(() => Array.from(selection), [selection]),
+		isEmpty: useMemo(() => selection.isEmpty(), [selection]),
+		firstSelectedValue: useMemo(() => selection.firstSelectedValue(collection), [selection, collection]),
+		lastSelectedValue: useMemo(() => selection.lastSelectedValue(collection), [selection, collection]),
+		isSelected: useEvent((value) => {
+			return selection.isSelected(value);
+		}),
+		isAllSelected: useEvent(() => {
+			const allValues = collection.getValues();
+			return allValues.length > 0 && allValues.every((value) => selection.isSelected(value));
+		}),
+		isSomeSelected: useEvent(() => {
+			return collection.getValues().some((value) => selection.isSelected(value));
+		}),
+		canSelect: useEvent((value) => {
+			return selection.canSelect(collection, value);
+		}),
+		select: useEvent((value, forceToggle) => {
+			setSelectionState(selection.select(collection, value, forceToggle));
+		}),
+		deselect: useEvent((value) => {
+			setSelectionState(selection.deselect(value));
+		}),
+		toggle: useEvent((value) => {
+			setSelectionState(selection.toggleSelection(collection, value));
+		}),
+		replace: useEvent((value) => {
+			setSelectionState(selection.replaceSelection(collection, value));
+		}),
+		extend: useEvent((anchorValue, targetValue) => {
+			setSelectionState(selection.extendSelection(collection, anchorValue, targetValue));
+		}),
+		setSelectedValues: useEvent((values) => {
+			setSelectionState(selection.setSelection(values));
+		}),
+		clear: useEvent(() => {
+			setSelectionState(selection.clearSelection());
+		}),
+		resetSelection: useEvent(() => {
+			setSelectionState(createSelection());
+		})
+	};
+}
+//#endregion
+export { createTreeCollection as a, createFileTreeCollection as i, useListCollection as n, createListCollection as o, useAsyncList as r, createGridCollection as s, useListSelection as t };

package/dist/collection.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_collection = require("./collection-BFjWNdUS.cjs");
+exports.createFileTreeCollection = require_collection.createFileTreeCollection;
+exports.createGridCollection = require_collection.createGridCollection;
+exports.createListCollection = require_collection.createListCollection;
+exports.createTreeCollection = require_collection.createTreeCollection;
+exports.useAsyncList = require_collection.useAsyncList;
+exports.useListCollection = require_collection.useListCollection;
+exports.useListSelection = require_collection.useListSelection;

package/dist/collection.d.cts

@@ -0,0 +1,2 @@
+import { C as createGridCollection, S as GridCollectionOptions, _ as CollectionItem, a as UseListCollectionReturn, b as createListCollection, c as UseAsyncListReturn, d as FlatTreeNode, f as TreeCollection, g as createTreeCollection, h as createFileTreeCollection, i as UseListCollectionProps, l as useAsyncList, m as TreeNode, n as UseListSelectionReturn, o as useListCollection, p as TreeCollectionOptions, r as useListSelection, s as UseAsyncListProps, t as UseListSelectionProps, u as FilePathTreeNode, v as CollectionOptions, x as GridCollection, y as ListCollection } from "./index-3Al0R5bH.cjs";
+export { type CollectionItem, type CollectionOptions, type FilePathTreeNode, type FlatTreeNode, type GridCollection, type GridCollectionOptions, type ListCollection, type TreeCollection, type TreeCollectionOptions, type TreeNode, type UseAsyncListProps, type UseAsyncListReturn, type UseListCollectionProps, type UseListCollectionReturn, type UseListSelectionProps, type UseListSelectionReturn, createFileTreeCollection, createGridCollection, createListCollection, createTreeCollection, useAsyncList, useListCollection, useListSelection };

package/dist/collection.d.ts

@@ -0,0 +1,2 @@
+import { C as createGridCollection, S as GridCollectionOptions, _ as CollectionItem, a as UseListCollectionReturn, b as createListCollection, c as UseAsyncListReturn, d as FlatTreeNode, f as TreeCollection, g as createTreeCollection, h as createFileTreeCollection, i as UseListCollectionProps, l as useAsyncList, m as TreeNode, n as UseListSelectionReturn, o as useListCollection, p as TreeCollectionOptions, r as useListSelection, s as UseAsyncListProps, t as UseListSelectionProps, u as FilePathTreeNode, v as CollectionOptions, x as GridCollection, y as ListCollection } from "./index-BAn8qiCM.js";
+export { type CollectionItem, type CollectionOptions, type FilePathTreeNode, type FlatTreeNode, type GridCollection, type GridCollectionOptions, type ListCollection, type TreeCollection, type TreeCollectionOptions, type TreeNode, type UseAsyncListProps, type UseAsyncListReturn, type UseListCollectionProps, type UseListCollectionReturn, type UseListSelectionProps, type UseListSelectionReturn, createFileTreeCollection, createGridCollection, createListCollection, createTreeCollection, useAsyncList, useListCollection, useListSelection };

package/dist/collection.js

@@ -0,0 +1,2 @@
+import { a as createTreeCollection, i as createFileTreeCollection, n as useListCollection, o as createListCollection, r as useAsyncList, s as createGridCollection, t as useListSelection } from "./collection-BJOl6a4H.js";
+export { createFileTreeCollection, createGridCollection, createListCollection, createTreeCollection, useAsyncList, useListCollection, useListSelection };