@usels/core 0.0.1

package/dist/function/peek/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var peek_exports = {};
+__export(peek_exports, {
+  peek: () => peek
+});
+module.exports = __toCommonJS(peek_exports);
+var import_state = require("@legendapp/state");
+function peek(maybeObservable, key) {
+  const value = (0, import_state.isObservable)(maybeObservable) ? maybeObservable.peek() : maybeObservable;
+  if (key === void 0) {
+    return value;
+  }
+  if (value !== null && value !== void 0 && typeof value === "object") {
+    return value[key];
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  peek
+});
+//# sourceMappingURL=index.js.map

package/dist/function/peek/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/function/peek/index.ts"],"sourcesContent":["import { isObservable } from \"@legendapp/state\";\nimport { MaybeObservable } from \"../../types\";\n\n/**\n * Extracts the value from a MaybeObservable **without** registering a tracking dependency.\n * If the value is an Observable, calls `.peek()` to extract it non-reactively.\n * Otherwise returns the value as-is.\n *\n * Use this for mount-time-only options that should not trigger re-runs when changed.\n * Prefer `get()` inside reactive contexts (`useObserve`, `useObservable`) when reactivity is needed.\n *\n * @param maybeObservable - A value that might be an Observable\n * @returns The extracted value (no tracking dependency registered)\n *\n * @example\n * ```ts\n * import { observable } from '@legendapp/state'\n * import { peek } from '@usels/core'\n *\n * const value = peek('hello')           // 'hello'\n * const obsValue = peek(observable(42)) // 42  — no dep registered\n * ```\n */\nexport function peek<T>(maybeObservable: MaybeObservable<T>): T;\nexport function peek<T>(maybeObservable: MaybeObservable<T> | undefined): T | undefined;\n\n/**\n * Extracts a property value from a MaybeObservable object **without** registering a tracking dependency.\n *\n * @param maybeObservable - A value that might be an Observable\n * @param key - The property key to extract\n * @returns The property value, or undefined if not found\n *\n * @example\n * ```ts\n * import { observable } from '@legendapp/state'\n * import { peek } from '@usels/core'\n *\n * const obs$ = observable({ initialValue: true, rootMargin: '0px' })\n *\n * peek(obs$, 'initialValue')  // true  — no dep registered (mount-time-only read)\n * peek(obs$, 'rootMargin')    // '0px' — no dep registered\n * ```\n */\nexport function peek<T, K extends keyof T>(\n  maybeObservable: MaybeObservable<T>,\n  key: K,\n): T[K] | undefined;\n\n// Implementation\nexport function peek<T>(\n  maybeObservable: MaybeObservable<T>,\n  key?: keyof T,\n): any {\n  // Extract the base value without registering a tracking dependency\n  const value = isObservable(maybeObservable)\n    ? maybeObservable.peek()\n    : maybeObservable;\n\n  if (key === undefined) {\n    return value;\n  }\n\n  if (value !== null && value !== undefined && typeof value === \"object\") {\n    return (value as any)[key];\n  }\n\n  return undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA6B;AAkDtB,SAAS,KACd,iBACA,KACK;AAEL,QAAM,YAAQ,2BAAa,eAAe,IACtC,gBAAgB,KAAK,IACrB;AAEJ,MAAI,QAAQ,QAAW;AACrB,WAAO;AAAA,EACT;AAEA,MAAI,UAAU,QAAQ,UAAU,UAAa,OAAO,UAAU,UAAU;AACtE,WAAQ,MAAc,GAAG;AAAA,EAC3B;AAEA,SAAO;AACT;","names":[]}

package/dist/function/peek/index.mjs

@@ -0,0 +1,15 @@
+import { isObservable } from "@legendapp/state";
+function peek(maybeObservable, key) {
+  const value = isObservable(maybeObservable) ? maybeObservable.peek() : maybeObservable;
+  if (key === void 0) {
+    return value;
+  }
+  if (value !== null && value !== void 0 && typeof value === "object") {
+    return value[key];
+  }
+  return void 0;
+}
+export {
+  peek
+};
+//# sourceMappingURL=index.mjs.map

package/dist/function/peek/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/function/peek/index.ts"],"sourcesContent":["import { isObservable } from \"@legendapp/state\";\nimport { MaybeObservable } from \"../../types\";\n\n/**\n * Extracts the value from a MaybeObservable **without** registering a tracking dependency.\n * If the value is an Observable, calls `.peek()` to extract it non-reactively.\n * Otherwise returns the value as-is.\n *\n * Use this for mount-time-only options that should not trigger re-runs when changed.\n * Prefer `get()` inside reactive contexts (`useObserve`, `useObservable`) when reactivity is needed.\n *\n * @param maybeObservable - A value that might be an Observable\n * @returns The extracted value (no tracking dependency registered)\n *\n * @example\n * ```ts\n * import { observable } from '@legendapp/state'\n * import { peek } from '@usels/core'\n *\n * const value = peek('hello')           // 'hello'\n * const obsValue = peek(observable(42)) // 42  — no dep registered\n * ```\n */\nexport function peek<T>(maybeObservable: MaybeObservable<T>): T;\nexport function peek<T>(maybeObservable: MaybeObservable<T> | undefined): T | undefined;\n\n/**\n * Extracts a property value from a MaybeObservable object **without** registering a tracking dependency.\n *\n * @param maybeObservable - A value that might be an Observable\n * @param key - The property key to extract\n * @returns The property value, or undefined if not found\n *\n * @example\n * ```ts\n * import { observable } from '@legendapp/state'\n * import { peek } from '@usels/core'\n *\n * const obs$ = observable({ initialValue: true, rootMargin: '0px' })\n *\n * peek(obs$, 'initialValue')  // true  — no dep registered (mount-time-only read)\n * peek(obs$, 'rootMargin')    // '0px' — no dep registered\n * ```\n */\nexport function peek<T, K extends keyof T>(\n  maybeObservable: MaybeObservable<T>,\n  key: K,\n): T[K] | undefined;\n\n// Implementation\nexport function peek<T>(\n  maybeObservable: MaybeObservable<T>,\n  key?: keyof T,\n): any {\n  // Extract the base value without registering a tracking dependency\n  const value = isObservable(maybeObservable)\n    ? maybeObservable.peek()\n    : maybeObservable;\n\n  if (key === undefined) {\n    return value;\n  }\n\n  if (value !== null && value !== undefined && typeof value === \"object\") {\n    return (value as any)[key];\n  }\n\n  return undefined;\n}\n"],"mappings":"AAAA,SAAS,oBAAoB;AAkDtB,SAAS,KACd,iBACA,KACK;AAEL,QAAM,QAAQ,aAAa,eAAe,IACtC,gBAAgB,KAAK,IACrB;AAEJ,MAAI,QAAQ,QAAW;AACrB,WAAO;AAAA,EACT;AAEA,MAAI,UAAU,QAAQ,UAAU,UAAa,OAAO,UAAU,UAAU;AACtE,WAAQ,MAAc,GAAG;AAAA,EAC3B;AAEA,SAAO;AACT;","names":[]}

