@unicom-cloud/ui 0.8.168 → 0.8.170

package/draw/libs/jotai/vanilla/internals.js

@@ -0,0 +1,303 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+//#region components/pc/draw/libs/jotai/vanilla/internals.ts
+function e(e) {
+	return "init" in e;
+}
+function t(e) {
+	return !!e.write;
+}
+function n(e) {
+	return "v" in e || "e" in e;
+}
+function r(e) {
+	if ("e" in e) throw e.e;
+	return e.v;
+}
+var i = /* @__PURE__ */ new WeakMap();
+function a(e) {
+	return c(e) && !!i.get(e)?.[0];
+}
+function o(e) {
+	let t = i.get(e);
+	t?.[0] && (t[0] = !1, t[1].forEach((e) => e()));
+}
+function s(e, t) {
+	let n = i.get(e);
+	if (!n) {
+		n = [!0, /* @__PURE__ */ new Set()], i.set(e, n);
+		let t = () => {
+			n[0] = !1;
+		};
+		e.then(t, t);
+	}
+	n[1].add(t);
+}
+function c(e) {
+	return typeof e?.then == "function";
+}
+function l(e, t, n) {
+	if (!n.p.has(e)) {
+		n.p.add(e);
+		let r = () => n.p.delete(e);
+		t.then(r, r);
+	}
+}
+function u(e, t, n) {
+	let r = /* @__PURE__ */ new Set();
+	for (let t of n.get(e)?.t || []) r.add(t);
+	for (let e of t.p) r.add(e);
+	return r;
+}
+var d = (e, t, ...n) => t.read(...n), f = (e, t, ...n) => t.write(...n), p = (e, t) => {
+	if (t.INTERNAL_onInit) return t.INTERNAL_onInit(e);
+}, m = (e, t, n) => t.onMount?.(n), h = (e, t) => {
+	let n = k(e), r = n[0], i = n[6], a = n[9], o = r.get(t);
+	return o || (o = {
+		d: /* @__PURE__ */ new Map(),
+		p: /* @__PURE__ */ new Set(),
+		n: 0
+	}, r.set(t, o), i.i?.(t), a?.(e, t)), o;
+}, g = (e) => {
+	let t = k(e), n = t[1], r = t[3], i = t[4], a = t[5], o = t[6], s = t[13], c = [], l = (e) => {
+		try {
+			e();
+		} catch (e) {
+			c.push(e);
+		}
+	};
+	do {
+		o.f && l(o.f);
+		let t = /* @__PURE__ */ new Set(), c = t.add.bind(t);
+		r.forEach((e) => n.get(e)?.l?.forEach?.(c)), r.clear(), a.forEach(c), a.clear(), i.forEach(c), i.clear(), t.forEach(l), r.size && s(e);
+	} while (r.size || a.size || i.size);
+	if (c.length) throw AggregateError(c);
+}, _ = (e) => {
+	let t = k(e), n = t[1], r = t[2], i = t[3], a = t[11], o = t[14], s = t[17], c = [], l = /* @__PURE__ */ new WeakSet(), d = /* @__PURE__ */ new WeakSet(), f = Array.from(i);
+	for (; f.length;) {
+		let t = f[f.length - 1], i = a(e, t);
+		if (d.has(t)) {
+			f.pop();
+			continue;
+		}
+		if (l.has(t)) {
+			r.get(t) === i.n && c.push([t, i]), d.add(t), f.pop();
+			continue;
+		}
+		l.add(t);
+		for (let e of u(t, i, n)) l.has(e) || f.push(e);
+	}
+	for (let t = c.length - 1; t >= 0; --t) {
+		let [n, a] = c[t], l = !1;
+		for (let e of a.d.keys()) if (e !== n && i.has(e)) {
+			l = !0;
+			break;
+		}
+		l && (o(e, n), s(e, n)), r.delete(n);
+	}
+}, v = (i, o) => {
+	let u = k(i), d = u[1], f = u[2], p = u[3], m = u[6], h = u[7], g = u[11], _ = u[12], v = u[13], y = u[14], b = u[16], x = u[17], S = u[20], C = g(i, o);
+	if (n(C)) {
+		if (d.has(o) && f.get(o) !== C.n) return C;
+		let e = !1;
+		for (let [t, n] of C.d) if (y(i, t).n !== n) {
+			e = !0;
+			break;
+		}
+		if (!e) return C;
+	}
+	C.d.clear();
+	let w = !0;
+	function T() {
+		d.has(o) && (x(i, o), v(i), _(i));
+	}
+	function E(t) {
+		if (t === o) {
+			let a = g(i, t);
+			if (!n(a)) if (e(t)) S(i, t, t.init);
+			else throw Error("no atom init");
+			return r(a);
+		}
+		let s = y(i, t);
+		try {
+			return r(s);
+		} finally {
+			C.d.set(t, s.n), a(C.v) && l(o, C.v, s), d.has(o) && d.get(t)?.t?.add?.(o), w || T();
+		}
+	}
+	let D, O, A = {
+		get signal() {
+			return D ||= new AbortController(), D.signal;
+		},
+		get setSelf() {
+			return !O && t(o) && (O = (...e) => {
+				if (!w) try {
+					return b(i, o, ...e);
+				} finally {
+					v(i), _(i);
+				}
+			}), O;
+		}
+	}, j = C.n;
+	try {
+		let e = h(i, o, E, A);
+		return S(i, o, e), c(e) && (s(e, () => D?.abort?.()), e.then(T, T)), m.r?.(o), C;
+	} catch (e) {
+		return delete C.v, C.e = e, ++C.n, C;
+	} finally {
+		w = !1, j !== C.n && f.get(o) === j && (f.set(o, C.n), p.add(o), m.c?.(o));
+	}
+}, y = (e, t) => {
+	let n = k(e), r = n[1], i = n[2], a = n[11], o = [t];
+	for (; o.length;) {
+		let t = o.pop(), n = a(e, t);
+		for (let s of u(t, n, r)) {
+			let t = a(e, s);
+			i.set(s, t.n), o.push(s);
+		}
+	}
+}, b = (t, n, ...i) => {
+	let a = k(t), o = a[3], s = a[6], c = a[8], l = a[11], u = a[12], d = a[13], f = a[14], p = a[15], m = a[16], h = a[17], g = a[20], _ = !0, v = (e) => r(f(t, e)), y = (r, ...i) => {
+		let a = l(t, r);
+		try {
+			if (r === n) {
+				if (!e(r)) throw Error("atom not writable");
+				let n = a.n, c = i[0];
+				g(t, r, c), h(t, r), n !== a.n && (o.add(r), p(t, r), s.c?.(r));
+				return;
+			} else return m(t, r, ...i);
+		} finally {
+			_ || (d(t), u(t));
+		}
+	};
+	try {
+		return c(t, n, v, y, ...i);
+	} finally {
+		_ = !1;
+	}
+}, x = (e, t) => {
+	let n = k(e), r = n[1], i = n[3], o = n[6], s = n[11], c = n[15], l = n[18], u = n[19], d = s(e, t), f = r.get(t);
+	if (f && !a(d.v)) {
+		for (let [n, r] of d.d) if (!f.d.has(n)) {
+			let a = s(e, n);
+			l(e, n).t.add(t), f.d.add(n), r !== a.n && (i.add(n), c(e, n), o.c?.(n));
+		}
+		for (let n of f.d) d.d.has(n) || (f.d.delete(n), u(e, n)?.t?.delete?.(t));
+	}
+}, S = (e, n) => {
+	let r = k(e), i = r[1], a = r[4], o = r[6], s = r[10], c = r[11], l = r[12], u = r[13], d = r[14], f = r[16], p = r[18], m = c(e, n), h = i.get(n);
+	if (!h) {
+		d(e, n);
+		for (let t of m.d.keys()) p(e, t).t.add(n);
+		h = {
+			l: /* @__PURE__ */ new Set(),
+			d: new Set(m.d.keys()),
+			t: /* @__PURE__ */ new Set()
+		}, i.set(n, h), t(n) && a.add(() => {
+			let t = !0, r = (...r) => {
+				try {
+					return f(e, n, ...r);
+				} finally {
+					t || (u(e), l(e));
+				}
+			};
+			try {
+				let i = s(e, n, r);
+				i && (h.u = () => {
+					t = !0;
+					try {
+						i();
+					} finally {
+						t = !1;
+					}
+				});
+			} finally {
+				t = !1;
+			}
+		}), o.m?.(n);
+	}
+	return h;
+}, C = (e, t) => {
+	let n = k(e), r = n[1], i = n[5], a = n[6], o = n[11], s = n[19], c = o(e, t), l = r.get(t);
+	if (!l || l.l.size) return l;
+	let u = !1;
+	for (let e of l.t) if (r.get(e)?.d?.has?.(t)) {
+		u = !0;
+		break;
+	}
+	if (!u) {
+		l.u && i.add(l.u), l = void 0, r.delete(t);
+		for (let n of c.d.keys()) s(e, n)?.t?.delete?.(t);
+		a.u?.(t);
+		return;
+	}
+	return l;
+}, w = (e, t, n) => {
+	let r = k(e)[11], i = r(e, t), a = "v" in i, s = i.v;
+	if (c(n)) for (let a of i.d.keys()) l(t, n, r(e, a));
+	i.v = n, delete i.e, (!a || !Object.is(s, i.v)) && (++i.n, c(s) && o(s));
+}, T = (e, t) => {
+	let n = k(e)[14];
+	return r(n(e, t));
+}, E = (e, t, ...n) => {
+	let r = k(e), i = r[12], a = r[13], o = r[16];
+	try {
+		return o(e, t, ...n);
+	} finally {
+		a(e), i(e);
+	}
+}, D = (e, t, n) => {
+	let r = k(e), i = r[12], a = r[18], o = r[19], s = a(e, t).l;
+	return s.add(n), i(e), () => {
+		s.delete(n), o(e, t), i(e);
+	};
+}, O = /* @__PURE__ */ new WeakMap(), k = (e) => O.get(e);
+function A(e) {
+	let t = k(e), n = t[24];
+	return n ? n(t) : t;
+}
+function j(...e) {
+	let t = {
+		get(e) {
+			let n = k(t)[21];
+			return n(t, e);
+		},
+		set(e, ...n) {
+			let r = k(t)[22];
+			return r(t, e, ...n);
+		},
+		sub(e, n) {
+			let r = k(t)[23];
+			return r(t, e, n);
+		}
+	}, n = [
+		/* @__PURE__ */ new WeakMap(),
+		/* @__PURE__ */ new WeakMap(),
+		/* @__PURE__ */ new WeakMap(),
+		/* @__PURE__ */ new Set(),
+		/* @__PURE__ */ new Set(),
+		/* @__PURE__ */ new Set(),
+		{},
+		d,
+		f,
+		p,
+		m,
+		h,
+		g,
+		_,
+		v,
+		y,
+		b,
+		x,
+		S,
+		C,
+		w,
+		T,
+		E,
+		D,
+		void 0
+	].map((t, n) => e[n] || t);
+	return O.set(t, Object.freeze(n)), t;
+}
+//#endregion
+export { j as buildStore, A as getBuildingBlocks, s as registerAbortHandler };
+/* 独立思考，明辨是非 */

