intable 0.0.8 → 0.0.9

package/dist/components/RecycleList.js

@@ -0,0 +1,39 @@
+import { createComponent, memo } from "solid-js/web";
+import { For, createMemo, getOwner, onCleanup, runWithOwner } from "solid-js";
+import { createMutable } from "solid-js/store";
+function RecycleList(c) {
+	let l = /* @__PURE__ */ new Map(), u = [], d = getOwner();
+	function f(e) {
+		return runWithOwner(d, () => createMutable(e));
+	}
+	let p = createMemo(() => {
+		let e = c.each || [], a = new Set(e);
+		for (let [e, o] of l) a.has(e) || (u.push(o), l.delete(e), o.active = !1);
+		let o = [];
+		for (let a = 0; a < e.length; a++) {
+			let s = e[a];
+			if (l.has(s)) {
+				let e = l.get(s);
+				e.i = a, e.v = s;
+			} else if (u.length > 0) {
+				let e = u.pop();
+				e.i = a, e.v = s, e.active = !0, l.set(s, e);
+			} else l.set(s, f({
+				v: s,
+				i: a,
+				active: !0
+			}));
+			o.push(l.get(s));
+		}
+		return o.concat(...u);
+	});
+	return onCleanup(() => {
+		l.clear(), u.length = 0;
+	}), createComponent(For, {
+		get each() {
+			return p();
+		},
+		children: (e) => memo(() => memo(() => !!e.active)() && runWithOwner(d, () => e.el ??= c.children(() => e.v, () => e.i)))
+	});
+}
+export { RecycleList };

package/dist/components/Render.d.ts

@@ -0,0 +1,4 @@
+export declare function createRender({ is, processProps }?: {
+    processProps?: (e: any) => any;
+}): (props: any) => import("solid-js").JSX.Element;
+export declare const Render: (props: any) => import("solid-js").JSX.Element;

package/dist/components/Render.js

@@ -0,0 +1,20 @@
+import { Dynamic, createComponent, memo, mergeProps } from "solid-js/web";
+import { splitProps } from "solid-js";
+var unFn = (e, ...a) => typeof e == "function" ? e(...a) : e;
+function createRender({ is: o, processProps: s = (e) => e } = {}) {
+	let c = (c) => {
+		let [u, d] = splitProps(s?.(c), [
+			"is",
+			"vIf",
+			"children"
+		]);
+		return memo(() => memo(() => !!(!("vIf" in u) || unFn(u.vIf)))() && createComponent(Dynamic, mergeProps({ get component() {
+			return u.is ?? o;
+		} }, d, { get children() {
+			return l(u.children);
+		} })));
+	}, l = (e) => Array.isArray(e) ? e.map((e) => typeof e == "object" ? c(e) : e) : e;
+	return c;
+}
+const Render = createRender({ is: "div" });
+export { Render, createRender };

package/dist/components/Split.d.ts

@@ -0,0 +1,15 @@
+import { type JSXElement } from 'solid-js';
+type SplitProps = {
+    container?: Element;
+    cells: () => Element[];
+    handle?: (i: number) => JSXElement;
+    size?: number;
+    dir?: 'x' | 'y';
+    leading?: boolean;
+    trailing?: boolean;
+};
+export declare const Split: (props: SplitProps & {
+    children?: JSXElement;
+}) => import("solid-js").JSX.Element;
+export declare const useSplit: (props: SplitProps) => void;
+export {};

package/dist/components/Split.js