package/dist/function/useMayObservableOptions/index.d.mts

@@ -0,0 +1,59 @@
+import { Observable } from '@legendapp/state';
+import { MaybeObservable, DeepMaybeObservable } from '../../types.mjs';
+
+/**
+ * Per-field resolution hint for the object-form transform.
+ *
+ * Resolution axis (`get` / `peek`):
+ * - `'get'`          — no-op; Legend-State auto-derefs the field Observable and registers the dep at the call site. **Default.**
+ * - `'peek'`         — `peek(fieldValue)` — no dep, mount-time-only snapshot.
+ *
+ * Legend-State wrapping axis (dot-notation):
+ * - `'get.opaque'`   — `get()` then `ObservableHint.opaque()`. Null-safe.
+ * - `'get.plain'`    — `get()` then `ObservableHint.plain()`. Prevents nested auto-deref. Null-safe.
+ * - `'get.function'` — `get()` then `ObservableHint.function()`. For callbacks. Null-safe.
+ * - `'get.element'`  — `getElement(fieldValue)` (reactive) then `ObservableHint.opaque()`. For MaybeElement.
+ * - `'peek.element'` — `peekElement(fieldValue)` (non-reactive) then `ObservableHint.opaque()`. For MaybeElement.
+ *
+ * Escape hatch:
+ * - `(value) => R`   — custom transform function.
+ */
+type FieldHint<V = any, R = any> = "get" | "peek" | "get.opaque" | "get.plain" | "get.function" | "get.element" | "peek.element" | ((value: MaybeObservable<V>) => R);
+/**
+ * Maps each field of `T` to a `FieldHint`.
+ * Fields not specified default to `'get'` (reactive resolution via Legend-State auto-deref).
+ */
+type FieldTransformMap<T> = {
+    [K in keyof T]?: FieldHint<T[K], any>;
+};
+/**
+ * The `transform` parameter for `useMayObservableOptions`.
+ * - **Object form:** declarative per-field hints — `FieldTransformMap<T>`.
+ * - **Function form:** full custom compute — `(current) => T | undefined`.
+ */
+type Transform<T> = FieldTransformMap<T> | ((current: DeepMaybeObservable<T> | undefined) => T | undefined);
+/**
+ * Normalizes `DeepMaybeObservable<T>` into a stable computed `Observable<T | undefined>`.
+ *
+ * Handles three cases without interference:
+ * - **Outer `Observable<T>`** — tracked via `.get()` dep inside the compute fn
+ * - **Per-field `{ field: Observable<T[K]> }`** — tracked via explicit `get()` per field
+ * - **Plain value changing between renders** — tracked via Symbol depKey (React-level)
+ *
+ * The Symbol depKey prevents Legend-State from auto-deref'ing inner Observables
+ * inside `depsObs$`, which would break per-field dep tracking if the raw `options`
+ * object were passed directly as the dep array item.
+ *
+ * @param options - DeepMaybeObservable options to normalize
+ * @param transform - Optional transform. Two forms:
+ *   - **Object form:** `FieldTransformMap<T>` — per-field hints (`'peek'`, `'get.opaque'`, etc.).
+ *     Defaults to `'get'` for unspecified fields.
+ *     **Note:** has no effect when `options` is an outer `Observable<T>` — in that case the
+ *     proxy is returned as-is (same as no transform), preserving Legend-State's
+ *     reference-equality tracking behavior. Use per-field Observables or plain objects
+ *     when field-level hints are needed.
+ *   - **Function form:** `(current) => T | undefined` — full custom compute for complex cases.
+ */
+declare function useMayObservableOptions<T>(options: DeepMaybeObservable<T> | undefined, transform?: Transform<T>): Observable<T | undefined>;
+
+export { type FieldHint, type FieldTransformMap, type Transform, useMayObservableOptions };

package/dist/function/useMayObservableOptions/index.d.ts

@@ -0,0 +1,59 @@
+import { Observable } from '@legendapp/state';
+import { MaybeObservable, DeepMaybeObservable } from '../../types.js';
+
+/**
+ * Per-field resolution hint for the object-form transform.
+ *
+ * Resolution axis (`get` / `peek`):
+ * - `'get'`          — no-op; Legend-State auto-derefs the field Observable and registers the dep at the call site. **Default.**
+ * - `'peek'`         — `peek(fieldValue)` — no dep, mount-time-only snapshot.
+ *
+ * Legend-State wrapping axis (dot-notation):
+ * - `'get.opaque'`   — `get()` then `ObservableHint.opaque()`. Null-safe.
+ * - `'get.plain'`    — `get()` then `ObservableHint.plain()`. Prevents nested auto-deref. Null-safe.
+ * - `'get.function'` — `get()` then `ObservableHint.function()`. For callbacks. Null-safe.
+ * - `'get.element'`  — `getElement(fieldValue)` (reactive) then `ObservableHint.opaque()`. For MaybeElement.
+ * - `'peek.element'` — `peekElement(fieldValue)` (non-reactive) then `ObservableHint.opaque()`. For MaybeElement.
+ *
+ * Escape hatch:
+ * - `(value) => R`   — custom transform function.
+ */
+type FieldHint<V = any, R = any> = "get" | "peek" | "get.opaque" | "get.plain" | "get.function" | "get.element" | "peek.element" | ((value: MaybeObservable<V>) => R);
+/**
+ * Maps each field of `T` to a `FieldHint`.
+ * Fields not specified default to `'get'` (reactive resolution via Legend-State auto-deref).
+ */
+type FieldTransformMap<T> = {
+    [K in keyof T]?: FieldHint<T[K], any>;
+};
+/**
+ * The `transform` parameter for `useMayObservableOptions`.
+ * - **Object form:** declarative per-field hints — `FieldTransformMap<T>`.
+ * - **Function form:** full custom compute — `(current) => T | undefined`.
+ */
+type Transform<T> = FieldTransformMap<T> | ((current: DeepMaybeObservable<T> | undefined) => T | undefined);
+/**
+ * Normalizes `DeepMaybeObservable<T>` into a stable computed `Observable<T | undefined>`.
+ *
+ * Handles three cases without interference:
+ * - **Outer `Observable<T>`** — tracked via `.get()` dep inside the compute fn
+ * - **Per-field `{ field: Observable<T[K]> }`** — tracked via explicit `get()` per field
+ * - **Plain value changing between renders** — tracked via Symbol depKey (React-level)
+ *
+ * The Symbol depKey prevents Legend-State from auto-deref'ing inner Observables
+ * inside `depsObs$`, which would break per-field dep tracking if the raw `options`
+ * object were passed directly as the dep array item.
+ *
+ * @param options - DeepMaybeObservable options to normalize
+ * @param transform - Optional transform. Two forms:
+ *   - **Object form:** `FieldTransformMap<T>` — per-field hints (`'peek'`, `'get.opaque'`, etc.).
+ *     Defaults to `'get'` for unspecified fields.
+ *     **Note:** has no effect when `options` is an outer `Observable<T>` — in that case the
+ *     proxy is returned as-is (same as no transform), preserving Legend-State's
+ *     reference-equality tracking behavior. Use per-field Observables or plain objects
+ *     when field-level hints are needed.
+ *   - **Function form:** `(current) => T | undefined` — full custom compute for complex cases.
+ */
+declare function useMayObservableOptions<T>(options: DeepMaybeObservable<T> | undefined, transform?: Transform<T>): Observable<T | undefined>;
+
+export { type FieldHint, type FieldTransformMap, type Transform, useMayObservableOptions };