package/draw/libs/jotai/vanilla/store.d.ts

@@ -0,0 +1,5 @@
+import type { INTERNAL_Store } from './internals.ts';
+export type Store = INTERNAL_Store;
+export declare function INTERNAL_overrideCreateStore(fn: (prev: typeof createStore | undefined) => typeof createStore): void;
+export declare function createStore(): Store;
+export declare function getDefaultStore(): Store;

package/draw/libs/jotai/vanilla/store.js

@@ -0,0 +1,17 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import { buildStore as e } from "./internals.js";
+//#region components/pc/draw/libs/jotai/vanilla/store.ts
+var t;
+function n(e) {
+	t = e(t);
+}
+function r() {
+	return t ? t() : e();
+}
+var i;
+function a() {
+	return i ||= r(), i;
+}
+//#endregion
+export { n as INTERNAL_overrideCreateStore, r as createStore, a as getDefaultStore };
+/* 独立思考，明辨是非 */

package/draw/libs/jotai/vanilla/typeUtils.d.ts

@@ -0,0 +1,7 @@
+import type { Atom, PrimitiveAtom, WritableAtom } from './atom.ts';
+export type Getter = Parameters<Atom<unknown>['read']>[0];
+export type Setter = Parameters<WritableAtom<unknown, unknown[], unknown>['write']>[1];
+export type ExtractAtomValue<AtomType> = AtomType extends Atom<infer Value> ? Value : never;
+export type ExtractAtomArgs<AtomType> = AtomType extends WritableAtom<unknown, infer Args, infer _Result> ? Args : never;
+export type ExtractAtomResult<AtomType> = AtomType extends WritableAtom<unknown, infer _Args, infer Result> ? Result : never;
+export type SetStateAction<Value> = ExtractAtomArgs<PrimitiveAtom<Value>>[0];