@@ -0,0 +1,76 @@
+import { unFn } from "../utils.js";
+import { Portal, createComponent, effect, insert, memo, spread, style, template, use } from "solid-js/web";
+import { For, children, createEffect, mapArray, mergeProps as mergeProps$1, onMount } from "solid-js";
+import { createElementBounds } from "@solid-primitives/bounds";
+var _tmpl$ = /* @__PURE__ */ template("<div class=relative>"), _tmpl$2 = /* @__PURE__ */ template("<div class=\"absolute z-1\">");
+const Split = (e) => {
+	let d, f = children(() => e.children);
+	return onMount(() => {
+		useSplit({
+			...e,
+			container: d,
+			cells: () => e.cells ? e.cells() : f()
+		});
+	}), (() => {
+		var p = _tmpl$(), m = d;
+		return typeof m == "function" ? use(m, p) : d = p, spread(p, e, !1, !0), insert(p, f), p;
+	})();
+}, useSplit = (h) => {
+	h = mergeProps$1({
+		dir: "x",
+		size: 4
+	}, h);
+	let g, _ = mapArray(() => h.cells(), (e) => createElementBounds(e)), v = createElementBounds(() => g);
+	createEffect(() => g.style.position = "absolute");
+	let y = (e, d) => h.dir == "x" ? `transform: translate(${(d ? e.left + e.width : e.left) - h.size / 2}px, ${e.top}px); width: ${h.size}px; height: ${e.height}px;` : `transform: translate(${e.left}px, ${(d ? e.top + e.height : e.top) - h.size / 2}px); width: ${e.width}px; height: ${h.size}px;`, b = (e) => (() => {
+		var d = _tmpl$2();
+		return insert(d, () => h.handle?.(e.i)), effect((f) => style(d, y({
+			...e.e,
+			left: e.e.left - v.left,
+			top: e.e.top - v.top
+		}, e.bool), f)), d;
+	})();
+	createComponent(Portal, {
+		ref(e) {
+			var d = g;
+			typeof d == "function" ? d(e) : g = e;
+		},
+		get mount() {
+			return h.container || document.body;
+		},
+		get children() {
+			return [
+				createComponent(For, {
+					get each() {
+						return _().slice(0, -1);
+					},
+					children: (d, p) => createComponent(b, {
+						get e() {
+							return unFn(d);
+						},
+						bool: 1,
+						get i() {
+							return unFn(p);
+						}
+					})
+				}),
+				memo(() => memo(() => !!(_().length && h.leading))() && createComponent(b, {
+					get e() {
+						return _()[0];
+					},
+					i: -1
+				})),
+				memo(() => memo(() => !!(_().length && h.trailing))() && createComponent(b, {
+					get e() {
+						return _()[_().length - 1];
+					},
+					bool: 1,
+					get i() {
+						return _().length - 1;
+					}
+				}))
+			];
+		}
+	});
+};
+export { Split, useSplit };

package/dist/components/Tree.d.ts

@@ -0,0 +1,37 @@
+export declare abstract class $Node {
+    data: any;
+    constructor(data: any);
+    get label(): any;
+    abstract getChildren(): $Node[] | undefined;
+    children: $Node[] | undefined;
+    $children: import("solid-js").Accessor<$Node[]>;
+    parent: $Node | undefined;
+    $parent: import("solid-js").Signal<unknown>;
+    deep: number;
+    $deep: import("solid-js").Accessor<number>;
+    index: number;
+    $index: import("solid-js").Accessor<number>;
+    prev: $Node | undefined;
+    $prev: import("solid-js").Accessor<$Node>;
+    next: $Node | undefined;
+    $next: import("solid-js").Accessor<$Node>;
+    root: $Node;
+    $root: any;
+    path: $Node[];
+    $path: import("solid-js").Accessor<$Node[]>;
+    get descendants(): $Node[];
+    contains(node: $Node): boolean;
+    remove(): void;
+}
+export declare class $TreeItem extends $Node {
+    get is(): any;
+    get props(): any;
+    get id(): any;
+    getChildren(): any;
+}
+export declare function Tree(_: {
+    data: any;
+    Node: {
+        new (data: any): $TreeItem;
+    };
+}): import("solid-js").JSX.Element;

package/dist/components/Tree.js