package/dist/function/useMayObservableOptions/index.js

@@ -0,0 +1,109 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useMayObservableOptions_exports = {};
+__export(useMayObservableOptions_exports, {
+  useMayObservableOptions: () => useMayObservableOptions
+});
+module.exports = __toCommonJS(useMayObservableOptions_exports);
+var import_state = require("@legendapp/state");
+var import_react = require("@legendapp/state/react");
+var import_react2 = require("react");
+var import_get = require("../get");
+var import_peek = require("../peek");
+var import_useRef = require("../../elements/useRef$");
+function applyObjectTransform(raw, map) {
+  if (raw == null) return void 0;
+  const result = { ...raw };
+  for (const key of Object.keys(result)) {
+    const hint = map[key];
+    const fieldValue = result[key];
+    switch (hint) {
+      case "peek":
+        result[key] = (0, import_peek.peek)(fieldValue);
+        break;
+      case "get.opaque": {
+        const v = (0, import_get.get)(fieldValue);
+        if (v != null) result[key] = import_state.ObservableHint.opaque(v);
+        break;
+      }
+      case "get.plain": {
+        const v = (0, import_get.get)(fieldValue);
+        if (v != null) result[key] = import_state.ObservableHint.plain(v);
+        break;
+      }
+      case "get.function": {
+        const v = (0, import_get.get)(fieldValue);
+        if (v != null)
+          result[key] = import_state.ObservableHint.function(
+            v
+          );
+        break;
+      }
+      case "get.element": {
+        if (fieldValue !== void 0) {
+          if ((0, import_state.isObservable)(fieldValue) && fieldValue.get() === void 0) {
+            result[key] = void 0;
+            break;
+          }
+          const el = (0, import_useRef.getElement)(fieldValue);
+          result[key] = el != null ? import_state.ObservableHint.opaque(el) : null;
+        }
+        break;
+      }
+      case "peek.element": {
+        if (fieldValue !== void 0) {
+          if ((0, import_state.isObservable)(fieldValue) && fieldValue.peek() === void 0) {
+            result[key] = void 0;
+            break;
+          }
+          const el = (0, import_useRef.peekElement)(fieldValue);
+          result[key] = el != null ? import_state.ObservableHint.opaque(el) : null;
+        }
+        break;
+      }
+      default:
+        if (typeof hint === "function") {
+          result[key] = hint(fieldValue);
+        }
+    }
+  }
+  return result;
+}
+function useMayObservableOptions(options, transform) {
+  const optionsRef = (0, import_react2.useRef)(options);
+  optionsRef.current = options;
+  const depKey = (0, import_react2.useMemo)(() => /* @__PURE__ */ Symbol(), [options]);
+  const compute = () => {
+    if (typeof transform === "function") {
+      return transform(optionsRef.current);
+    }
+    const raw = optionsRef.current;
+    const resolved = (0, import_get.get)(raw);
+    if (transform != null && !(0, import_state.isObservable)(raw)) {
+      return applyObjectTransform(resolved, transform);
+    }
+    return resolved;
+  };
+  return (0, import_react.useObservable)(compute, [depKey]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useMayObservableOptions
+});
+//# sourceMappingURL=index.js.map