package/draw/libs/jotai/vanilla/utils/atomFamily.d.ts

@@ -0,0 +1,55 @@
+import type { Atom } from '../../vanilla.ts';
+/**
+ * in milliseconds
+ */
+type CreatedAt = number;
+type ShouldRemove<Param> = (createdAt: CreatedAt, param: Param) => boolean;
+type Cleanup = () => void;
+type Callback<Param, AtomType> = (event: {
+    type: 'CREATE' | 'REMOVE';
+    param: Param;
+    atom: AtomType;
+}) => void;
+/**
+ * @deprecated atomFamily is deprecated and will be removed in v3.
+ * Please use the `jotai-family` package instead: https://github.com/jotaijs/jotai-family
+ *
+ * Install: `npm install jotai-family`
+ *
+ * Migration:
+ * ```ts
+ * // Before
+ * import { atomFamily } from 'jotai/utils'
+ *
+ * // After
+ * import { atomFamily } from 'jotai-family'
+ * ```
+ */
+export interface AtomFamily<Param, AtomType> {
+    (param: Param): AtomType;
+    getParams(): Iterable<Param>;
+    remove(param: Param): void;
+    setShouldRemove(shouldRemove: ShouldRemove<Param> | null): void;
+    /**
+     * fires when an atom is created or removed
+     * This API is for advanced use cases, and can change without notice.
+     */
+    unstable_listen(callback: Callback<Param, AtomType>): Cleanup;
+}
+/**
+ * @deprecated atomFamily is deprecated and will be removed in v3.
+ * Please use the `jotai-family` package instead: https://github.com/jotaijs/jotai-family
+ *
+ * Install: `npm install jotai-family`
+ *
+ * Migration:
+ * ```ts
+ * // Before
+ * import { atomFamily } from 'jotai/utils'
+ *
+ * // After
+ * import { atomFamily } from 'jotai-family'
+ * ```
+ */
+export declare function atomFamily<Param, AtomType extends Atom<unknown>>(initializeAtom: (param: Param) => AtomType, areEqual?: (a: Param, b: Param) => boolean): AtomFamily<Param, AtomType>;
+export {};

