@wirekyt/vue 0.0.1 → 0.0.3

package/dist/collapsible.d.ts

@@ -0,0 +1,161 @@
+import { a as PolymorphicProps } from "./factory-BNwuanv4.js";
+import { i as EmitFn$1, l as PropTypes, o as Optional } from "./index-BSoF1D-v.js";
+import { n as RenderStrategyProps } from "./index-Cc4qS0rQ.js";
+import { ButtonHTMLAttributes, ComputedRef, HTMLAttributes, MaybeRef, SlotsType, UnwrapRef } from "vue";
+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.vue.d.ts
+interface CollapsibleContentBaseProps extends PolymorphicProps {}
+interface CollapsibleContentProps extends CollapsibleContentBaseProps,
+/**
+ * @vue-ignore
+ */
+HTMLAttributes {}
+declare const _default: typeof __VLS_export$5;
+declare const __VLS_export$5: __VLS_WithSlots$5<import("vue").DefineComponent<CollapsibleContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CollapsibleContentProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$5<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/collapsible/types.d.ts
+interface RootProps {
+  collapsedHeight?: number | string;
+  collapsedWidth?: number | string;
+  defaultOpen?: boolean;
+  disabled?: boolean;
+  id?: string;
+  ids?: Partial<{
+    root: string;
+    content: string;
+    trigger: string;
+  }>;
+  lazyMount?: boolean;
+  open?: boolean;
+  unmountOnExit?: boolean;
+}
+type RootEmits = {
+  exitComplete: [];
+  openChange: [details: collapsible.OpenChangeDetails];
+  "update:open": [open: boolean];
+};
+//#endregion
+//#region src/components/collapsible/use.d.ts
+interface UseCollapsibleProps extends RenderStrategyProps, Optional<Omit<collapsible.Props, "dir" | "getRootNode">, "id"> {}
+interface Collapsible extends collapsible.Api<PropTypes> {
+  unmounted?: boolean;
+}
+interface UseCollapsibleReturn extends ComputedRef<Collapsible> {}
+declare const useCollapsible: (props?: MaybeRef<UseCollapsibleProps>, emits?: EmitFn$1<RootEmits>) => UseCollapsibleReturn;
+//#endregion
+//#region src/components/collapsible/use-context.d.ts
+interface UseCollapsibleContext extends UseCollapsibleReturn {}
+declare const CollapsibleProvider: (opts: UseCollapsibleContext) => void, useCollapsibleContext: (fallback?: UseCollapsibleContext | undefined) => UseCollapsibleContext;
+//#endregion
+//#region src/components/collapsible/context.vue.d.ts
+interface CollapsibleContextProps extends SlotsType<{
+  default: UnwrapRef<UseCollapsibleContext>;
+}> {}
+declare const _default$1: typeof __VLS_export$4;
+declare const __VLS_export$4: __VLS_WithSlots$4<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+  default(collapsible: UnwrapRef<UseCollapsibleContext>): unknown;
+}>;
+type __VLS_WithSlots$4<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/collapsible/root-provider.vue.d.ts
+interface RootProviderProps {
+  value: UnwrapRef<UseCollapsibleReturn>;
+}
+interface CollapsibleRootProviderBaseProps extends RootProviderProps, PolymorphicProps {}
+interface CollapsibleRootProviderProps extends CollapsibleRootProviderBaseProps,
+/**
+ * @vue-ignore
+ */
+HTMLAttributes {}
+declare const _default$4: typeof __VLS_export$3;
+declare const __VLS_export$3: __VLS_WithSlots$3<import("vue").DefineComponent<CollapsibleRootProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CollapsibleRootProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$3<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/collapsible/root.vue.d.ts
+interface CollapsibleRootBaseProps extends RootProps, PolymorphicProps {}
+interface CollapsibleRootProps extends CollapsibleRootBaseProps,
+/**
+ * @vue-ignore
+ */
+HTMLAttributes {}
+interface CollapsibleRootEmits extends RootEmits {}
+declare const _default$3: typeof __VLS_export$2;
+declare const __VLS_export$2: __VLS_WithSlots$2<import("vue").DefineComponent<CollapsibleRootProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  exitComplete: () => any;
+  openChange: (details: import("@wirekyt/dom/machines/collapsible").OpenChangeDetails) => any;
+  "update:open": (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<CollapsibleRootProps> & Readonly<{
+  onExitComplete?: (() => any) | undefined;
+  onOpenChange?: ((details: import("@wirekyt/dom/machines/collapsible").OpenChangeDetails) => any) | undefined;
+  "onUpdate:open"?: ((open: boolean) => any) | undefined;
+}>, {
+  disabled: boolean;
+  open: boolean;
+  lazyMount: boolean;
+  unmountOnExit: boolean;
+  defaultOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$2<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/collapsible/trigger.vue.d.ts
+interface CollapsibleTriggerBaseProps extends PolymorphicProps {}
+interface CollapsibleTriggerProps extends CollapsibleTriggerBaseProps,
+/**
+ * @vue-ignore
+ */
+ButtonHTMLAttributes {}
+declare const _default$5: typeof __VLS_export$1;
+declare const __VLS_export$1: __VLS_WithSlots$1<import("vue").DefineComponent<CollapsibleTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CollapsibleTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/collapsible/indicator.vue.d.ts
+interface CollapsibleIndicatorBaseProps extends PolymorphicProps {}
+interface CollapsibleIndicatorProps extends CollapsibleIndicatorBaseProps,
+/**
+ * @vue-ignore
+ */
+HTMLAttributes {}
+declare const _default$2: typeof __VLS_export;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<CollapsibleIndicatorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CollapsibleIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+declare namespace collapsible_d_exports {
+  export { _default as Content, CollapsibleContentBaseProps as ContentBaseProps, CollapsibleContentProps as ContentProps, _default$1 as Context, CollapsibleContextProps as ContextProps, _default$2 as Indicator, CollapsibleIndicatorBaseProps as IndicatorBaseProps, CollapsibleIndicatorProps as IndicatorProps, OpenChangeDetails, _default$3 as Root, CollapsibleRootBaseProps as RootBaseProps, CollapsibleRootEmits as RootEmits, CollapsibleRootProps as RootProps, _default$4 as RootProvider, CollapsibleRootProviderBaseProps as RootProviderBaseProps, CollapsibleRootProviderProps as RootProviderProps, _default$5 as Trigger, CollapsibleTriggerBaseProps as TriggerBaseProps, CollapsibleTriggerProps as TriggerProps };
+}
+//#endregion
+export { collapsible_d_exports as Collapsible, _default as CollapsibleContent, type CollapsibleContentBaseProps, type CollapsibleContentProps, _default$1 as CollapsibleContext, type CollapsibleContextProps, _default$2 as CollapsibleIndicator, type CollapsibleIndicatorBaseProps, type CollapsibleIndicatorProps, type CollapsibleOpenChangeDetails, _default$3 as CollapsibleRoot, type CollapsibleRootBaseProps, type CollapsibleRootEmits, type CollapsibleRootProps, _default$4 as CollapsibleRootProvider, type CollapsibleRootProviderBaseProps, type CollapsibleRootProviderProps, _default$5 as 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 _sfc_main$3, c as _sfc_main$1, i as _sfc_main$5, l as _sfc_main, n as collapsibleAnatomy, o as useCollapsible, r as _sfc_main$2, s as _sfc_main$4, t as collapsible_exports, u as useCollapsibleContext } from "./collapsible-jvqnRz16.js";
+export { collapsible_exports as Collapsible, _sfc_main as CollapsibleContent, _sfc_main$1 as CollapsibleContext, _sfc_main$2 as CollapsibleIndicator, _sfc_main$3 as CollapsibleRoot, _sfc_main$4 as CollapsibleRootProvider, _sfc_main$5 as CollapsibleTrigger, collapsibleAnatomy, useCollapsible, useCollapsibleContext };

package/dist/collection-B0onOyyK.cjs

@@ -0,0 +1,254 @@
+const require_rolldown_runtime = require("./rolldown-runtime-DakpK96I.cjs");
+const require_utils = require("./utils-XrBZd2Yk.cjs");
+const require_clean_props = require("./clean-props-MyKqus13.cjs");
+let vue = require("vue");
+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
+const useAsyncList = (props = {}) => {
+	const context = (0, vue.computed)(() => require_clean_props.cleanProps((0, vue.toValue)(props)));
+	const service = require_utils.useMachine(_wirekyt_dom_machines_async_list.machine, context);
+	return (0, vue.computed)(() => _wirekyt_dom_machines_async_list.connect(service));
+};
+//#endregion
+//#region src/components/collection/use-list.ts
+function useListCollection(props) {
+	const resolvedProps = (0, vue.computed)(() => {
+		const { initialItems = [], filter, limit, ...collectionOptions } = (0, vue.toValue)(props);
+		return [{
+			initialItems,
+			filter,
+			limit
+		}, collectionOptions];
+	});
+	const init = () => {
+		const { initialItems } = resolvedProps.value[0];
+		return initialItems;
+	};
+	const items = (0, vue.ref)(init());
+	const filterText = (0, vue.ref)("");
+	const setItems = (newItems) => {
+		items.value = newItems;
+		filterText.value = "";
+	};
+	const create = (itemsToCreate) => {
+		const [, collectionOptions] = resolvedProps.value;
+		return createListCollection({
+			...collectionOptions,
+			items: itemsToCreate
+		});
+	};
+	return {
+		collection: (0, vue.computed)(() => {
+			const [localProps, collectionOptions] = resolvedProps.value;
+			let activeItems = items.value;
+			const filter = localProps.filter;
+			if (filterText.value && filter) activeItems = create(items.value).filter((itemString, _index, item) => filter(itemString, filterText.value, item)).items;
+			const limitedItems = localProps.limit == null ? activeItems : activeItems.slice(0, localProps.limit);
+			return createListCollection({
+				...collectionOptions,
+				items: limitedItems
+			});
+		}),
+		filter: (inputValue = "") => {
+			filterText.value = inputValue;
+		},
+		set: (newItems) => {
+			setItems(newItems);
+		},
+		reset: () => {
+			const [localProps] = resolvedProps.value;
+			setItems(localProps.initialItems);
+		},
+		clear: () => {
+			setItems([]);
+		},
+		insert: (index, ...itemsToInsert) => {
+			const newItems = create(items.value).insert(index, ...itemsToInsert).items;
+			setItems(newItems);
+		},
+		insertBefore: (value, ...itemsToInsert) => {
+			const newItems = create(items.value).insertBefore(value, ...itemsToInsert).items;
+			setItems(newItems);
+		},
+		insertAfter: (value, ...itemsToInsert) => {
+			const newItems = create(items.value).insertAfter(value, ...itemsToInsert).items;
+			setItems(newItems);
+		},
+		remove: (...itemOrValues) => {
+			const newItems = create(items.value).remove(...itemOrValues).items;
+			setItems(newItems);
+		},
+		move: (value, to) => {
+			const newItems = create(items.value).move(value, to).items;
+			setItems(newItems);
+		},
+		moveBefore: (value, ...values) => {
+			const newItems = create(items.value).moveBefore(value, ...values).items;
+			setItems(newItems);
+		},
+		moveAfter: (value, ...values) => {
+			const newItems = create(items.value).moveAfter(value, ...values).items;
+			setItems(newItems);
+		},
+		reorder: (from, to) => {
+			const newItems = create(items.value).reorder(from, to).items;
+			setItems(newItems);
+		},
+		append: (...itemsToAppend) => {
+			const newItems = create(items.value).append(...itemsToAppend).items;
+			setItems(newItems);
+		},
+		upsert: (value, item, mode = "append") => {
+			const newItems = create(items.value).upsert(value, item, mode).items;
+			setItems(newItems);
+		},
+		prepend: (...itemsToPrepend) => {
+			const newItems = create(items.value).prepend(...itemsToPrepend).items;
+			setItems(newItems);
+		},
+		update: (value, item) => {
+			const newItems = create(items.value).update(value, item).items;
+			setItems(newItems);
+		}
+	};
+}
+//#endregion
+//#region src/components/collection/use-list-selection.ts
+function useListSelection(props) {
+	const resolvedProps = (0, vue.computed)(() => {
+		const { collection, selectionMode = "single", deselectable = true, initialSelectedValues = [], resetOnCollectionChange = false } = (0, vue.toValue)(props);
+		return {
+			collection,
+			selectionMode,
+			deselectable,
+			initialSelectedValues,
+			resetOnCollectionChange
+		};
+	});
+	const createSelection = (values = []) => {
+		const { selectionMode, deselectable } = resolvedProps.value;
+		const selection = new _wirekyt_dom_collection.Selection(values);
+		selection.selectionMode = selectionMode;
+		selection.deselectable = deselectable;
+		return selection;
+	};
+	const init = () => {
+		const { initialSelectedValues } = resolvedProps.value;
+		return createSelection(initialSelectedValues);
+	};
+	const selection = (0, vue.shallowRef)(init());
+	(0, vue.watch)([() => resolvedProps.value.collection.getValues(), () => resolvedProps.value.resetOnCollectionChange], ([, resetOnCollectionChange]) => {
+		if (resetOnCollectionChange) selection.value = createSelection();
+	});
+	return {
+		selectedValues: (0, vue.computed)(() => Array.from(selection.value)),
+		isEmpty: (0, vue.computed)(() => selection.value.isEmpty()),
+		firstSelectedValue: (0, vue.computed)(() => {
+			const { collection } = resolvedProps.value;
+			return selection.value.firstSelectedValue(collection);
+		}),
+		lastSelectedValue: (0, vue.computed)(() => {
+			const { collection } = resolvedProps.value;
+			return selection.value.lastSelectedValue(collection);
+		}),
+		isSelected: (value) => {
+			return selection.value.isSelected(value);
+		},
+		isAllSelected: () => {
+			const { collection } = resolvedProps.value;
+			const allValues = collection.getValues();
+			return allValues.length > 0 && allValues.every((value) => selection.value.isSelected(value));
+		},
+		isSomeSelected: () => {
+			const { collection } = resolvedProps.value;
+			return collection.getValues().some((value) => selection.value.isSelected(value));
+		},
+		canSelect: (value) => {
+			const { collection } = resolvedProps.value;
+			return selection.value.canSelect(collection, value);
+		},
+		select: (value, forceToggle) => {
+			const { collection } = resolvedProps.value;
+			selection.value = selection.value.select(collection, value, forceToggle);
+		},
+		deselect: (value) => {
+			selection.value = selection.value.deselect(value);
+		},
+		toggle: (value) => {
+			const { collection } = resolvedProps.value;
+			selection.value = selection.value.toggleSelection(collection, value);
+		},
+		replace: (value) => {
+			const { collection } = resolvedProps.value;
+			selection.value = selection.value.replaceSelection(collection, value);
+		},
+		extend: (anchorValue, targetValue) => {
+			const { collection } = resolvedProps.value;
+			selection.value = selection.value.extendSelection(collection, anchorValue, targetValue);
+		},
+		setSelectedValues: (values) => {
+			selection.value = selection.value.setSelection(values);
+		},
+		clear: () => {
+			selection.value = selection.value.clearSelection();
+		},
+		resetSelection: () => {
+			selection.value = 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-Dg6EtML_.js

@@ -0,0 +1,211 @@
+import { s as useMachine } from "./utils-D95V66v9.js";
+import { t as cleanProps } from "./clean-props--1kqQE0Y.js";
+import { computed, ref, shallowRef, toValue, watch } from "vue";
+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
+const useAsyncList = (props = {}) => {
+	const context = computed(() => cleanProps(toValue(props)));
+	const service = useMachine(asyncList.machine, context);
+	return computed(() => asyncList.connect(service));
+};
+//#endregion
+//#region src/components/collection/use-list.ts
+function useListCollection(props) {
+	const resolvedProps = computed(() => {
+		const { initialItems = [], filter, limit, ...collectionOptions } = toValue(props);
+		return [{
+			initialItems,
+			filter,
+			limit
+		}, collectionOptions];
+	});
+	const init = () => {
+		const { initialItems } = resolvedProps.value[0];
+		return initialItems;
+	};
+	const items = ref(init());
+	const filterText = ref("");
+	const setItems = (newItems) => {
+		items.value = newItems;
+		filterText.value = "";
+	};
+	const create = (itemsToCreate) => {
+		const [, collectionOptions] = resolvedProps.value;
+		return createListCollection({
+			...collectionOptions,
+			items: itemsToCreate
+		});
+	};
+	return {
+		collection: computed(() => {
+			const [localProps, collectionOptions] = resolvedProps.value;
+			let activeItems = items.value;
+			const filter = localProps.filter;
+			if (filterText.value && filter) activeItems = create(items.value).filter((itemString, _index, item) => filter(itemString, filterText.value, item)).items;
+			const limitedItems = localProps.limit == null ? activeItems : activeItems.slice(0, localProps.limit);
+			return createListCollection({
+				...collectionOptions,
+				items: limitedItems
+			});
+		}),
+		filter: (inputValue = "") => {
+			filterText.value = inputValue;
+		},
+		set: (newItems) => {
+			setItems(newItems);
+		},
+		reset: () => {
+			const [localProps] = resolvedProps.value;
+			setItems(localProps.initialItems);
+		},
+		clear: () => {
+			setItems([]);
+		},
+		insert: (index, ...itemsToInsert) => {
+			const newItems = create(items.value).insert(index, ...itemsToInsert).items;
+			setItems(newItems);
+		},
+		insertBefore: (value, ...itemsToInsert) => {
+			const newItems = create(items.value).insertBefore(value, ...itemsToInsert).items;
+			setItems(newItems);
+		},
+		insertAfter: (value, ...itemsToInsert) => {
+			const newItems = create(items.value).insertAfter(value, ...itemsToInsert).items;
+			setItems(newItems);
+		},
+		remove: (...itemOrValues) => {
+			const newItems = create(items.value).remove(...itemOrValues).items;
+			setItems(newItems);
+		},
+		move: (value, to) => {
+			const newItems = create(items.value).move(value, to).items;
+			setItems(newItems);
+		},
+		moveBefore: (value, ...values) => {
+			const newItems = create(items.value).moveBefore(value, ...values).items;
+			setItems(newItems);
+		},
+		moveAfter: (value, ...values) => {
+			const newItems = create(items.value).moveAfter(value, ...values).items;
+			setItems(newItems);
+		},
+		reorder: (from, to) => {
+			const newItems = create(items.value).reorder(from, to).items;
+			setItems(newItems);
+		},
+		append: (...itemsToAppend) => {
+			const newItems = create(items.value).append(...itemsToAppend).items;
+			setItems(newItems);
+		},
+		upsert: (value, item, mode = "append") => {
+			const newItems = create(items.value).upsert(value, item, mode).items;
+			setItems(newItems);
+		},
+		prepend: (...itemsToPrepend) => {
+			const newItems = create(items.value).prepend(...itemsToPrepend).items;
+			setItems(newItems);
+		},
+		update: (value, item) => {
+			const newItems = create(items.value).update(value, item).items;
+			setItems(newItems);
+		}
+	};
+}
+//#endregion
+//#region src/components/collection/use-list-selection.ts
+function useListSelection(props) {
+	const resolvedProps = computed(() => {
+		const { collection, selectionMode = "single", deselectable = true, initialSelectedValues = [], resetOnCollectionChange = false } = toValue(props);
+		return {
+			collection,
+			selectionMode,
+			deselectable,
+			initialSelectedValues,
+			resetOnCollectionChange
+		};
+	});
+	const createSelection = (values = []) => {
+		const { selectionMode, deselectable } = resolvedProps.value;
+		const selection = new Selection(values);
+		selection.selectionMode = selectionMode;
+		selection.deselectable = deselectable;
+		return selection;
+	};
+	const init = () => {
+		const { initialSelectedValues } = resolvedProps.value;
+		return createSelection(initialSelectedValues);
+	};
+	const selection = shallowRef(init());
+	watch([() => resolvedProps.value.collection.getValues(), () => resolvedProps.value.resetOnCollectionChange], ([, resetOnCollectionChange]) => {
+		if (resetOnCollectionChange) selection.value = createSelection();
+	});
+	return {
+		selectedValues: computed(() => Array.from(selection.value)),
+		isEmpty: computed(() => selection.value.isEmpty()),
+		firstSelectedValue: computed(() => {
+			const { collection } = resolvedProps.value;
+			return selection.value.firstSelectedValue(collection);
+		}),
+		lastSelectedValue: computed(() => {
+			const { collection } = resolvedProps.value;
+			return selection.value.lastSelectedValue(collection);
+		}),
+		isSelected: (value) => {
+			return selection.value.isSelected(value);
+		},
+		isAllSelected: () => {
+			const { collection } = resolvedProps.value;
+			const allValues = collection.getValues();
+			return allValues.length > 0 && allValues.every((value) => selection.value.isSelected(value));
+		},
+		isSomeSelected: () => {
+			const { collection } = resolvedProps.value;
+			return collection.getValues().some((value) => selection.value.isSelected(value));
+		},
+		canSelect: (value) => {
+			const { collection } = resolvedProps.value;
+			return selection.value.canSelect(collection, value);
+		},
+		select: (value, forceToggle) => {
+			const { collection } = resolvedProps.value;
+			selection.value = selection.value.select(collection, value, forceToggle);
+		},
+		deselect: (value) => {
+			selection.value = selection.value.deselect(value);
+		},
+		toggle: (value) => {
+			const { collection } = resolvedProps.value;
+			selection.value = selection.value.toggleSelection(collection, value);
+		},
+		replace: (value) => {
+			const { collection } = resolvedProps.value;
+			selection.value = selection.value.replaceSelection(collection, value);
+		},
+		extend: (anchorValue, targetValue) => {
+			const { collection } = resolvedProps.value;
+			selection.value = selection.value.extendSelection(collection, anchorValue, targetValue);
+		},
+		setSelectedValues: (values) => {
+			selection.value = selection.value.setSelection(values);
+		},
+		clear: () => {
+			selection.value = selection.value.clearSelection();
+		},
+		resetSelection: () => {
+			selection.value = 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-B0onOyyK.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-Dpm1wGVS.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-kCBQJqpU.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-Dg6EtML_.js";
+export { createFileTreeCollection, createGridCollection, createListCollection, createTreeCollection, useAsyncList, useListCollection, useListSelection };