package/dist/function/useMayObservableOptions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/function/useMayObservableOptions/index.ts"],"sourcesContent":["import {\n  isObservable,\n  ObservableHint,\n  type Observable,\n} from \"@legendapp/state\";\nimport { useObservable } from \"@legendapp/state/react\";\nimport { useMemo, useRef } from \"react\";\nimport { get } from \"../get\";\nimport { peek } from \"../peek\";\nimport type { DeepMaybeObservable, MaybeObservable } from \"../../types\";\nimport { getElement, peekElement } from \"../../elements/useRef$\";\nimport type { MaybeElement } from \"../../elements/useRef$\";\n\n/**\n * Per-field resolution hint for the object-form transform.\n *\n * Resolution axis (`get` / `peek`):\n * - `'get'`          — no-op; Legend-State auto-derefs the field Observable and registers the dep at the call site. **Default.**\n * - `'peek'`         — `peek(fieldValue)` — no dep, mount-time-only snapshot.\n *\n * Legend-State wrapping axis (dot-notation):\n * - `'get.opaque'`   — `get()` then `ObservableHint.opaque()`. Null-safe.\n * - `'get.plain'`    — `get()` then `ObservableHint.plain()`. Prevents nested auto-deref. Null-safe.\n * - `'get.function'` — `get()` then `ObservableHint.function()`. For callbacks. Null-safe.\n * - `'get.element'`  — `getElement(fieldValue)` (reactive) then `ObservableHint.opaque()`. For MaybeElement.\n * - `'peek.element'` — `peekElement(fieldValue)` (non-reactive) then `ObservableHint.opaque()`. For MaybeElement.\n *\n * Escape hatch:\n * - `(value) => R`   — custom transform function.\n */\nexport type FieldHint<V = any, R = any> =\n  | \"get\"\n  | \"peek\"\n  | \"get.opaque\"\n  | \"get.plain\"\n  | \"get.function\"\n  | \"get.element\"\n  | \"peek.element\"\n  | ((value: MaybeObservable<V>) => R);\n\n/**\n * Maps each field of `T` to a `FieldHint`.\n * Fields not specified default to `'get'` (reactive resolution via Legend-State auto-deref).\n */\nexport type FieldTransformMap<T> = {\n  [K in keyof T]?: FieldHint<T[K], any>;\n};\n\n/**\n * The `transform` parameter for `useMayObservableOptions`.\n * - **Object form:** declarative per-field hints — `FieldTransformMap<T>`.\n * - **Function form:** full custom compute — `(current) => T | undefined`.\n */\nexport type Transform<T> =\n  | FieldTransformMap<T>\n  | ((current: DeepMaybeObservable<T> | undefined) => T | undefined);\n\nfunction applyObjectTransform<T>(\n  raw: T | undefined,\n  map: FieldTransformMap<T>,\n): T | undefined {\n  if (raw == null) return undefined;\n  const result = { ...raw } as Record<string, unknown>;\n  for (const key of Object.keys(result)) {\n    const hint = (map as Record<string, FieldHint>)[key];\n    const fieldValue = result[key] as MaybeObservable<unknown>;\n    switch (hint) {\n      case \"peek\":\n        result[key] = peek(fieldValue);\n        break;\n      case \"get.opaque\": {\n        const v = get(fieldValue);\n        if (v != null) result[key] = ObservableHint.opaque(v);\n        break;\n      }\n      case \"get.plain\": {\n        const v = get(fieldValue);\n        if (v != null) result[key] = ObservableHint.plain(v as object);\n        break;\n      }\n      case \"get.function\": {\n        const v = get(fieldValue);\n        if (v != null)\n          result[key] = ObservableHint.function(\n            v as (...args: unknown[]) => unknown,\n          );\n        break;\n      }\n      case \"get.element\": {\n        if (fieldValue !== undefined) {\n          // Observable resolving to undefined means \"not set\" — propagate undefined\n          if (isObservable(fieldValue) && (fieldValue as Observable<unknown>).get() === undefined) {\n            result[key] = undefined;\n            break;\n          }\n          const el = getElement(fieldValue as MaybeElement);\n          result[key] = el != null ? ObservableHint.opaque(el) : null;\n        }\n        break;\n      }\n      case \"peek.element\": {\n        if (fieldValue !== undefined) {\n          // Observable resolving to undefined means \"not set\" — propagate undefined\n          if (isObservable(fieldValue) && (fieldValue as Observable<unknown>).peek() === undefined) {\n            result[key] = undefined;\n            break;\n          }\n          const el = peekElement(fieldValue as MaybeElement);\n          result[key] = el != null ? ObservableHint.opaque(el) : null;\n        }\n        break;\n      }\n      default:\n        if (typeof hint === \"function\") {\n          result[key] = hint(fieldValue);\n        }\n        // 'get' or undefined → no action; Legend-State auto-derefs per-field Observables\n    }\n  }\n  return result as T;\n}\n\n/**\n * Normalizes `DeepMaybeObservable<T>` into a stable computed `Observable<T | undefined>`.\n *\n * Handles three cases without interference:\n * - **Outer `Observable<T>`** — tracked via `.get()` dep inside the compute fn\n * - **Per-field `{ field: Observable<T[K]> }`** — tracked via explicit `get()` per field\n * - **Plain value changing between renders** — tracked via Symbol depKey (React-level)\n *\n * The Symbol depKey prevents Legend-State from auto-deref'ing inner Observables\n * inside `depsObs$`, which would break per-field dep tracking if the raw `options`\n * object were passed directly as the dep array item.\n *\n * @param options - DeepMaybeObservable options to normalize\n * @param transform - Optional transform. Two forms:\n *   - **Object form:** `FieldTransformMap<T>` — per-field hints (`'peek'`, `'get.opaque'`, etc.).\n *     Defaults to `'get'` for unspecified fields.\n *     **Note:** has no effect when `options` is an outer `Observable<T>` — in that case the\n *     proxy is returned as-is (same as no transform), preserving Legend-State's\n *     reference-equality tracking behavior. Use per-field Observables or plain objects\n *     when field-level hints are needed.\n *   - **Function form:** `(current) => T | undefined` — full custom compute for complex cases.\n */\nexport function useMayObservableOptions<T>(\n  options: DeepMaybeObservable<T> | undefined,\n  transform?: Transform<T>,\n): Observable<T | undefined> {\n  const optionsRef = useRef(options);\n  optionsRef.current = options;\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  const depKey = useMemo(() => Symbol(), [options]);\n  const compute = (): T | undefined => {\n    if (typeof transform === \"function\") {\n      return transform(optionsRef.current);\n    }\n    const raw = optionsRef.current;\n    const resolved = get(raw as MaybeObservable<T> | undefined);\n    if (transform != null && !isObservable(raw)) {\n      // Object form — only applies when options is NOT an outer Observable.\n      // For outer Observable, returning the proxy as-is preserves the\n      // \"reference-equality tracking\" behavior: child-field mutations do not\n      // trigger opts$ recomputation (documented known Legend-State limitation).\n      // For per-field Observable or plain object, apply field hints.\n      return applyObjectTransform(resolved, transform);\n    }\n    return resolved;\n  };\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  return useObservable(compute, [depKey]) as unknown as Observable<\n    T | undefined\n  >;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAIO;AACP,mBAA8B;AAC9B,IAAAA,gBAAgC;AAChC,iBAAoB;AACpB,kBAAqB;AAErB,oBAAwC;AA+CxC,SAAS,qBACP,KACA,KACe;AACf,MAAI,OAAO,KAAM,QAAO;AACxB,QAAM,SAAS,EAAE,GAAG,IAAI;AACxB,aAAW,OAAO,OAAO,KAAK,MAAM,GAAG;AACrC,UAAM,OAAQ,IAAkC,GAAG;AACnD,UAAM,aAAa,OAAO,GAAG;AAC7B,YAAQ,MAAM;AAAA,MACZ,KAAK;AACH,eAAO,GAAG,QAAI,kBAAK,UAAU;AAC7B;AAAA,MACF,KAAK,cAAc;AACjB,cAAM,QAAI,gBAAI,UAAU;AACxB,YAAI,KAAK,KAAM,QAAO,GAAG,IAAI,4BAAe,OAAO,CAAC;AACpD;AAAA,MACF;AAAA,MACA,KAAK,aAAa;AAChB,cAAM,QAAI,gBAAI,UAAU;AACxB,YAAI,KAAK,KAAM,QAAO,GAAG,IAAI,4BAAe,MAAM,CAAW;AAC7D;AAAA,MACF;AAAA,MACA,KAAK,gBAAgB;AACnB,cAAM,QAAI,gBAAI,UAAU;AACxB,YAAI,KAAK;AACP,iBAAO,GAAG,IAAI,4BAAe;AAAA,YAC3B;AAAA,UACF;AACF;AAAA,MACF;AAAA,MACA,KAAK,eAAe;AAClB,YAAI,eAAe,QAAW;AAE5B,kBAAI,2BAAa,UAAU,KAAM,WAAmC,IAAI,MAAM,QAAW;AACvF,mBAAO,GAAG,IAAI;AACd;AAAA,UACF;AACA,gBAAM,SAAK,0BAAW,UAA0B;AAChD,iBAAO,GAAG,IAAI,MAAM,OAAO,4BAAe,OAAO,EAAE,IAAI;AAAA,QACzD;AACA;AAAA,MACF;AAAA,MACA,KAAK,gBAAgB;AACnB,YAAI,eAAe,QAAW;AAE5B,kBAAI,2BAAa,UAAU,KAAM,WAAmC,KAAK,MAAM,QAAW;AACxF,mBAAO,GAAG,IAAI;AACd;AAAA,UACF;AACA,gBAAM,SAAK,2BAAY,UAA0B;AACjD,iBAAO,GAAG,IAAI,MAAM,OAAO,4BAAe,OAAO,EAAE,IAAI;AAAA,QACzD;AACA;AAAA,MACF;AAAA,MACA;AACE,YAAI,OAAO,SAAS,YAAY;AAC9B,iBAAO,GAAG,IAAI,KAAK,UAAU;AAAA,QAC/B;AAAA,IAEJ;AAAA,EACF;AACA,SAAO;AACT;AAwBO,SAAS,wBACd,SACA,WAC2B;AAC3B,QAAM,iBAAa,sBAAO,OAAO;AACjC,aAAW,UAAU;AAErB,QAAM,aAAS,uBAAQ,MAAM,uBAAO,GAAG,CAAC,OAAO,CAAC;AAChD,QAAM,UAAU,MAAqB;AACnC,QAAI,OAAO,cAAc,YAAY;AACnC,aAAO,UAAU,WAAW,OAAO;AAAA,IACrC;AACA,UAAM,MAAM,WAAW;AACvB,UAAM,eAAW,gBAAI,GAAqC;AAC1D,QAAI,aAAa,QAAQ,KAAC,2BAAa,GAAG,GAAG;AAM3C,aAAO,qBAAqB,UAAU,SAAS;AAAA,IACjD;AACA,WAAO;AAAA,EACT;AAEA,aAAO,4BAAc,SAAS,CAAC,MAAM,CAAC;AAGxC;","names":["import_react"]}

