@manyducks.co/dolla 2.0.0-alpha.60 → 2.0.0-alpha.61

package/dist/core/context.d.ts

@@ -139,6 +139,4 @@ export declare class Context implements Logger {
     setState(entries: [key: any, value: any][]): void;
 }
 export declare function createContext(name: MaybeSignal<string>, options?: ContextOptions): Context;
-export declare class StoreError extends Error {
-}
 export {};

package/dist/core/context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/index.d.ts

@@ -1,16 +1,15 @@
-export { $, effect, get, untracked, batch } from "./signals.js";
+export { $, batch, effect, get, untracked } from "./signals.js";
 export type { MaybeSignal, Signal, Source } from "./signals.js";
 export { createContext } from "./context.js";
 export type { Context } from "./context.js";
-export { m, portal, render, repeat, unless, when } from "./markup.js";
-export type { MarkupNode } from "./markup.js";
+export { m, MarkupNode, portal, render, repeat, unless, when } from "./markup.js";
 export { ref, type Ref } from "./ref.js";
 export { mount, type UnmountFn } from "./mount.js";
 export { deepEqual, shallowEqual, strictEqual } from "../utils.js";
 export { getEnv, setEnv } from "./env.js";
-export { createLogger, setLogFilter, setLogLevels, onLoggerCrash } from "./logger.js";
+export { createLogger, onLoggerCrash, setLogFilter, setLogLevels } from "./logger.js";
 export type { Logger, LoggerCrashProps, LoggerOptions, LogLevels } from "./logger.js";