package/draw/libs/jotai/vanilla/utils/atomFamily.js

@@ -0,0 +1,3 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import "lodash/isUndefined";
+/* 独立思考，明辨是非 */

package/draw/libs/jotai/vanilla/utils/atomWithDefault.d.ts

@@ -0,0 +1,6 @@
+import type { WritableAtom } from '../../vanilla.ts';
+import { RESET } from './constants.ts';
+type Read<Value, Args extends unknown[], Result> = WritableAtom<Value, Args, Result>['read'];
+type DefaultSetStateAction<Value> = Value | typeof RESET | ((prev: Value) => Value | typeof RESET);
+export declare function atomWithDefault<Value>(getDefault: Read<Value, [DefaultSetStateAction<Value>], void>): WritableAtom<Value, [DefaultSetStateAction<Value>], void>;
+export {};

package/draw/libs/jotai/vanilla/utils/atomWithLazy.d.ts

@@ -0,0 +1,2 @@
+import type { PrimitiveAtom } from '../../vanilla.ts';
+export declare function atomWithLazy<Value>(makeInitial: () => Value): PrimitiveAtom<Value>;

package/draw/libs/jotai/vanilla/utils/atomWithObservable.d.ts

@@ -0,0 +1,32 @@
+import type { Atom, Getter, WritableAtom } from '../../vanilla.ts';
+type AnyError = unknown;
+type Subscription = {
+    unsubscribe: () => void;
+};
+type Observer<T> = {
+    next: (value: T) => void;
+    error: (error: AnyError) => void;
+    complete: () => void;
+};
+type ObservableLike<T> = {
+    subscribe(observer: Observer<T>): Subscription;
+} | {
+    subscribe(observer: Partial<Observer<T>>): Subscription;
+} | {
+    subscribe(observer: Partial<Observer<T>>): Subscription;
+    subscribe(next: (value: T) => void): Subscription;
+};
+type SubjectLike<T> = ObservableLike<T> & Observer<T>;
+type Options<Data> = {
+    initialValue?: Data | (() => Data);
+    unstable_timeout?: number;
+};
+type OptionsWithInitialValue<Data> = {
+    initialValue: Data | (() => Data);
+    unstable_timeout?: number;
+};
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => SubjectLike<Data>, options: OptionsWithInitialValue<Data>): WritableAtom<Data, [Data], void>;
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => SubjectLike<Data>, options?: Options<Data>): WritableAtom<Data | Promise<Data>, [Data], void>;
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => ObservableLike<Data>, options: OptionsWithInitialValue<Data>): Atom<Data>;
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => ObservableLike<Data>, options?: Options<Data>): Atom<Data | Promise<Data>>;
+export {};