package/dist/function/useMayObservableOptions/index.mjs

@@ -0,0 +1,88 @@
+import {
+  isObservable,
+  ObservableHint
+} from "@legendapp/state";
+import { useObservable } from "@legendapp/state/react";
+import { useMemo, useRef } from "react";
+import { get } from "../get";
+import { peek } from "../peek";
+import { getElement, peekElement } from "../../elements/useRef$";
+function applyObjectTransform(raw, map) {
+  if (raw == null) return void 0;
+  const result = { ...raw };
+  for (const key of Object.keys(result)) {
+    const hint = map[key];
+    const fieldValue = result[key];
+    switch (hint) {
+      case "peek":
+        result[key] = peek(fieldValue);
+        break;
+      case "get.opaque": {
+        const v = get(fieldValue);
+        if (v != null) result[key] = ObservableHint.opaque(v);
+        break;
+      }
+      case "get.plain": {
+        const v = get(fieldValue);
+        if (v != null) result[key] = ObservableHint.plain(v);
+        break;
+      }
+      case "get.function": {
+        const v = get(fieldValue);
+        if (v != null)
+          result[key] = ObservableHint.function(
+            v
+          );
+        break;
+      }
+      case "get.element": {
+        if (fieldValue !== void 0) {
+          if (isObservable(fieldValue) && fieldValue.get() === void 0) {
+            result[key] = void 0;
+            break;
+          }
+          const el = getElement(fieldValue);
+          result[key] = el != null ? ObservableHint.opaque(el) : null;
+        }
+        break;
+      }
+      case "peek.element": {
+        if (fieldValue !== void 0) {
+          if (isObservable(fieldValue) && fieldValue.peek() === void 0) {
+            result[key] = void 0;
+            break;
+          }
+          const el = peekElement(fieldValue);
+          result[key] = el != null ? ObservableHint.opaque(el) : null;
+        }
+        break;
+      }
+      default:
+        if (typeof hint === "function") {
+          result[key] = hint(fieldValue);
+        }
+    }
+  }
+  return result;
+}
+function useMayObservableOptions(options, transform) {
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const depKey = useMemo(() => /* @__PURE__ */ Symbol(), [options]);
+  const compute = () => {
+    if (typeof transform === "function") {
+      return transform(optionsRef.current);
+    }
+    const raw = optionsRef.current;
+    const resolved = get(raw);
+    if (transform != null && !isObservable(raw)) {
+      return applyObjectTransform(resolved, transform);
+    }
+    return resolved;
+  };
+  return useObservable(compute, [depKey]);
+}
+export {
+  useMayObservableOptions
+};
+//# sourceMappingURL=index.mjs.map