-export type { View, Store, Mixin, InputType, Renderable, Env, CSSProperties } from "../types.js";
+export type { CSSProperties, Env, InputType, Mixin, Renderable, Store, View } from "../types.js";
 export type { CrashViewProps } from "./views/default-crash-view.js";
 import type { IntrinsicElements as Elements } from "../types.js";
 declare global {

package/dist/core/markup.d.ts

@@ -1,9 +1,11 @@
 import type { IntrinsicElements, Renderable, View } from "../types.js";
 import { Context } from "./context.js";
+import { MarkupNode } from "./nodes/_markup.js";
 import { KeyFn, RenderFn } from "./nodes/repeat.js";
 import { type MaybeSignal, type Signal } from "./signals.js";
+export { MarkupNode };
 /**
- * Markup is a set of element metadata that hasn't been constructed into a MarkupElement yet.
+ * `Markup` is a set of metadata that will be constructed into a `MarkupNode`.
  */
 export declare class Markup<P = any> {
     /**
@@ -19,37 +21,11 @@ export declare class Markup<P = any> {
     constructor(type: string | View<P>, props?: P);
 }
 /**
- * A mountable node that has been constructed from Markup metadata.
+ * A node that can be mounted by the Markup layout engine.
+ * Implemented by the built in nodes, but can of course also be implemented to create your own custom nodes.
+ *
+ * A `MarkupNode` instance can be passed anywhere a `Renderable` is required.
  */
-export interface MarkupNode {
-    /**
-     *
-     */
-    readonly root?: Node;
-    /**
-     * Returns true when this MarkupNode is mounted.
-     */
-    isMounted(): boolean;
-    /**
-     * Mount this MarkupNode to a `parent` element.
-     * If passed, this MarkupNode will be mounted as the next sibling of `after`.
-     */
-    mount(parent: Element, after?: Node): void;
-    /**
-     * Unmount this MarkupNode from its parent element.
-     *
-     * The `skipDOM` option can be passed as an optimization when unmounting a parent node.
-     * A value of `true` indicates that no DOM operations need to happen because the parent is already being unmounted.
-     *
-     * @param skipDOM - No DOM updates will be performed when true. Lifecycle methods will be called regardless.
-     */
-    unmount(skipDOM?: boolean): void;
-    /**
-     * Moves a node without unmounting and remounting (if the browser supports Element.moveBefore).
-     */
-    move(parent: Element, after?: Node): void;
-}
-export declare function isMarkupNode(value: any): value is MarkupNode;
 export declare enum MarkupType {
     DOM = "$dom",
     Dynamic = "$dynamic",
@@ -80,25 +56,25 @@ export interface MarkupCustomElementProps {
     [tag: `${string}-${string}`]: Record<string, any>;
 }
 /**
- * Creates a Markup element that defines an HTML element.
+ * Creates a `Markup` element that defines an HTML element.
  */
 export declare function m<T extends keyof IntrinsicElements>(tag: T, attrs: IntrinsicElements[T] & {
     children?: Renderable;
 }): Markup;
 /**
- * Creates a Markup element that defines an HTML custom element.
+ * Creates a `Markup` element that defines an HTML custom element.
  */
 export declare function m<T extends keyof MarkupCustomElementProps>(type: T, props: MarkupCustomElementProps[T]): Markup;
 /**
- * Creates a Markup element that defines a MarkupNode.
+ * Creates a `Markup` element that defines a `MarkupNode`.
  */
 export declare function m<T extends keyof MarkupNodeProps>(type: T, props: MarkupNodeProps[T]): Markup;
 /**
- * Creates a Markup element that defines a view.
+ * Creates a `Markup` element that defines a view.
  */
 export declare function m<P extends {}>(type: View<P>, props?: P): Markup;
 /**
- * Creates a Markup element that defines a view.
+ * Creates a `Markup` element that defines a view.
  */
 export declare function m<P>(type: View<P>, props: P): Markup;
 /**
@@ -118,8 +94,11 @@ export declare function repeat<T>(items: MaybeSignal<T[]>, key: KeyFn<T>, render
  * Renders `content` into a `parent` node anywhere in the page, rather than its usual position in the view.
  */
 export declare function portal(parent: Element, content: Renderable): Markup;
+/**
+ * Takes any `Renderable` value and returns a `MarkupNode` that will display it.
+ */
 export declare function render(content: Renderable, context?: Context): MarkupNode;
 /**
- * Convert basically anything into a set of MarkupElements.
+ * Convert basically anything into a set of `MarkupNode`s.
  */
 export declare function toMarkupNodes(context: Context, ...content: any[]): MarkupNode[];

package/dist/core/nodes/_markup.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A node that can be mounted by the Markup layout engine. Can be extended to create new custom node types.
+ *
+ * A `MarkupNode` instance can be passed anywhere a `Renderable` is required.
+ */
+export declare abstract class MarkupNode {
+    /**
+     * Returns a single DOM node to represent this MarkupNode's position in the DOM.
+     * Usually the parent element, but it can be an empty Text node used as a marker.
+     *
+     * It only needs to be defined while the node is mounted, so it can be created in the `mount` function.
+     */
+    getRoot(): Node | undefined;
+    /**
+     * Returns true while this node is mounted.
+     */
+    isMounted(): boolean;
+    /**
+     * Mount this node to a `parent` element.
+     * If passed, this node will be mounted as the next sibling of `after`.
+     */
+    mount(parent: Element, after?: Node): void;
+    /**
+     * Unmount this MarkupNode from its parent element.
+     *
+     * The `skipDOM` option can be passed as an optimization when unmounting a parent node.
+     * A value of `true` indicates that no DOM operations need to happen because the parent is already being unmounted.
+     *
+     * @param skipDOM - No DOM updates will be performed when true. Lifecycle methods will be called regardless.
+     */
+    unmount(skipDOM?: boolean): void;
+    /**
+     * Moves a node without unmounting and remounting (if the browser supports Element.moveBefore).
+     */
+    move(parent: Element, after?: Node): void;
+}

package/dist/core/nodes/dom.d.ts

@@ -1,12 +1,11 @@
-import type { MarkupNode } from "../markup";
-import { TYPE } from "../symbols";
+import { MarkupNode } from "./_markup";
 /**
- * Lightweight MarkupNode wrapper for a plain DOM node.
+ * A lightweight MarkupNode wrapper for a plain DOM node.
  */
-export declare class DOMNode implements MarkupNode {
-    [TYPE]: symbol;
-    root: Node;
+export declare class DOMNode extends MarkupNode {
+    private root;
     constructor(node: Node);
+    getRoot(): Node;
     isMounted(): boolean;
     mount(parent: Element, after?: Node): void;
     unmount(skipDOM?: boolean): void;

package/dist/core/nodes/dynamic.d.ts

@@ -1,29 +1,22 @@
 import type { Context } from "../context.js";
-import { type MarkupNode } from "../markup.js";
 import { type Signal } from "../signals.js";
-import { TYPE } from "../symbols.js";
+import { MarkupNode } from "./_markup.js";
 /**
- * Displays dynamic children without a parent element.
- * Renders a Reactive value via a render function.
- *
- * This is probably the most used element type aside from HTML.
+ * Renders any kind of content; markup, signals, DOM nodes, etc.
+ * If it can be rendered by Dolla then Dynamic will do it.
  */
-export declare class Dynamic implements MarkupNode {
-    [TYPE]: symbol;
-    root: Text;
+export declare class DynamicNode extends MarkupNode {
+    private root;
     private children;
     private context;
     private $slot;
     private unsubscribe?;
     constructor(context: Context, $slot: Signal<any>);
+    getRoot(): Text;
     isMounted(): boolean;
     mount(parent: Node, after?: Node): void;
     unmount(skipDOM?: boolean): void;
     move(parent: Element, after?: Node): void;
     private cleanup;
     private update;
-    /**
-     * Move marker node to end of children.
-     */
-    private moveMarker;
 }

package/dist/core/nodes/{html.d.ts → element.d.ts}

@@ -1,18 +1,19 @@
 import { Context } from "../context.js";
-import { type MarkupNode } from "../markup.js";
-import { TYPE } from "../symbols.js";
-export declare class HTML implements MarkupNode {
-    [TYPE]: symbol;
-    root: HTMLElement | SVGElement;
-    private parentContext;
+import { MarkupNode } from "./_markup.js";
+/**
+ * Renders an HTML or SVG element.
+ */
+export declare class ElementNode extends MarkupNode {
+    private root;
+    readonly tag: string;
+    readonly props: Record<string, any>;
     private context;
-    tag: string;
-    props: Record<string, any>;
     private childNodes;
     private unsubscribers;
     private ref?;
     private canClickAway;
     constructor(context: Context, tag: string, props: Record<string, any>);
+    getRoot(): HTMLElement | SVGElement;
     isMounted(): boolean;
     mount(parent: Node, after?: Node): void;
     unmount(skipDOM?: boolean): void;

package/dist/core/nodes/portal.d.ts

@@ -1,17 +1,16 @@
 import type { Renderable } from "../../types.js";
 import { Context } from "../context.js";
-import { type MarkupNode } from "../markup.js";
-import { TYPE } from "../symbols.js";
+import { MarkupNode } from "./_markup.js";
 /**
  * Renders content into a specified parent node.
  */
-export declare class Portal implements MarkupNode {
-    [TYPE]: symbol;
+export declare class PortalNode extends MarkupNode {
     private context;
-    private content;
+    private value;
     private parent;
-    private element?;
-    constructor(context: Context, content: Renderable, parent: Element);
+    private node?;
+    constructor(context: Context, value: Renderable, parent: Element);
+    getRoot(): Node | undefined;
     isMounted(): boolean;
     mount(_parent: Element, _after?: Node): void;
     unmount(skipDOM?: boolean): void;

package/dist/core/nodes/repeat.d.ts

@@ -1,14 +1,15 @@
 import type { Renderable } from "../../types.js";
 import type { Context } from "../context.js";
-import type { MarkupNode } from "../markup.js";
 import { type Signal } from "../signals.js";
-import { TYPE } from "../symbols.js";
+import { MarkupNode } from "./_markup.js";
 export type Key = string | number | symbol;
 export type KeyFn<T> = (item: T, index: number) => Key;
 export type RenderFn<T> = (item: Signal<T>, index: Signal<number>, ctx: Context) => Renderable;
-export declare class Repeat<T> implements MarkupNode {
-    [TYPE]: symbol;
-    root: Text;
+/**
+ * Renders a list of items.
+ */
+export declare class RepeatNode<T> extends MarkupNode {
+    private root;
     private context;
     private items;
     private key;
@@ -16,6 +17,7 @@ export declare class Repeat<T> implements MarkupNode {
     private unsubscribe;
     private connectedItems;
     constructor(context: Context, items: Signal<T[]>, key: KeyFn<T>, render: RenderFn<T>);
+    getRoot(): Text;
     isMounted(): boolean;
     mount(parent: Element, after?: Node): void;
     unmount(skipDOM?: boolean): void;

package/dist/core/nodes/view.d.ts

@@ -1,22 +1,23 @@
 import type { View } from "../../types.js";
 import { Context } from "../context.js";
-import { type MarkupNode } from "../markup.js";
-import { TYPE } from "../symbols.js";
+import { MarkupNode } from "./_markup.js";
 export declare const VIEW: unique symbol;
-export declare class ViewInstance<P> implements MarkupNode {
-    [TYPE]: symbol;
+/**
+ * Renders a View.
+ */
+export declare class ViewNode<P> extends MarkupNode {
     uniqueId: string;
     context: Context;
     props: P;
     view: View<P>;
     node?: MarkupNode;
-    get root(): Node;
     /**
      * @param context - Parent contenxt to link to.
      * @param view - View function to mount.
      * @param props - Props to pass to view function.
      */
     constructor(context: Context, view: View<P>, props: P);
+    getRoot(): Node | undefined;
     isMounted(): boolean;
     mount(parent: Element, after?: Node): void;
     unmount(skipDOM?: boolean): void;

package/dist/core/ref.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/signals.d.ts

@@ -1,3 +1,9 @@
+import { Context } from "./context";
+interface ComputedGetterState<T> {
+    value?: T;
+}
+export declare function getCurrentContext(): Context | undefined;
+export declare function setCurrentContext(context: Context | undefined): Context | undefined;
 /**
  * A getter that returns the current value held within the signal.
  * If called inside a trackable scope this signal will be tracked as a dependency.
@@ -20,9 +26,17 @@ export interface SignalOptions<T> {
      */
     equals?: EqualityFn<T>;
 }
-export declare function isSource<T>(value: MaybeSignal<T>): value is Source<T>;
+/**
+ * Suspends effects during `fn`. Effects for all updated Signal values are called at the end of the batch.
+ */
 export declare function batch(fn: () => void): void;
+/**
+ * Call a Signal function without tracking its value.
+ */
 export declare function untracked<T>(value: MaybeSignal<T>): T;
+/**
+ * Unwraps the plain value from a Signal. If the value is not a Signal it is returned as-is.
+ */
 export declare function get<T>(value: MaybeSignal<T>): T;
 /**
  * Function to be invoked for the effect. Can return an optional cleanup function to be called between invocations.
@@ -37,7 +51,8 @@ export type UnsubscribeFn = () => void;
  * If you are using an effect inside a View or Store, use `ctx.effect` instead, which cleans up automatically when the component unmounts.
  */
 export declare function effect(fn: EffectFn): UnsubscribeFn;
-export declare function $<T>(compute: (previousValue: T) => MaybeSignal<T>, options?: SignalOptions<T>): Signal<T>;
+export declare function $<T>(compute: (this: ComputedGetterState<T>) => MaybeSignal<T>, options?: SignalOptions<T>): Signal<T>;
 export declare function $<T>(value: T, options?: SignalOptions<T>): Source<T>;
 export declare function $<T>(value: undefined, options?: SignalOptions<T>): Source<T | undefined>;
 export declare function $<T>(): Source<T | undefined>;
+export {};

package/dist/core/views/default-crash-view.d.ts

@@ -1,7 +1,7 @@
 /**
  * Props passed to the crash view when a crash occurs.
  */
-export type CrashViewProps = {
+export interface CrashViewProps {
     /**
      * JavaScript Error object.
      */
@@ -18,5 +18,8 @@ export type CrashViewProps = {
      * Label for the tag.
      */
     tagName?: string;
-};
+}
+/**
+ * The crash view displayed unless you specify your own.
+ */
 export declare function DefaultCrashView(props: CrashViewProps): import("../markup.js").Markup<any>;

package/dist/hooks/index.d.ts

@@ -0,0 +1,64 @@
+import { Context, Logger, type Ref, type Store } from "../core";
+import { type EffectFn, MaybeSignal, type Signal } from "../core/signals";
+/**
+ * Returns the Context object of the View, Store or Mixin this hook is called in.
+ */
+export declare function useContext(): Context;
+/**
+ * Returns a logger. If a name is passed it will be used as a prefix for all console messages.
+ * Otherwise the default name of the context will be used.
+ */
+export declare function useLogger(name?: MaybeSignal<string>): Logger;
+/**
+ * Sets the value of the Signal it is bound to.
+ */
+export interface Setter<T> {
+    (value: T): void;
+    (fn: (current: T) => T): void;
+}
+/**
+ * Creates a new read-only Signal and a bound Setter function.
+ */
+export declare function useState<T>(value: T): [Signal<T>, Setter<T>];
+/**
+ * Creates a new read-only Signal and a bound Setter function.
+ */
+export declare function useState<T>(): [Signal<T | undefined>, Setter<T | undefined>];
+export declare function useMemo<T>(compute: (current?: T) => T, deps?: Signal<any>[]): Signal<T>;
+export declare function useEffect(fn: EffectFn, deps?: Signal<any>[]): void;
+/**
+ * Takes the current state and a dispatched action. Returns a new state based on the action.
+ * Typically the body of this function will be a large switch statement.
+ */
+export type ReducerFn<State, Action> = (state: State, action: Action) => State;
+/**
+ * Dispatches an action to this reducer, causing the state to update.
+ */
+export type DispatchFn<Action> = (action: Action) => void;
+/**
+ *
+ */
+export declare function useReducer<State, Action>(reducer: ReducerFn<State, Action>, initialState: State): [Signal<State>, DispatchFn<Action>];
+/**
+ * Uses a previously added Store. Takes the Store function itself and returns the nearest instance.
+ */
+export declare function useStore<T>(store: Store<any, T>): T;
+/**
+ * A hybrid Ref which is both a function ref and a React-style object ref with a `current` property.
+ * Both the `current` property and the function syntax access the same value.
+ */
+export interface HybridRef<T> extends Ref<T> {
+    current: T;
+}
+/**
+ * Creates a Ref. Useful for getting references to DOM nodes.
+ */
+export declare function useRef<T>(initialValue?: T): HybridRef<T>;
+/**
+ * Calls `callback` when the context is mounted. If `callback` returns a function, that function is called when the context is unmounted.
+ */
+export declare function useMount(callback: () => void | (() => void)): void;
+/**
+ * Calls `callback` when the context is unmounted.
+ */
+export declare function useUnmount(callback: () => void): void;

package/dist/hooks/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks.js

@@ -0,0 +1,69 @@
+import { $ as u, g as c, u as s, c as a } from "./signals-gCwiIe5X.js";
+import { r as x } from "./ref-BD79iqlg.js";
+function o() {
+  const t = a();
+  if (!t)
+    throw new Error("No context found; hooks can only be called in the body of a View, Store or Mixin.");
+  return t;
+}
+function m(t) {
+  const e = o();
+  return t && e.setName(t), e;
+}
+function l(t) {
+  o();
+  const e = u(t);
+  return [() => e(), e];
+}
+function p(t, e) {
+  return o(), e ? u(function() {
+    for (const n of e) c(n);
+    return s(() => t(this.value));
+  }) : u(function() {
+    return t(this.value);
+  });
+}
+function S(t, e) {
+  const n = o();
+  e ? n.effect(() => {
+    for (const r of e) c(r);
+    s(t);
+  }) : n.effect(t);
+}
+function v(t, e) {
+  const [n, r] = l(e);
+  return [n, (f) => {
+    r((i) => t(i, f));
+  }];
+}
+function M(t) {
+  return o().getStore(t);
+}
+function b(...t) {
+  o();
+  const e = x(...t);
+  return Object.defineProperty(e, "current", { get: e, set: e }), e;
+}
+function w(t) {
+  const e = o();
+  e.onMount(() => {
+    const n = t();
+    n && e.onUnmount(n);
+  });
+}
+function y(t) {
+  o().onUnmount(t);
+}
+export {
+  o as useContext,
+  S as useEffect,
+  m as useLogger,
+  p as useMemo,
+  w as useMount,
+  v as useReducer,
+  b as useRef,
+  l as useState,
+  M as useStore,
+  y as useUnmount
+};
+//# sourceMappingURL=hooks.js.map

package/dist/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sources":["../src/hooks/index.ts"],"sourcesContent":["import { Context, Logger, ref, type Ref, type Store } from \"../core\";\nimport { $, type EffectFn, get, getCurrentContext, MaybeSignal, type Signal, untracked } from \"../core/signals\";\n\n/**\n * Returns the Context object of the View, Store or Mixin this hook is called in.\n */\nexport function useContext(): Context {\n  const context = getCurrentContext();\n  if (!context) {\n    throw new Error(`No context found; hooks can only be called in the body of a View, Store or Mixin.`);\n  }\n  return context;\n}\n\n/**\n * Returns a logger. If a name is passed it will be used as a prefix for all console messages.\n * Otherwise the default name of the context will be used.\n */\nexport function useLogger(name?: MaybeSignal<string>): Logger {\n  const context = useContext();\n  if (name) context.setName(name);\n  return context;\n}\n\n/**\n * Sets the value of the Signal it is bound to.\n */\nexport interface Setter<T> {\n  (value: T): void;\n  (fn: (current: T) => T): void;\n}\n\n/**\n * Creates a new read-only Signal and a bound Setter function.\n */\nexport function useState<T>(value: T): [Signal<T>, Setter<T>];\n\n/**\n * Creates a new read-only Signal and a bound Setter function.\n */\nexport function useState<T>(): [Signal<T | undefined>, Setter<T | undefined>];\n\nexport function useState<T>(value?: T): [Signal<T>, Setter<T>] {\n  useContext(); // assert that we're in a valid context\n  const $value = $(value);\n  return [() => $value() as T, $value];\n}\n\nexport function useMemo<T>(compute: (current?: T) => T, deps?: Signal<any>[]): Signal<T> {\n  useContext(); // assert that we're in a valid context\n  if (deps) {\n    return $(function () {\n      // Track deps and run `compute` untracked.\n      for (const dep of deps) get(dep);\n      return untracked(() => compute(this.value));\n    });\n  } else {\n    return $(function () {\n      return compute(this.value);\n    });\n  }\n}\n\nexport function useEffect(fn: EffectFn, deps?: Signal<any>[]): void {\n  const context = useContext();\n  if (deps) {\n    context.effect(() => {\n      // Track deps and run `fn` untracked.\n      for (const dep of deps) get(dep);\n      untracked(fn);\n    });\n  } else {\n    context.effect(fn);\n  }\n}\n\n// TODO: What would layout effect even mean in dolla?\n// export function useLayoutEffect() {}\n\n/**\n * Takes the current state and a dispatched action. Returns a new state based on the action.\n * Typically the body of this function will be a large switch statement.\n */\nexport type ReducerFn<State, Action> = (state: State, action: Action) => State;\n\n/**\n * Dispatches an action to this reducer, causing the state to update.\n */\nexport type DispatchFn<Action> = (action: Action) => void;\n\n/**\n *\n */\nexport function useReducer<State, Action>(\n  reducer: ReducerFn<State, Action>,\n  initialState: State,\n): [Signal<State>, DispatchFn<Action>] {\n  const [state, setState] = useState(initialState);\n  const dispatch = (action: Action) => {\n    setState((current) => reducer(current, action));\n  };\n  return [state, dispatch];\n}\n\n/**\n * Uses a previously added Store. Takes the Store function itself and returns the nearest instance.\n */\nexport function useStore<T>(store: Store<any, T>): T {\n  const context = useContext();\n  return context.getStore(store);\n}\n\n/**\n * A hybrid Ref which is both a function ref and a React-style object ref with a `current` property.\n * Both the `current` property and the function syntax access the same value.\n */\nexport interface HybridRef<T> extends Ref<T> {\n  current: T;\n}\n\n/**\n * Creates a Ref. Useful for getting references to DOM nodes.\n */\nexport function useRef<T>(initialValue?: T): HybridRef<T>;\n\nexport function useRef<T>(...value: [T]): HybridRef<T> {\n  useContext(); // assert that we're in a valid context\n  const valueRef = ref(...value);\n  Object.defineProperty(valueRef, \"current\", { get: valueRef, set: valueRef });\n  return valueRef as HybridRef<T>;\n}\n\n/**\n * Calls `callback` when the context is mounted. If `callback` returns a function, that function is called when the context is unmounted.\n */\nexport function useMount(callback: () => void | (() => void)): void {\n  const context = useContext();\n  context.onMount(() => {\n    const result = callback();\n    if (result) context.onUnmount(result);\n  });\n}\n\n/**\n * Calls `callback` when the context is unmounted.\n */\nexport function useUnmount(callback: () => void): void {\n  const context = useContext();\n  context.onUnmount(callback);\n}\n"],"names":["useContext","context","getCurrentContext","useLogger","name","useState","value","$value","$","useMemo","compute","deps","dep","get","untracked","useEffect","fn","useReducer","reducer","initialState","state","setState","action","current","useStore","store","useRef","valueRef","ref","useMount","callback","result","useUnmount"],"mappings":";;AAMO,SAASA,IAAsB;AACpC,QAAMC,IAAUC,EAAkB;AAClC,MAAI,CAACD;AACG,UAAA,IAAI,MAAM,mFAAmF;AAE9F,SAAAA;AACT;AAMO,SAASE,EAAUC,GAAoC;AAC5D,QAAMH,IAAUD,EAAW;AACvB,SAAAI,KAAcH,EAAA,QAAQG,CAAI,GACvBH;AACT;AAoBO,SAASI,EAAYC,GAAmC;AAClD,EAAAN,EAAA;AACL,QAAAO,IAASC,EAAEF,CAAK;AACtB,SAAO,CAAC,MAAMC,EAAO,GAAQA,CAAM;AACrC;AAEgB,SAAAE,EAAWC,GAA6BC,GAAiC;AAEvF,SADWX,EAAA,GACPW,IACKH,EAAE,WAAY;AAER,eAAAI,KAAOD,EAAM,CAAAE,EAAID,CAAG;AAC/B,WAAOE,EAAU,MAAMJ,EAAQ,KAAK,KAAK,CAAC;AAAA,EAAA,CAC3C,IAEMF,EAAE,WAAY;AACZ,WAAAE,EAAQ,KAAK,KAAK;AAAA,EAAA,CAC1B;AAEL;AAEgB,SAAAK,EAAUC,GAAcL,GAA4B;AAClE,QAAMV,IAAUD,EAAW;AAC3B,EAAIW,IACFV,EAAQ,OAAO,MAAM;AAER,eAAAW,KAAOD,EAAM,CAAAE,EAAID,CAAG;AAC/B,IAAAE,EAAUE,CAAE;AAAA,EAAA,CACb,IAEDf,EAAQ,OAAOe,CAAE;AAErB;AAmBgB,SAAAC,EACdC,GACAC,GACqC;AACrC,QAAM,CAACC,GAAOC,CAAQ,IAAIhB,EAASc,CAAY;AAIxC,SAAA,CAACC,GAHS,CAACE,MAAmB;AACnC,IAAAD,EAAS,CAACE,MAAYL,EAAQK,GAASD,CAAM,CAAC;AAAA,EAChD,CACuB;AACzB;AAKO,SAASE,EAAYC,GAAyB;AAE5C,SADSzB,EAAW,EACZ,SAASyB,CAAK;AAC/B;AAeO,SAASC,KAAapB,GAA0B;AAC1C,EAAAN,EAAA;AACL,QAAA2B,IAAWC,EAAI,GAAGtB,CAAK;AACtB,gBAAA,eAAeqB,GAAU,WAAW,EAAE,KAAKA,GAAU,KAAKA,GAAU,GACpEA;AACT;AAKO,SAASE,EAASC,GAA2C;AAClE,QAAM7B,IAAUD,EAAW;AAC3B,EAAAC,EAAQ,QAAQ,MAAM;AACpB,UAAM8B,IAASD,EAAS;AACpB,IAAAC,KAAgB9B,EAAA,UAAU8B,CAAM;AAAA,EAAA,CACrC;AACH;AAKO,SAASC,EAAWF,GAA4B;AAErD,EADgB9B,EAAW,EACnB,UAAU8B,CAAQ;AAC5B;"}