@@ -0,0 +1,82 @@
+import { Dynamic, createComponent, insert, mergeProps, spread, template } from "solid-js/web";
+import { Index, createEffect, createMemo, createSignal, onCleanup, splitProps } from "solid-js";
+import { combineProps } from "@solid-primitives/props";
+import { createLazyMemo } from "@solid-primitives/memo";
+import { castArray } from "es-toolkit/compat";
+var _tmpl$ = /* @__PURE__ */ template("<div>");
+function define(e, d) {
+	let f = createSignal();
+	return Object.defineProperty(e, d, {
+		get() {
+			return f[0]();
+		},
+		set(e) {
+			f[1](e);
+		}
+	}), f;
+}
+function memo$1(e, d, f) {
+	let p = createLazyMemo(f);
+	return Object.defineProperty(e, d, { get() {
+		return p();
+	} }), p;
+}
+var $Node = class {
+	constructor(e) {
+		this.$children = memo$1(this, "children", () => this.getChildren()), this.$parent = define(this, "parent"), this.$deep = memo$1(this, "deep", () => this.parent ? this.parent.deep + 1 : 0), this.$index = memo$1(this, "index", () => this.parent?.children?.indexOf(this)), this.$prev = memo$1(this, "prev", () => this.parent?.children?.[this.index - 1]), this.$next = memo$1(this, "next", () => this.parent?.children?.[this.index + 1]), this.$root = memo$1(this, "root", () => this.parent ? this.parent.root : this), this.$path = memo$1(this, "path", () => {
+			let e = [this], d = this;
+			for (; d.parent;) e.push(d = d.parent);
+			return e.reverse();
+		}), this.data = e, createEffect(() => {
+			let e = this.children;
+			e?.map((e) => e.parent = this), onCleanup(() => e?.map((e) => e.parent = void 0));
+		});
+	}
+	get label() {
+		return this.data.label;
+	}
+	get descendants() {
+		return this.children?.flatMap((e) => [e, ...e.descendants]) || [];
+	}
+	contains(e) {
+		return e.path.includes(this);
+	}
+	remove() {}
+}, $TreeItem = class e extends $Node {
+	get is() {
+		return this.data.is;
+	}
+	get props() {
+		return this.data;
+	}
+	get id() {
+		return this.data.id;
+	}
+	getChildren() {
+		return this.data.children?.map((d) => new e(d));
+	}
+};
+function Tree(h) {
+	let [g, _] = splitProps(h, ["data", "Node"]), v = g.Node ?? $TreeItem, y = createMemo(() => new class extends v {
+		getChildren() {
+			return castArray(this.data || []).map((e) => new v(e));
+		}
+	}(g.data)), b = createMemo(() => y().descendants);
+	return (() => {
+		var h = _tmpl$();
+		return spread(h, mergeProps(() => combineProps({ class: "tt-menu" }, _)), !1, !0), insert(h, createComponent(Index, {
+			get each() {
+				return b();
+			},
+			children: (f, m) => createComponent(Dynamic, mergeProps({ get component() {
+				return f().is ?? "div";
+			} }, () => combineProps({
+				class: "li py-1 px-4",
+				style: `padding-left: ${f().deep * 16}px`
+			}, f().props), { get children() {
+				return f().label;
+			} }))
+		})), h;
+	})();
+}
+export { $Node, $TreeItem, Tree };

package/dist/components/utils.d.ts

@@ -0,0 +1,3 @@
+import type { JSX } from 'solid-js';
+export declare function solidComponent<T extends (...arg: any[]) => JSX.Element>(comp: T): T;
+export declare function renderComponent(Comp: any, props: any, renderer: any): JSX.Element;

package/dist/components/utils.js

@@ -0,0 +1,8 @@
+import { createComponent } from "solid-js/web";
+function solidComponent(e) {
+	return e.__solid = 1, e;
+}
+function renderComponent(t, n, r) {
+	return t ? (t.__solid || (t = r(t)), createComponent(t, n)) : null;
+}
+export { renderComponent, solidComponent };

package/dist/hooks/index.d.ts