package/dist/function/useMayObservableOptions/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/function/useMayObservableOptions/index.ts"],"sourcesContent":["import {\n  isObservable,\n  ObservableHint,\n  type Observable,\n} from \"@legendapp/state\";\nimport { useObservable } from \"@legendapp/state/react\";\nimport { useMemo, useRef } from \"react\";\nimport { get } from \"../get\";\nimport { peek } from \"../peek\";\nimport type { DeepMaybeObservable, MaybeObservable } from \"../../types\";\nimport { getElement, peekElement } from \"../../elements/useRef$\";\nimport type { MaybeElement } from \"../../elements/useRef$\";\n\n/**\n * Per-field resolution hint for the object-form transform.\n *\n * Resolution axis (`get` / `peek`):\n * - `'get'`          — no-op; Legend-State auto-derefs the field Observable and registers the dep at the call site. **Default.**\n * - `'peek'`         — `peek(fieldValue)` — no dep, mount-time-only snapshot.\n *\n * Legend-State wrapping axis (dot-notation):\n * - `'get.opaque'`   — `get()` then `ObservableHint.opaque()`. Null-safe.\n * - `'get.plain'`    — `get()` then `ObservableHint.plain()`. Prevents nested auto-deref. Null-safe.\n * - `'get.function'` — `get()` then `ObservableHint.function()`. For callbacks. Null-safe.\n * - `'get.element'`  — `getElement(fieldValue)` (reactive) then `ObservableHint.opaque()`. For MaybeElement.\n * - `'peek.element'` — `peekElement(fieldValue)` (non-reactive) then `ObservableHint.opaque()`. For MaybeElement.\n *\n * Escape hatch:\n * - `(value) => R`   — custom transform function.\n */\nexport type FieldHint<V = any, R = any> =\n  | \"get\"\n  | \"peek\"\n  | \"get.opaque\"\n  | \"get.plain\"\n  | \"get.function\"\n  | \"get.element\"\n  | \"peek.element\"\n  | ((value: MaybeObservable<V>) => R);\n\n/**\n * Maps each field of `T` to a `FieldHint`.\n * Fields not specified default to `'get'` (reactive resolution via Legend-State auto-deref).\n */\nexport type FieldTransformMap<T> = {\n  [K in keyof T]?: FieldHint<T[K], any>;\n};\n\n/**\n * The `transform` parameter for `useMayObservableOptions`.\n * - **Object form:** declarative per-field hints — `FieldTransformMap<T>`.\n * - **Function form:** full custom compute — `(current) => T | undefined`.\n */\nexport type Transform<T> =\n  | FieldTransformMap<T>\n  | ((current: DeepMaybeObservable<T> | undefined) => T | undefined);\n\nfunction applyObjectTransform<T>(\n  raw: T | undefined,\n  map: FieldTransformMap<T>,\n): T | undefined {\n  if (raw == null) return undefined;\n  const result = { ...raw } as Record<string, unknown>;\n  for (const key of Object.keys(result)) {\n    const hint = (map as Record<string, FieldHint>)[key];\n    const fieldValue = result[key] as MaybeObservable<unknown>;\n    switch (hint) {\n      case \"peek\":\n        result[key] = peek(fieldValue);\n        break;\n      case \"get.opaque\": {\n        const v = get(fieldValue);\n        if (v != null) result[key] = ObservableHint.opaque(v);\n        break;\n      }\n      case \"get.plain\": {\n        const v = get(fieldValue);\n        if (v != null) result[key] = ObservableHint.plain(v as object);\n        break;\n      }\n      case \"get.function\": {\n        const v = get(fieldValue);\n        if (v != null)\n          result[key] = ObservableHint.function(\n            v as (...args: unknown[]) => unknown,\n          );\n        break;\n      }\n      case \"get.element\": {\n        if (fieldValue !== undefined) {\n          // Observable resolving to undefined means \"not set\" — propagate undefined\n          if (isObservable(fieldValue) && (fieldValue as Observable<unknown>).get() === undefined) {\n            result[key] = undefined;\n            break;\n          }\n          const el = getElement(fieldValue as MaybeElement);\n          result[key] = el != null ? ObservableHint.opaque(el) : null;\n        }\n        break;\n      }\n      case \"peek.element\": {\n        if (fieldValue !== undefined) {\n          // Observable resolving to undefined means \"not set\" — propagate undefined\n          if (isObservable(fieldValue) && (fieldValue as Observable<unknown>).peek() === undefined) {\n            result[key] = undefined;\n            break;\n          }\n          const el = peekElement(fieldValue as MaybeElement);\n          result[key] = el != null ? ObservableHint.opaque(el) : null;\n        }\n        break;\n      }\n      default:\n        if (typeof hint === \"function\") {\n          result[key] = hint(fieldValue);\n        }\n        // 'get' or undefined → no action; Legend-State auto-derefs per-field Observables\n    }\n  }\n  return result as T;\n}\n\n/**\n * Normalizes `DeepMaybeObservable<T>` into a stable computed `Observable<T | undefined>`.\n *\n * Handles three cases without interference:\n * - **Outer `Observable<T>`** — tracked via `.get()` dep inside the compute fn\n * - **Per-field `{ field: Observable<T[K]> }`** — tracked via explicit `get()` per field\n * - **Plain value changing between renders** — tracked via Symbol depKey (React-level)\n *\n * The Symbol depKey prevents Legend-State from auto-deref'ing inner Observables\n * inside `depsObs$`, which would break per-field dep tracking if the raw `options`\n * object were passed directly as the dep array item.\n *\n * @param options - DeepMaybeObservable options to normalize\n * @param transform - Optional transform. Two forms:\n *   - **Object form:** `FieldTransformMap<T>` — per-field hints (`'peek'`, `'get.opaque'`, etc.).\n *     Defaults to `'get'` for unspecified fields.\n *     **Note:** has no effect when `options` is an outer `Observable<T>` — in that case the\n *     proxy is returned as-is (same as no transform), preserving Legend-State's\n *     reference-equality tracking behavior. Use per-field Observables or plain objects\n *     when field-level hints are needed.\n *   - **Function form:** `(current) => T | undefined` — full custom compute for complex cases.\n */\nexport function useMayObservableOptions<T>(\n  options: DeepMaybeObservable<T> | undefined,\n  transform?: Transform<T>,\n): Observable<T | undefined> {\n  const optionsRef = useRef(options);\n  optionsRef.current = options;\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  const depKey = useMemo(() => Symbol(), [options]);\n  const compute = (): T | undefined => {\n    if (typeof transform === \"function\") {\n      return transform(optionsRef.current);\n    }\n    const raw = optionsRef.current;\n    const resolved = get(raw as MaybeObservable<T> | undefined);\n    if (transform != null && !isObservable(raw)) {\n      // Object form — only applies when options is NOT an outer Observable.\n      // For outer Observable, returning the proxy as-is preserves the\n      // \"reference-equality tracking\" behavior: child-field mutations do not\n      // trigger opts$ recomputation (documented known Legend-State limitation).\n      // For per-field Observable or plain object, apply field hints.\n      return applyObjectTransform(resolved, transform);\n    }\n    return resolved;\n  };\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  return useObservable(compute, [depKey]) as unknown as Observable<\n    T | undefined\n  >;\n}\n"],"mappings":"AAAA;AAAA,EACE;AAAA,EACA;AAAA,OAEK;AACP,SAAS,qBAAqB;AAC9B,SAAS,SAAS,cAAc;AAChC,SAAS,WAAW;AACpB,SAAS,YAAY;AAErB,SAAS,YAAY,mBAAmB;AA+CxC,SAAS,qBACP,KACA,KACe;AACf,MAAI,OAAO,KAAM,QAAO;AACxB,QAAM,SAAS,EAAE,GAAG,IAAI;AACxB,aAAW,OAAO,OAAO,KAAK,MAAM,GAAG;AACrC,UAAM,OAAQ,IAAkC,GAAG;AACnD,UAAM,aAAa,OAAO,GAAG;AAC7B,YAAQ,MAAM;AAAA,MACZ,KAAK;AACH,eAAO,GAAG,IAAI,KAAK,UAAU;AAC7B;AAAA,MACF,KAAK,cAAc;AACjB,cAAM,IAAI,IAAI,UAAU;AACxB,YAAI,KAAK,KAAM,QAAO,GAAG,IAAI,eAAe,OAAO,CAAC;AACpD;AAAA,MACF;AAAA,MACA,KAAK,aAAa;AAChB,cAAM,IAAI,IAAI,UAAU;AACxB,YAAI,KAAK,KAAM,QAAO,GAAG,IAAI,eAAe,MAAM,CAAW;AAC7D;AAAA,MACF;AAAA,MACA,KAAK,gBAAgB;AACnB,cAAM,IAAI,IAAI,UAAU;AACxB,YAAI,KAAK;AACP,iBAAO,GAAG,IAAI,eAAe;AAAA,YAC3B;AAAA,UACF;AACF;AAAA,MACF;AAAA,MACA,KAAK,eAAe;AAClB,YAAI,eAAe,QAAW;AAE5B,cAAI,aAAa,UAAU,KAAM,WAAmC,IAAI,MAAM,QAAW;AACvF,mBAAO,GAAG,IAAI;AACd;AAAA,UACF;AACA,gBAAM,KAAK,WAAW,UAA0B;AAChD,iBAAO,GAAG,IAAI,MAAM,OAAO,eAAe,OAAO,EAAE,IAAI;AAAA,QACzD;AACA;AAAA,MACF;AAAA,MACA,KAAK,gBAAgB;AACnB,YAAI,eAAe,QAAW;AAE5B,cAAI,aAAa,UAAU,KAAM,WAAmC,KAAK,MAAM,QAAW;AACxF,mBAAO,GAAG,IAAI;AACd;AAAA,UACF;AACA,gBAAM,KAAK,YAAY,UAA0B;AACjD,iBAAO,GAAG,IAAI,MAAM,OAAO,eAAe,OAAO,EAAE,IAAI;AAAA,QACzD;AACA;AAAA,MACF;AAAA,MACA;AACE,YAAI,OAAO,SAAS,YAAY;AAC9B,iBAAO,GAAG,IAAI,KAAK,UAAU;AAAA,QAC/B;AAAA,IAEJ;AAAA,EACF;AACA,SAAO;AACT;AAwBO,SAAS,wBACd,SACA,WAC2B;AAC3B,QAAM,aAAa,OAAO,OAAO;AACjC,aAAW,UAAU;AAErB,QAAM,SAAS,QAAQ,MAAM,uBAAO,GAAG,CAAC,OAAO,CAAC;AAChD,QAAM,UAAU,MAAqB;AACnC,QAAI,OAAO,cAAc,YAAY;AACnC,aAAO,UAAU,WAAW,OAAO;AAAA,IACrC;AACA,UAAM,MAAM,WAAW;AACvB,UAAM,WAAW,IAAI,GAAqC;AAC1D,QAAI,aAAa,QAAQ,CAAC,aAAa,GAAG,GAAG;AAM3C,aAAO,qBAAqB,UAAU,SAAS;AAAA,IACjD;AACA,WAAO;AAAA,EACT;AAEA,SAAO,cAAc,SAAS,CAAC,MAAM,CAAC;AAGxC;","names":[]}