package/draw/libs/jotai/vanilla/utils/atomWithReducer.d.ts

@@ -0,0 +1,3 @@
+import type { WritableAtom } from '../../vanilla.ts';
+export declare function atomWithReducer<Value, Action>(initialValue: Value, reducer: (value: Value, action?: Action) => Value): WritableAtom<Value, [Action?], void>;
+export declare function atomWithReducer<Value, Action>(initialValue: Value, reducer: (value: Value, action: Action) => Value): WritableAtom<Value, [Action], void>;

package/draw/libs/jotai/vanilla/utils/atomWithRefresh.d.ts

@@ -0,0 +1,6 @@
+import type { WritableAtom } from '../../vanilla.ts';
+type Read<Value, Args extends unknown[], Result> = WritableAtom<Value, Args, Result>['read'];
+type Write<Value, Args extends unknown[], Result> = WritableAtom<Value, Args, Result>['write'];
+export declare function atomWithRefresh<Value, Args extends unknown[], Result>(read: Read<Value, Args, Result>, write: Write<Value, Args, Result>): WritableAtom<Value, Args | [], Result | void>;
+export declare function atomWithRefresh<Value>(read: Read<Value, [], void>): WritableAtom<Value, [], void>;
+export {};

package/draw/libs/jotai/vanilla/utils/atomWithReset.d.ts

@@ -0,0 +1,8 @@
+import type { WritableAtom } from '../../vanilla.ts';
+import { RESET } from './constants.ts';
+type SetStateActionWithReset<Value> = Value | typeof RESET | ((prev: Value) => Value | typeof RESET);
+type WithInitialValue<Value> = {
+    init: Value;
+};
+export declare function atomWithReset<Value>(initialValue: Value): WritableAtom<Value, [SetStateActionWithReset<Value>], void> & WithInitialValue<Value>;
+export {};

package/draw/libs/jotai/vanilla/utils/atomWithStorage.d.ts

@@ -0,0 +1,50 @@
+import type { WritableAtom } from '../../vanilla.ts';
+import { RESET } from './constants.ts';
+type Unsubscribe = () => void;
+type Subscribe<Value> = (key: string, callback: (value: Value) => void, initialValue: Value) => Unsubscribe | undefined;
+type StringSubscribe = (key: string, callback: (value: string | null) => void) => Unsubscribe | undefined;
+type SetStateActionWithReset<Value> = Value | typeof RESET | ((prev: Value) => Value | typeof RESET);
+export interface AsyncStorage<Value> {
+    getItem: (key: string, initialValue: Value) => PromiseLike<Value>;
+    setItem: (key: string, newValue: Value) => PromiseLike<void>;
+    removeItem: (key: string) => PromiseLike<void>;
+    subscribe?: Subscribe<Value>;
+}
+export interface SyncStorage<Value> {
+    getItem: (key: string, initialValue: Value) => Value;
+    setItem: (key: string, newValue: Value) => void;
+    removeItem: (key: string) => void;
+    subscribe?: Subscribe<Value>;
+}
+export interface AsyncStringStorage {
+    getItem: (key: string) => PromiseLike<string | null>;
+    setItem: (key: string, newValue: string) => PromiseLike<void>;
+    removeItem: (key: string) => PromiseLike<void>;
+    subscribe?: StringSubscribe;
+}
+export interface SyncStringStorage {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, newValue: string) => void;
+    removeItem: (key: string) => void;
+    subscribe?: StringSubscribe;
+}
+export declare function withStorageValidator<Value>(validator: (value: unknown) => value is Value): {
+    (storage: AsyncStorage<unknown>): AsyncStorage<Value>;
+    (storage: SyncStorage<unknown>): SyncStorage<Value>;
+};
+type JsonStorageOptions = {
+    reviver?: (key: string, value: unknown) => unknown;
+    replacer?: (key: string, value: unknown) => unknown;
+};
+export declare function createJSONStorage<Value>(): SyncStorage<Value>;
+export declare function createJSONStorage<Value>(getStringStorage: () => AsyncStringStorage, options?: JsonStorageOptions): AsyncStorage<Value>;
+export declare function createJSONStorage<Value>(getStringStorage: () => SyncStringStorage, options?: JsonStorageOptions): SyncStorage<Value>;
+export declare function atomWithStorage<Value>(key: string, initialValue: Value, storage: AsyncStorage<Value>, options?: {
+    getOnInit?: boolean;
+}): WritableAtom<Value | Promise<Value>, [
+    SetStateActionWithReset<Value | Promise<Value>>
+], Promise<void>>;
+export declare function atomWithStorage<Value>(key: string, initialValue: Value, storage?: SyncStorage<Value>, options?: {
+    getOnInit?: boolean;
+}): WritableAtom<Value, [SetStateActionWithReset<Value>], void>;
+export {};