@@ -0,0 +1,40 @@
+import { type Signal } from 'solid-js';
+import { type Many, type MaybeAccessor } from '@solid-primitives/utils';
+interface UseMoveOptions {
+    preventDefault?: boolean;
+    start?(e: PointerEvent, move: (cb: MoveCB) => void, end: (cb: EndCb) => void): void;
+}
+type MoveCB = (e: PointerEvent, o: {
+    sx: number;
+    sy: number;
+    ox: number;
+    oy: number;
+}) => void;
+type EndCb = (e: PointerEvent) => void;
+export declare function usePointerDrag(el: MaybeAccessor<HTMLElement | undefined>, options: UseMoveOptions): void;
+export declare function model(el: any, value: () => [() => string, (v: string) => any]): void;
+export declare function toSignle<T extends Record<string, any>>(state: T, k: keyof T): ((v: any) => any)[];
+export declare function useDark(): [get: import("solid-js").Accessor<boolean>, set: import("solid-js").Setter<boolean>, init: string | Promise<string>];
+export declare function useMemoAsync<T>(fn: (prev?: T) => Promise<T> | T, init?: Awaited<T>): import("solid-js").Accessor<Awaited<T>>;
+export declare function useSignle2<T>(v: T | (() => T), opt?: {
+    before?: (v: T) => Promise<T | void> | T;
+}): Signal<T>;
+type Reactive<T extends object> = {
+    [K in keyof T]: T[K] extends () => infer V ? V : T[K];
+};
+export declare function toReactive<T extends object>(fn: (() => T) | T): Reactive<T>;
+export declare function useMemo<T>(fn: () => T): import("solid-js").Accessor<T>;
+export declare function useHover(el: MaybeAccessor<Many<HTMLElement | undefined>>): import("solid-js").Accessor<boolean>;
+export declare function useMouseDown(el: MaybeAccessor<Many<HTMLElement | undefined>>): import("solid-js").Accessor<boolean>;
+export declare function useClicked(el: MaybeAccessor<Many<HTMLElement | undefined>>): import("solid-js").Accessor<boolean>;
+export declare function useMutation<T>(initial: MaybeAccessor<Node | Node[]>, options: MutationObserverInit, cb: () => T): import("solid-js").Accessor<T>;
+export declare function useTinykeys(el: MaybeAccessor<HTMLElement | undefined>, handlers: any): void;
+export declare function useHistory([val, setVal]: [any, any]): {
+    undo: () => any;
+    redo: () => any;
+    clear: () => any[];
+    readonly index: number;
+    readonly history: any[];
+};
+export declare function useMemoState(fn: any): {};
+export {};

package/dist/hooks/index.js