package/dist/function/useSupported/index.d.mts

@@ -0,0 +1,6 @@
+import { Observable } from '@legendapp/state';
+
+type UseSupportedReturn = Observable<boolean>;
+declare function useSupported(callback: () => unknown): UseSupportedReturn;
+
+export { type UseSupportedReturn, useSupported };

package/dist/function/useSupported/index.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from '@legendapp/state';
+
+type UseSupportedReturn = Observable<boolean>;
+declare function useSupported(callback: () => unknown): UseSupportedReturn;
+
+export { type UseSupportedReturn, useSupported };

package/dist/function/useSupported/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useSupported_exports = {};
+__export(useSupported_exports, {
+  useSupported: () => useSupported
+});
+module.exports = __toCommonJS(useSupported_exports);
+var import_react = require("@legendapp/state/react");
+// @__NO_SIDE_EFFECTS__
+function useSupported(callback) {
+  const isMounted = (0, import_react.useIsMounted)();
+  return (0, import_react.useObservable)(() => {
+    if (!isMounted.get()) return false;
+    return Boolean(callback());
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSupported
+});
+//# sourceMappingURL=index.js.map

package/dist/function/useSupported/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/function/useSupported/index.ts"],"sourcesContent":["import { Observable } from \"@legendapp/state\";\nimport { useIsMounted, useObservable } from \"@legendapp/state/react\";\n\nexport type UseSupportedReturn = Observable<boolean>;\n\n/* @__NO_SIDE_EFFECTS__ */\nexport function useSupported(callback: () => unknown): UseSupportedReturn {\n  const isMounted = useIsMounted();\n\n  return useObservable(() => {\n    if (!isMounted.get()) return false;\n    return Boolean(callback());\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAA4C;AAAA;AAKrC,SAAS,aAAa,UAA6C;AACxE,QAAM,gBAAY,2BAAa;AAE/B,aAAO,4BAAc,MAAM;AACzB,QAAI,CAAC,UAAU,IAAI,EAAG,QAAO;AAC7B,WAAO,QAAQ,SAAS,CAAC;AAAA,EAC3B,CAAC;AACH;","names":[]}

package/dist/function/useSupported/index.mjs

@@ -0,0 +1,13 @@
+import { useIsMounted, useObservable } from "@legendapp/state/react";
+// @__NO_SIDE_EFFECTS__
+function useSupported(callback) {
+  const isMounted = useIsMounted();
+  return useObservable(() => {
+    if (!isMounted.get()) return false;
+    return Boolean(callback());
+  });
+}
+export {
+  useSupported
+};
+//# sourceMappingURL=index.mjs.map

package/dist/function/useSupported/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/function/useSupported/index.ts"],"sourcesContent":["import { Observable } from \"@legendapp/state\";\nimport { useIsMounted, useObservable } from \"@legendapp/state/react\";\n\nexport type UseSupportedReturn = Observable<boolean>;\n\n/* @__NO_SIDE_EFFECTS__ */\nexport function useSupported(callback: () => unknown): UseSupportedReturn {\n  const isMounted = useIsMounted();\n\n  return useObservable(() => {\n    if (!isMounted.get()) return false;\n    return Boolean(callback());\n  });\n}\n"],"mappings":"AACA,SAAS,cAAc,qBAAqB;AAAA;AAKrC,SAAS,aAAa,UAA6C;AACxE,QAAM,YAAY,aAAa;AAE/B,SAAO,cAAc,MAAM;AACzB,QAAI,CAAC,UAAU,IAAI,EAAG,QAAO;AAC7B,WAAO,QAAQ,SAAS,CAAC;AAAA,EAC3B,CAAC;AACH;","names":[]}