package/draw/libs/jotai/vanilla/utils/atomWithStorage.js

@@ -0,0 +1,53 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+//#region components/pc/draw/libs/jotai/vanilla/utils/atomWithStorage.ts
+var e = (e) => typeof e?.then == "function";
+function t(t = () => {
+	try {
+		return window.localStorage;
+	} catch {
+		return;
+	}
+}, n) {
+	let r, i, a = {
+		getItem: (a, o) => {
+			let s = (e) => {
+				if (e ||= "", r !== e) {
+					try {
+						i = JSON.parse(e, n?.reviver);
+					} catch {
+						return o;
+					}
+					r = e;
+				}
+				return i;
+			}, c = t()?.getItem?.(a) ?? null;
+			return e(c) ? c.then(s) : s(c);
+		},
+		setItem: (e, r) => t()?.setItem?.(e, JSON.stringify(r, n?.replacer)),
+		removeItem: (e) => t()?.removeItem?.(e)
+	}, o = (e) => (t, n, r) => e(t, (e) => {
+		let t;
+		try {
+			t = JSON.parse(e || "");
+		} catch {
+			t = r;
+		}
+		n(t);
+	}), s;
+	try {
+		s = t()?.subscribe;
+	} catch {}
+	return !s && typeof window < "u" && typeof window.addEventListener == "function" && window.Storage && (s = (e, n) => {
+		if (!(t() instanceof window.Storage)) return () => {};
+		let r = (r) => {
+			r.storageArea === t() && r.key === e && n(r.newValue);
+		};
+		return window.addEventListener("storage", r), () => {
+			window.removeEventListener("storage", r);
+		};
+	}), s && (a.subscribe = o(s)), a;
+}
+t();
+//#endregion
+export { t as createJSONStorage };
+/* 独立思考，明辨是非 */

package/draw/libs/jotai/vanilla/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const RESET: unique symbol;

package/draw/libs/jotai/vanilla/utils/freezeAtom.d.ts

@@ -0,0 +1,6 @@
+import type { Atom } from '../../vanilla.ts';
+export declare function freezeAtom<AtomType extends Atom<unknown>>(anAtom: AtomType): AtomType;
+/**
+ * @deprecated Define it on users end
+ */
+export declare function freezeAtomCreator<CreateAtom extends (...args: unknown[]) => Atom<unknown>>(createAtom: CreateAtom): CreateAtom;

package/draw/libs/jotai/vanilla/utils/loadable.d.ts

@@ -0,0 +1,33 @@
+import type { Atom } from '../../vanilla.ts';
+export type Loadable<Value> = {
+    state: 'loading';
+} | {
+    state: 'hasError';
+    error: unknown;
+} | {
+    state: 'hasData';
+    data: Awaited<Value>;
+};
+/**
+ * @deprecated `loadable` is deprecated infavor of `unwrap`.
+ *
+ * Userland implementation of loadable:
+ * ```js
+ * function loadable(anAtom) {
+ *   const LOADING = { state: 'loading' }
+ *   const unwrappedAtom = unwrap(anAtom, () => LOADING)
+ *   return atom((get) => {
+ *     try {
+ *       const data = get(unwrappedAtom)
+ *       if (data === LOADING) {
+ *         return LOADING
+ *       }
+ *       return { state: 'hasData', data }
+ *     } catch (error) {
+ *       return { state: 'hasError', error }
+ *     }
+ *   })
+ * }
+ * ```
+ */
+export declare function loadable<Value>(anAtom: Atom<Value>): Atom<Loadable<Value>>;