@@ -0,0 +1,157 @@
+import { unFn } from "../utils.js";
+import { $PROXY, batch, createComputed, createEffect, createMemo, createRenderEffect, createRoot, createSignal, mergeProps, on, onCleanup, untrack } from "solid-js";
+import { $RAW, createMutable } from "solid-js/store";
+import { isFunction, isPromise, mapValues } from "es-toolkit";
+import { createEventListener, createEventListenerMap } from "@solid-primitives/event-listener";
+import { createPointerListeners } from "@solid-primitives/pointer";
+import { access } from "@solid-primitives/utils";
+import { makePersisted, storageSync } from "@solid-primitives/storage";
+import { createMutationObserver } from "@solid-primitives/mutation-observer";
+import { castArray } from "es-toolkit/compat";
+import { createKeybindingsHandler } from "tinykeys";
+function usePointerDrag(h, L) {
+	L = mergeProps({ preventDefault: !0 }, L), createPointerListeners({
+		target: h,
+		passive: !1,
+		onDown(h) {
+			L.preventDefault && h.preventDefault();
+			let [R, z] = [h.x, h.y], B, V;
+			L.start?.(h, (h) => B = h, (h) => V = h), createRoot((L) => {
+				createPointerListeners({
+					target: document,
+					onMove(h) {
+						let [L, V] = [h.x - R, h.y - z];
+						B?.(h, {
+							sx: R,
+							sy: z,
+							ox: L,
+							oy: V
+						});
+					},
+					onUp() {
+						V?.(h), L(), B = void 0, V = void 0;
+					}
+				}), createEventListenerMap(document, { drop: L });
+			});
+		}
+	});
+}
+function model(h, L) {
+	let [R, z] = L();
+	createRenderEffect(() => h.value = R()), h.addEventListener("input", (h) => z(h.target.value));
+}
+function toSignle(h, L) {
+	return [() => h[L], (R) => h[L] = R];
+}
+function useDark() {
+	let h = (h) => h == "dark" || R() && !h, L = (h) => h ? "dark" : "light", R = () => window.matchMedia("(prefers-color-scheme: dark)").matches, z = makePersisted(createSignal(R()), {
+		name: "color-schema",
+		storage: localStorage,
+		sync: storageSync,
+		serialize: L,
+		deserialize: h
+	});
+	return createEffect(() => document.documentElement.classList[z[0]() ? "add" : "remove"]("dark")), createEffect(() => window.dispatchEvent(new StorageEvent("storage", {
+		key: "color-schema",
+		newValue: L(z[0]())
+	}))), z;
+}
+function useMemoAsync(h, L) {
+	let R = Symbol(), [B, V] = createSignal(L);
+	return createComputed(async () => {
+		let L = h(untrack(B)), z = L instanceof Promise ? await new Promise((h) => {
+			L.then(h), onCleanup(() => h(R));
+		}) : L;
+		z == R || V(() => z);
+	}), B;
+}
+function useSignle2(h, L) {
+	let R = createSignal(isFunction(h) ? void 0 : h), B = (h) => {
+		let R = L?.before?.(h);
+		return isPromise(R) ? R.then((L) => L === void 0 ? h : L) : R ?? h;
+	}, V = useMemoAsync(() => B(R[0]()));
+	if (isFunction(h)) {
+		let L = useMemoAsync(() => B(h()));
+		createComputed(() => R[1](L()));
+	}
+	return [V, R[1]];
+}
+var $MEMO = Symbol();
+function toReactive(R) {
+	let z = () => unFn(R), B = () => !0, V = (h) => ((h) => typeof h == "function" && $MEMO in h ? h() : h)(z()[h]);
+	return new Proxy(Object.create(null), {
+		get: (h, R, B) => R == $PROXY || R == $RAW ? B : ((h) => typeof h == "function" && $MEMO in h ? h() : h)(z()[R]),
+		set: B,
+		defineProperty: (h, L, R) => Object.defineProperty(z(), L, R),
+		deleteProperty: B,
+		getPrototypeOf: () => Object.getPrototypeOf(z()),
+		has: (h, R) => R == $PROXY || R in z(),
+		ownKeys: (h) => Object.keys(z()),
+		getOwnPropertyDescriptor: (h, L) => ({
+			enumerable: !0,
+			configurable: !0,
+			get() {
+				return V(L);
+			},
+			set: B
+		})
+	});
+}
+function useMemo(h) {
+	let L = createMemo(h);
+	return L[$MEMO] = 1, L;
+}
+function useHover(h) {
+	let [L, R] = createSignal(!1);
+	return createEventListener(h, "pointerenter", () => R(!0)), createEventListener(h, "pointerleave", () => R(!1)), L;
+}
+function useMouseDown(h) {
+	let [L, R] = createSignal(!1);
+	return createEventListener(h, "pointerdown", () => R(!0)), createEventListener(document.body, "pointerup", () => R(!1)), L;
+}
+function useClicked(h) {
+	let [L, R] = createSignal(!1), z = () => castArray(access(h));
+	return createEventListener(() => z().map((h) => h?.getRootNode()), "click", (h) => R(z().some((L) => L?.contains(h.target)))), L;
+}
+function useMutation(h, L, R) {
+	let z = createSignal(R());
+	return createMutationObserver(h, L, (h) => z[1](R())), z[0];
+}
+function useTinykeys(h, L) {
+	createEventListener(h, "keydown", createKeybindingsHandler({ ...mapValues(L, (h) => (L) => {
+		L.preventDefault(), h(L);
+	}) }));
+}
+function useHistory([h, L]) {
+	let R = 1, z = createMutable({
+		index: -1,
+		history: []
+	}), B = () => (z.index = 0, z.history = [h()]), V = () => z.index > 0, H = () => z.index < z.history.length - 1;
+	return createRenderEffect(on(h, (h) => {
+		if (h != null) {
+			if (!R) return R = 1;
+			H() && (z.history = z.history.slice(0, z.index + 1)), z.history[++z.index] = h;
+		}
+	})), {
+		undo: () => V() && ((R = 0) || L(z.history[--z.index])),
+		redo: () => H() && ((R = 0) || L(z.history[++z.index])),
+		clear: B,
+		get index() {
+			return z.index;
+		},
+		get history() {
+			return z.history;
+		}
+	};
+}
+function useMemoState(h) {
+	let L = createMutable({});
+	return createComputed(() => {
+		let z = h();
+		untrack(() => batch(() => {
+			for (let h in L) h in z || delete L[h];
+			Object.assign(L, z);
+		}));
+	}), L;
+}
+export { model, toReactive, toSignle, useClicked, useDark, useHistory, useHover, useMemo, useMemoAsync, useMemoState, useMouseDown, useMutation, usePointerDrag, useSignle2, useTinykeys };