package/dist/function/useWhenMounted/index.d.mts

@@ -0,0 +1,6 @@
+import { Observable } from '@legendapp/state';
+
+type UseWhenMountedReturn<T> = Observable<T | undefined>;
+declare function useWhenMounted<T>(callback: () => T): UseWhenMountedReturn<T>;
+
+export { type UseWhenMountedReturn, useWhenMounted };

package/dist/function/useWhenMounted/index.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from '@legendapp/state';
+
+type UseWhenMountedReturn<T> = Observable<T | undefined>;
+declare function useWhenMounted<T>(callback: () => T): UseWhenMountedReturn<T>;
+
+export { type UseWhenMountedReturn, useWhenMounted };

package/dist/function/useWhenMounted/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useWhenMounted_exports = {};
+__export(useWhenMounted_exports, {
+  useWhenMounted: () => useWhenMounted
+});
+module.exports = __toCommonJS(useWhenMounted_exports);
+var import_react = require("@legendapp/state/react");
+// @__NO_SIDE_EFFECTS__
+function useWhenMounted(callback) {
+  const isMounted = (0, import_react.useIsMounted)();
+  return (0, import_react.useObservable)(() => {
+    if (!isMounted.get()) return void 0;
+    return callback();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useWhenMounted
+});
+//# sourceMappingURL=index.js.map

package/dist/function/useWhenMounted/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/function/useWhenMounted/index.ts"],"sourcesContent":["import type { Observable } from \"@legendapp/state\";\nimport { useIsMounted, useObservable } from \"@legendapp/state/react\";\n\nexport type UseWhenMountedReturn<T> = Observable<T | undefined>;\n\n/* @__NO_SIDE_EFFECTS__ */\nexport function useWhenMounted<T>(\n  callback: () => T,\n): UseWhenMountedReturn<T> {\n  const isMounted = useIsMounted();\n\n  return useObservable(() => {\n    if (!isMounted.get()) return undefined;\n    return callback();\n  }) as unknown as Observable<T | undefined>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAA4C;AAAA;AAKrC,SAAS,eACd,UACyB;AACzB,QAAM,gBAAY,2BAAa;AAE/B,aAAO,4BAAc,MAAM;AACzB,QAAI,CAAC,UAAU,IAAI,EAAG,QAAO;AAC7B,WAAO,SAAS;AAAA,EAClB,CAAC;AACH;","names":[]}

package/dist/function/useWhenMounted/index.mjs

@@ -0,0 +1,13 @@
+import { useIsMounted, useObservable } from "@legendapp/state/react";
+// @__NO_SIDE_EFFECTS__
+function useWhenMounted(callback) {
+  const isMounted = useIsMounted();
+  return useObservable(() => {
+    if (!isMounted.get()) return void 0;
+    return callback();
+  });
+}
+export {
+  useWhenMounted
+};
+//# sourceMappingURL=index.mjs.map

package/dist/function/useWhenMounted/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/function/useWhenMounted/index.ts"],"sourcesContent":["import type { Observable } from \"@legendapp/state\";\nimport { useIsMounted, useObservable } from \"@legendapp/state/react\";\n\nexport type UseWhenMountedReturn<T> = Observable<T | undefined>;\n\n/* @__NO_SIDE_EFFECTS__ */\nexport function useWhenMounted<T>(\n  callback: () => T,\n): UseWhenMountedReturn<T> {\n  const isMounted = useIsMounted();\n\n  return useObservable(() => {\n    if (!isMounted.get()) return undefined;\n    return callback();\n  }) as unknown as Observable<T | undefined>;\n}\n"],"mappings":"AACA,SAAS,cAAc,qBAAqB;AAAA;AAKrC,SAAS,eACd,UACyB;AACzB,QAAM,YAAY,aAAa;AAE/B,SAAO,cAAc,MAAM;AACzB,QAAI,CAAC,UAAU,IAAI,EAAG,QAAO;AAC7B,WAAO,SAAS;AAAA,EAClB,CAAC;AACH;","names":[]}

package/dist/index.d.mts

@@ -0,0 +1,24 @@
+export { AnyFn, Arrayable, Awaitable, DeepMaybeObservable, Fn, MaybeObservable, Pausable, Stoppable, TimerHandle } from './types.mjs';
+export { get } from './function/get/index.mjs';
+export { peek } from './function/peek/index.mjs';
+export { UseSupportedReturn, useSupported } from './function/useSupported/index.mjs';
+export { UseWhenMountedReturn, useWhenMounted } from './function/useWhenMounted/index.mjs';
+export { MaybeElement, Ref$, getElement, isRef$, peekElement, useRef$ } from './elements/useRef_/index.mjs';
+export { UseResizeObserverOptions, UseResizeObserverReturn, useResizeObserver } from './elements/useResizeObserver/index.mjs';
+export { UseElementSizeOptions, UseElementSizeReturn, useElementSize } from './elements/useElementSize/index.mjs';
+export { UseElementBoundingOptions, UseElementBoundingReturn, useElementBounding } from './elements/useElementBounding/index.mjs';
+export { UseMutationObserverOptions, UseMutationObserverReturn, useMutationObserver } from './elements/useMutationObserver/index.mjs';
+export { UseIntersectionObserverOptions, UseIntersectionObserverReturn, useIntersectionObserver } from './elements/useIntersectionObserver/index.mjs';
+export { UseElementVisibilityOptions, useElementVisibility } from './elements/useElementVisibility/index.mjs';
+export { useDocumentVisibility } from './elements/useDocumentVisibility/index.mjs';
+export { useWindowFocus } from './elements/useWindowFocus/index.mjs';
+export { UseWindowSizeOptions, UseWindowSizeReturn, useWindowSize } from './elements/useWindowSize/index.mjs';
+export { useParentElement } from './elements/useParentElement/index.mjs';
+export { UseMouseInElementOptions, UseMouseInElementReturn, useMouseInElement } from './elements/useMouseInElement/index.mjs';
+export { ArrivedState, ScrollDirections, UseScrollOptions, UseScrollReturn, useScroll } from './sensors/useScroll/index.mjs';
+export { useWindowScroll } from './sensors/useWindowScroll/index.mjs';
+export { GeneralEventListener, useEventListener } from './browser/useEventListener/index.mjs';
+export { UseMediaQueryOptions, UseMediaQueryReturn, evaluateSSRQuery, useMediaQuery } from './browser/useMediaQuery/index.mjs';
+export { normalizeTargets } from './shared/normalizeTargets/index.mjs';
+import '@legendapp/state';
+import 'react';