package/draw/libs/jotai/vanilla/utils/selectAtom.d.ts

@@ -0,0 +1,2 @@
+import type { Atom } from '../../vanilla.ts';
+export declare function selectAtom<Value, Slice>(anAtom: Atom<Value>, selector: (v: Value, prevSlice?: Slice) => Slice, equalityFn?: (a: Slice, b: Slice) => boolean): Atom<Slice>;

package/draw/libs/jotai/vanilla/utils/splitAtom.d.ts

@@ -0,0 +1,16 @@
+import type { Atom, PrimitiveAtom, WritableAtom } from '../../vanilla.ts';
+type SplitAtomAction<Item> = {
+    type: 'remove';
+    atom: PrimitiveAtom<Item>;
+} | {
+    type: 'insert';
+    value: Item;
+    before?: PrimitiveAtom<Item>;
+} | {
+    type: 'move';
+    atom: PrimitiveAtom<Item>;
+    before?: PrimitiveAtom<Item>;
+};
+export declare function splitAtom<Item, Key>(arrAtom: WritableAtom<Item[], [Item[]], void>, keyExtractor?: (item: Item) => Key): WritableAtom<PrimitiveAtom<Item>[], [SplitAtomAction<Item>], void>;
+export declare function splitAtom<Item, Key>(arrAtom: Atom<Item[]>, keyExtractor?: (item: Item) => Key): Atom<Atom<Item>[]>;
+export {};

package/draw/libs/jotai/vanilla/utils/unwrap.d.ts

@@ -0,0 +1,5 @@
+import type { Atom, WritableAtom } from '../../vanilla.ts';
+export declare function unwrap<Value, Args extends unknown[], Result>(anAtom: WritableAtom<Value, Args, Result>): WritableAtom<Awaited<Value> | undefined, Args, Result>;
+export declare function unwrap<Value, Args extends unknown[], Result, PendingValue>(anAtom: WritableAtom<Value, Args, Result>, fallback: (prev?: Awaited<Value>) => PendingValue): WritableAtom<Awaited<Value> | PendingValue, Args, Result>;
+export declare function unwrap<Value>(anAtom: Atom<Value>): Atom<Awaited<Value> | undefined>;
+export declare function unwrap<Value, PendingValue>(anAtom: Atom<Value>, fallback: (prev?: Awaited<Value>) => PendingValue): Atom<Awaited<Value> | PendingValue>;

package/draw/libs/jotai/vanilla/utils.d.ts

@@ -0,0 +1,14 @@
+export { atomFamily } from './utils/atomFamily.ts';
+export { atomWithDefault } from './utils/atomWithDefault.ts';
+export { atomWithLazy } from './utils/atomWithLazy.ts';
+export { atomWithObservable } from './utils/atomWithObservable.ts';
+export { atomWithReducer } from './utils/atomWithReducer.ts';
+export { atomWithRefresh } from './utils/atomWithRefresh.ts';
+export { atomWithReset } from './utils/atomWithReset.ts';
+export { atomWithStorage, createJSONStorage, withStorageValidator as unstable_withStorageValidator, } from './utils/atomWithStorage.ts';
+export { RESET } from './utils/constants.ts';
+export { freezeAtom, freezeAtomCreator } from './utils/freezeAtom.ts';
+export { loadable } from './utils/loadable.ts';
+export { selectAtom } from './utils/selectAtom.ts';
+export { splitAtom } from './utils/splitAtom.ts';
+export { unwrap } from './utils/unwrap.ts';

package/draw/libs/jotai/vanilla/utils.js

@@ -0,0 +1,4 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import "./utils/atomFamily.js";
+import "./utils/atomWithStorage.js";
+/* 独立思考，明辨是非 */

package/draw/libs/jotai/vanilla.d.ts

@@ -0,0 +1,4 @@
+export { atom } from './vanilla/atom.ts';
+export type { Atom, WritableAtom, PrimitiveAtom } from './vanilla/atom.ts';
+export { createStore, getDefaultStore, INTERNAL_overrideCreateStore, } from './vanilla/store.ts';
+export type { Getter, Setter, ExtractAtomValue, ExtractAtomArgs, ExtractAtomResult, SetStateAction, } from './vanilla/typeUtils.ts';