package/dist/hooks/useDir.d.ts

@@ -0,0 +1,11 @@
+import { type MaybeAccessor } from '@solid-primitives/utils';
+interface UseDirOptions {
+    ref: MaybeAccessor<HTMLElement | undefined>;
+    list?: MaybeAccessor<HTMLElement | undefined>;
+    loop?: boolean;
+    options?: EventListenerOptions;
+    defaultFirst?: boolean;
+}
+export declare function useDir(options: UseDirOptions): void;
+export declare function VDir(el: HTMLElement, options: any): void;
+export {};

package/dist/hooks/useDir.js

@@ -0,0 +1,42 @@
+import { createEffect, mergeProps } from "solid-js";
+import { createEventListener } from "@solid-primitives/event-listener";
+import { access } from "@solid-primitives/utils";
+import { createMutationObserver } from "@solid-primitives/mutation-observer";
+function useDir(a) {
+	a = mergeProps({ loop: !0 }, a);
+	let o = () => access(a.list) ?? access(a.ref), s = () => access(a.ref) ?? access(a.list);
+	createEffect(() => {
+		s().tabIndex > -1 || (s().tabIndex = 0);
+	}), createEventListener(s, "keydown", (e) => {
+		if (![
+			"ArrowDown",
+			"ArrowUp",
+			"Enter"
+		].includes(e.key)) return;
+		e.stopPropagation(), e.preventDefault();
+		let n = o()?.querySelector(".hover");
+		if (e.key == "Enter") {
+			n?.click();
+			return;
+		}
+		let r = e.key == "ArrowDown" ? n ? +n?.getAttribute("data-index") + 1 : 0 : e.key == "ArrowUp" ? n ? n?.getAttribute("data-index") - 1 : -1 : 0, i = o()?.querySelector(`[data-index='${r}']`);
+		i ? (n?.classList.remove("hover"), i.classList.add("hover")) : a.loop && (n?.classList.remove("hover"), r >= 0 ? o()?.querySelector("[data-index='0']")?.classList.add("hover") : [...o()?.querySelectorAll("[data-index]")].at(-1)?.classList.add("hover"));
+	}, a.options), createEffect(() => {
+		if (!a.defaultFirst) return;
+		let e = o();
+		if (!e) return;
+		let n = () => {
+			e.querySelector(".hover") || e.querySelector("[data-index]")?.classList.add("hover");
+		};
+		createMutationObserver(e, { childList: !0 }, n), n();
+	}), createEventListener(o, "mouseover", () => {
+		o()?.querySelector(".hover")?.classList.remove("hover");
+	});
+}
+function VDir(e, n) {
+	useDir({
+		...n(),
+		list: e
+	});
+}
+export { VDir, useDir };

package/dist/hooks/useSelector.d.ts

@@ -0,0 +1,16 @@
+interface UseSelectorOpt<T> {
+    value?: T;
+    onChange?: (v: T) => void;
+    multiple?: boolean;
+    selectable?: (v: any) => boolean;
+}
+export declare function useSelector<T = any>(opt: UseSelectorOpt<T>): {
+    clear: () => void;
+    set: (v: T) => void;
+    has: (key: any) => boolean;
+    add: (v: T) => void;
+    del: (v: T) => void;
+    toggle: (v: T) => void;
+    readonly value: T;
+};
+export {};

package/dist/hooks/useSelector.js

@@ -0,0 +1,69 @@
+import { toArr } from "../utils.js";
+import { createMemo, createSelector, createSignal } from "solid-js";
+var _Symbol$toStringTag, SingleSet = class {
+	static {
+		_Symbol$toStringTag = Symbol.toStringTag;
+	}
+	#value;
+	constructor(e) {
+		this[_Symbol$toStringTag] = "SingleSet", this.#value = Array.from(e || [])[0];
+	}
+	add(e) {
+		return this.#value = e, this;
+	}
+	clear() {
+		this.#value = void 0;
+	}
+	delete(e) {
+		return this.#value === e ? (this.#value = void 0, !0) : !1;
+	}
+	forEach(e) {
+		this.#value !== void 0 && e.call(this, this.#value, this.#value, this);
+	}
+	has(e) {
+		return this.#value === e;
+	}
+	get size() {
+		return this.#value === void 0 ? 0 : 1;
+	}
+	entries() {
+		return this.values();
+	}
+	keys() {
+		return this.values();
+	}
+	values() {
+		return this.#value === void 0 ? [].entries() : [[this.#value, this.#value]].entries();
+	}
+	[Symbol.iterator]() {
+		return this.values()[Symbol.iterator]();
+	}
+};
+function useSelector(a) {
+	let { value: o, onChange: s, multiple: c = !1, selectable: l } = a, u = c ? Set : SingleSet, [d, f] = createSignal(new u(toArr(o))), p = createSelector(d, (e, i) => i.has(e)), m = (e) => l ? l(e) : !0, h = () => {
+		f(new u()), s?.(b());
+	}, g = (i) => {
+		m(i) && (f(new u(toArr(i))), s?.(b()));
+	}, _ = (e) => {
+		if (!m(e)) return;
+		let i = new u(d());
+		i.add(e), f(i), s?.(b());
+	}, v = (e) => {
+		let i = new u(d());
+		i.delete(e), f(i), s?.(b());
+	}, y = (e) => {
+		p(e) ? v(e) : _(e);
+	}, b = createMemo(() => c ? Array.from(d()) : Array.from(d())[0]);
+	return {
+		clear: h,
+		set: g,
+		has: p,
+		add: _,
+		del: v,
+		toggle: y,
+		get value() {
+			return b();
+		}
+	};
+}
+export { useSelector };

package/dist/hooks/useSort.d.ts

@@ -0,0 +1,18 @@
+import { type MaybeAccessor } from '@solid-primitives/utils';
+type Awaitable<T> = T | Promise<T>;
+interface UseSortOption {
+    enable?: boolean;
+    guideLine: any;
+    draggable: (el: HTMLElement) => Awaitable<boolean>;
+    dragover: (el: HTMLElement) => boolean;
+    children: (el: HTMLElement) => HTMLElement[];
+    dragend: () => void;
+}
+export declare const useSort: (el: MaybeAccessor<HTMLElement | undefined>, opt: UseSortOption) => {
+    style: any;
+    drag: any;
+    over: any;
+    rel: any;
+    type: string;
+};
+export {};