@manyducks.co/dolla 2.0.0-alpha.3 → 2.0.0-alpha.31

package/dist/core/batch.d.ts

@@ -0,0 +1,17 @@
+import type { Dolla } from "./dolla.js";
+/**
+ * Batches DOM updates; reads before writes.
+ */
+export declare class Batch {
+    #private;
+    constructor(dolla: Dolla);
+    /**
+     * Queues a callback that runs before the next batch of writes.
+     */
+    read(callback: () => void): void;
+    /**
+     * Queues a callback to run in the next render batch.
+     * Always put DOM mutations in a write callback when possible to help Dolla batch them efficiently.
+     */
+    write(callback: () => void, key?: string): void;
+}

package/dist/core/context.d.ts

@@ -0,0 +1,94 @@
+import type { Emitter } from "@manyducks.co/emitter";
+import type { Store, StoreFactory } from "./store";
+import type { Dolla } from "./dolla";
+interface ContextEmitterEvents {
+    [eventName: string | symbol]: [ContextEvent<any>];
+}
+export interface ElementContext {
+    /**
+     * The root Dolla instance this element belongs to.
+     */
+    root: Dolla;
+    /**
+     * Storage for context variables.
+     */
+    data: Record<string | symbol, unknown>;
+    /**
+     * Event emitter for this context.
+     */
+    emitter: Emitter<ContextEmitterEvents>;
+    /**
+     * Stores attached to this context.
+     */
+    stores: Map<string, Store<any, any>>;
+    /**
+     * A reference to the parent context.
+     */
+    parent?: ElementContext;
+    /**
+     * Whether to create DOM nodes in the SVG namespace. An `<svg>` element will set this to true and pass it down to children.
+     */
+    isSVG?: boolean;
+    /**
+     * The name of the nearest parent view.
+     */
+    viewName?: string;
+}
+/**
+ * Mapping of listener function passed to `.on` -> wrapped versions that discard eventName.
+ * Wrapping listeners is necessary because the context API's `.on` method does not pass the event name to "*" listeners while the emitter does.
+ * ContextEvent objects already have the event name stored as `event.type`.
+ */
+export type WildcardListenerMap = Map<(event: ContextEvent<any>) => void, (eventName: string | symbol, event: ContextEvent<any>) => void>;
+export interface ComponentContext {
+    /**
+     * Sets a context variable and returns its value.
+     */
+    set<T>(key: string | symbol, value: T): T;
+    /**
+     * Gets the value of a context variable. Returns null if the variable is not set.
+     */
+    get<T>(key: string | symbol): T | null;
+    /**
+     * Adds a listener to be called when `eventName` is emitted.
+     */
+    on<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    /**
+     * Removes a listener from the list to be called when `eventName` is emitted.
+     */
+    off<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    /**
+     * Adds a listener to be called when `eventName` is emitted. The listener is immediately removed after being called once.
+     */
+    once<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    /**
+     * Emits a new event to all listeners.
+     */
+    emit<T = unknown>(eventName: string, detail: T): boolean;
+}
+/**
+ * A context capable of hosting stores.
+ */
+export interface StorableContext extends ComponentContext {
+    /**
+     * Attaches a new store to this context.
+     */
+    attachStore(store: Store<any, any>): void;
+    /**
+     * Gets the closest instance of a store. Throws an error if the store isn't provided higher in the tree.
+     */
+    useStore<Value>(factory: StoreFactory<any, Value>): Value;
+}
+/**
+ * An event emitted from and received by a Dolla context. These are separate from DOM events.
+ */
+export declare class ContextEvent<T> {
+    #private;
+    type: string;
+    detail: T;
+    get propagationStopped(): boolean;
+    constructor(type: string, detail: T);
+    stopPropagation(): void;
+    get [Symbol.toStringTag](): string;
+}
+export {};

package/dist/core/dolla.d.ts

@@ -0,0 +1,161 @@
+import { HTTP } from "../modules/http.js";
+import { I18n } from "../modules/i18n.js";
+import { type Router } from "../modules/router.js";
+import { type CrashViewProps } from "../views/default-crash-view.js";
+import { Batch } from "./batch.js";
+import { ContextEvent, type StorableContext } from "./context.js";
+import { type Markup, type MarkupElement } from "./markup.js";
+import { type ViewElement, type ViewFunction } from "./nodes/view.js";
+import { createRef, isRef } from "./ref.js";
+import { createState, createWatcher, derive, isState, toState, toValue } from "./state.js";
+import { type Store, type StoreFactory } from "./store.js";
+export type Environment = "development" | "production";
+/**
+ * Log type toggles. Each message category can be turned on or off or enabled only in a specific environment.
+ */
+export type Loggles = {
+    info: boolean | Environment;
+    log: boolean | Environment;
+    warn: boolean | Environment;
+    error: boolean | Environment;
+};
+export interface Logger {
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    crash(error: Error): void;
+    setName(name: string): Logger;
+}
+export interface LoggerErrorContext {
+    error: Error;
+    loggerName: string;
+    uid?: string;
+}
+export type LoggerOptions = {
+    /**
+     * Console object to use for logging (mostly for testing). Uses window.console by default.
+     */
+    console?: any;
+    /**
+     * Unique ID to print with logs. Makes it easier to track down messages from specific view instances.
+     */
+    uid?: string;
+};
+export declare class Dolla implements StorableContext {
+    #private;
+    readonly batch: Batch;
+    private readonly stats;
+    readonly http: HTTP;
+    readonly i18n: I18n;
+    constructor();
+    watch: <I extends import("./state.js").MaybeState<any>[]>(states: [...I], fn: (...currentValues: import("./state.js").StateValues<I>) => void) => import("./state.js").StopFunction;
+    createState: typeof createState;
+    toState: typeof toState;
+    toValue: typeof toValue;
+    isState: typeof isState;
+    derive: typeof derive;
+    createWatcher: typeof createWatcher;
+    createRef: typeof createRef;
+    isRef: typeof isRef;
+    /**
+     * True when the app is connected to a DOM node and displayed to the user.
+     */
+    get isMounted(): boolean;
+    /**
+     * Get the current environment that this app is running in.
+     * Environment affects which log messages will print and how much debugging info is included in the DOM.
+     */
+    getEnv(): Environment;
+    /**
+     * Sets the environment that this app is running in.
+     * Environment affects which log messages will print and how much debugging info is included in the DOM.
+     */
+    setEnv(value: Environment): void;
+    /**
+     * Sets the view that will be shown when the `crash` method is called on any logger.
+     * When a crash is reported the app will be unmounted and replaced with this crash page.
+     */
+    setCrashView(view: ViewFunction<CrashViewProps>): void;
+    /**
+     * Returns the HTMLElement Dolla is mounted to. This will return undefined until Dolla.mount() is called.
+     */
+    getRootElement(): Element | undefined;
+    /**
+     * Returns the top level view Dolla is rendering inside the root element. This will return undefined until Dolla.mount() is called.
+     */
+    getRootView(): ViewElement | undefined;
+    /**
+     * Sets a context variable and returns its value. Context variables are accessible on the app and in child views.
+     */
+    set<T>(key: string | symbol, value: T): T;
+    /**
+     * Gets the value of a context variable. Returns null if the variable is not set.
+     */
+    get<T>(key: string | symbol): T | null;
+    /**
+     * Returns an object of all context variables stored at the app level.
+     */
+    /**
+     * Adds a listener to be called when `eventName` is emitted.
+     */
+    on<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    /**
+     * Removes a listener from the list to be called when `eventName` is emitted.
+     */
+    off<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    /**
+     * Adds a listener to be called when `eventName` is emitted. The listener is immediately removed after being called once.
+     */
+    once<T = unknown>(eventName: string, listener: (event: ContextEvent<T>) => void): void;
+    /**
+     * Emits a new event to all listeners.
+     */
+    emit<T = unknown>(eventName: string, detail: T): boolean;
+    /**
+     * Attaches a new store to this context.
+     */
+    attachStore(store: Store<any, any>): void;
+    /**
+     * Gets the nearest instance of a store. Throws an error if the store isn't provided higher in the tree.
+     */
+    useStore<Value>(factory: StoreFactory<any, Value>): Value;
+    mount(selector: string, router: Router): Promise<void>;
+    mount(selector: string, view: ViewFunction<any>): Promise<void>;
+    mount(element: Element, router: Router): Promise<void>;
+    mount(element: Element, view: ViewFunction<any>): Promise<void>;
+    unmount(): Promise<void>;
+    /**
+     * Registers a `callback` to run after `Dolla.mount` is called, before the app is mounted. If `callback` returns a Promise,
+     * it will be awaited before mounting finishes. Use this to perform initial setup before the app is displayed to the user.
+     */
+    beforeMount(callback: () => void | Promise<void>): void;
+    /**
+     * Registers a `callback` to run after the app is mounted.
+     */
+    onMount(callback: () => void): void;
+    /**
+     * Registers a `callback` to run after `Dolla.unmount` is called, before the app is unmounted. If `callback` returns a Promise,
+     * it will be awaited before unmounting finishes. Use this to perform cleanup.
+     */
+    beforeUnmount(callback: () => void | Promise<void>): void;
+    /**
+     * Registers a `callback` to run after the app is unmounted.
+     */
+    onUnmount(callback: () => void): void;
+    /**
+     * Update log type toggles. Values that are not passed will remain unchanged.
+     */
+    setLoggles(options: Partial<Loggles>): void;
+    setLogFilter(filter: string | RegExp): void;
+    createLogger(name: string, options?: LoggerOptions): Logger;
+    /**
+     *
+     */
+    constructView<P>(view: ViewFunction<P>, props: P, children?: Markup[]): ViewElement;
+    /**
+     *
+     */
+    constructMarkup(markup: Markup | Markup[]): MarkupElement;
+}
+export declare function getDefaultConsole(): any;

package/dist/core/markup.d.ts

@@ -0,0 +1,91 @@
+import type { Renderable } from "../types.js";
+import type { ElementContext } from "./context.js";
+import { type ViewContext, type ViewFunction, type ViewResult } from "./nodes/view.js";
+import { type MaybeState, type State } from "./state.js";
+/**
+ * Markup is a set of element metadata that hasn't been constructed into a MarkupElement yet.
+ */
+export interface Markup {
+    /**
+     * In the case of a view, type will be the View function itself. It can also hold an identifier for special nodes like "$cond", "$repeat", etc.
+     * DOM nodes can be created by name, such as HTML elements like "div", "ul" or "span", SVG elements like ""
+     */
+    type: string | ViewFunction<any>;
+    /**
+     * Data that will be passed to a new MarkupElement instance when it is constructed.
+     */
+    props?: Record<string, any>;
+    /**
+     *
+     */
+    children?: Markup[];
+}
+/**
+ * A DOM node that has been constructed from a Markup object.
+ */
+export interface MarkupElement {
+    readonly node?: Node;
+    readonly isMounted: boolean;
+    mount(parent: Node, after?: Node): void;
+    /**
+     * Disconnect from the DOM and clean up. If parentIsUnmounting, DOM operations are skipped.
+     * parentIsUnmounting is set for all children by HTML nodes when they unmount.
+     */
+    unmount(parentIsUnmounting?: boolean): void;
+}
+export declare function isMarkup(value: any): value is Markup;
+export declare function isMarkupElement(value: any): value is MarkupElement;
+export declare function toMarkup(renderables: Renderable | Renderable[]): Markup[];
+export interface MarkupAttributes {
+    $text: {
+        value: any;
+    };
+    $repeat: {
+        $items: State<any[]>;
+        keyFn: (value: any, index: number) => string | number | symbol;
+        renderFn: ($item: State<any>, $index: State<number>, c: ViewContext) => ViewResult;
+    };
+    $observer: {
+        sources: MaybeState<any>[];
+        renderFn: (...items: any) => Renderable;
+    };
+    $outlet: {
+        $children: State<MarkupElement[]>;
+    };
+    $node: {
+        value: Node;
+    };
+    $portal: {
+        content: Renderable;
+        parent: Node;
+    };
+    [tag: string]: Record<string, any>;
+}
+export declare function createMarkup<T extends keyof MarkupAttributes>(type: T, attributes: MarkupAttributes[T], ...children: Renderable[]): Markup;
+export declare function createMarkup<I>(type: ViewFunction<I>, attributes?: I, ...children: Renderable[]): Markup;
+/**
+ * Generate markup with HTML in a tagged template literal.
+ */
+export declare const html: (strings: TemplateStringsArray, ...values: any[]) => Markup | Markup[];
+/**
+ * Displays content conditionally. When `predicate` holds a truthy value, `thenContent` is displayed; when `predicate` holds a falsy value, `elseContent` is displayed.
+ */
+export declare function cond(predicate: MaybeState<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
+/**
+ * Calls `renderFn` for each item in `items`. Dynamically adds and removes views as items change.
+ * The result of `keyFn` is used to compare items and decide if item was added, removed or updated.
+ */
+export declare function repeat<T>(items: MaybeState<T[]>, keyFn: (value: T, index: number) => string | number | symbol, renderFn: ($value: State<T>, $index: State<number>, ctx: ViewContext) => ViewResult): Markup;
+/**
+ * Renders `content` into a `parent` node anywhere in the page, rather than its usual position in the view.
+ */
+export declare function portal(parent: Node, content: Renderable): Markup;
+/**
+ * Construct Markup metadata into a set of MarkupElements.
+ */
+export declare function constructMarkup(elementContext: ElementContext, markup: Markup | Markup[]): MarkupElement[];
+/**
+ * Combines one or more MarkupElements into a single MarkupElement.
+ */
+export declare function groupElements(elements: MarkupElement[]): MarkupElement;
+export declare function isRenderable(value: unknown): value is Renderable;

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

@@ -0,0 +1,13 @@
+import type { MarkupElement } from "../markup";
+import { IS_MARKUP_ELEMENT } from "../symbols";
+/**
+ * Wraps any plain DOM node in a MarkupElement interface.
+ */
+export declare class DOMNode implements MarkupElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    node: Node;
+    get isMounted(): boolean;
+    constructor(node: Node);
+    mount(parent: Node, after?: Node): void;
+    unmount(parentIsUnmounting?: boolean): void;
+}

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

@@ -0,0 +1,39 @@
+import { type ElementContext } from "../context.js";
+import { type Markup, type MarkupElement } from "../markup.js";
+import { type Ref } from "../ref.js";
+import { type State, type StopFunction } from "../state.js";
+import { IS_MARKUP_ELEMENT } from "../symbols.js";
+type HTMLOptions = {
+    elementContext: ElementContext;
+    tag: string;
+    props: Record<string, any>;
+    children?: Markup[];
+};
+export declare class HTML implements MarkupElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    node: HTMLElement | SVGElement;
+    props: Record<string, any>;
+    childMarkup: Markup[];
+    children: MarkupElement[];
+    stopCallbacks: StopFunction[];
+    elementContext: ElementContext;
+    uniqueId: string;
+    _batchWrite: (callback: () => void, key?: string) => void;
+    ref?: Ref<any>;
+    canClickAway: boolean;
+    get isMounted(): boolean;
+    constructor({ tag, props, children, elementContext }: HTMLOptions);
+    mount(parent: Node, after?: Node): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    getUpdateKey(type: string, value: string | number): string;
+    _mutate(callback: () => any, updateKey?: string): void;
+    attachProp<T>(value: State<T> | T, callback: (value: T) => void, updateKey: string): void;
+    applyProps(element: HTMLElement | SVGElement, props: Record<string, unknown>): void;
+    applyStyles(element: HTMLElement | SVGElement, styles: unknown, stopCallbacks: StopFunction[]): () => void;
+    applyClasses(element: HTMLElement | SVGElement, classes: unknown, stopCallbacks: StopFunction[]): () => void;
+}
+/**
+ * Converts a camelCase string to kebab-case.
+ */
+export declare function camelToKebab(value: string): string;
+export {};

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

@@ -0,0 +1,30 @@
+import type { Renderable } from "../../types.js";
+import type { ElementContext } from "../context.js";
+import { type MarkupElement } from "../markup.js";
+import { type MaybeState } from "../state.js";
+import { IS_MARKUP_ELEMENT } from "../symbols.js";
+interface ObserverOptions {
+    elementContext: ElementContext;
+    sources: MaybeState<any>[];
+    renderFn: (...values: any) => Renderable;
+}
+/**
+ * Displays dynamic children without a parent element.
+ * Used when a State is passed as a child in a view template.
+ */
+export declare class Observer implements MarkupElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    node: Text;
+    children: MarkupElement[];
+    renderFn: (...values: any) => Renderable;
+    elementContext: ElementContext;
+    watcher: import("../state.js").StateWatcher;
+    sources: MaybeState<any>[];
+    get isMounted(): boolean;
+    constructor({ sources, renderFn, elementContext }: ObserverOptions);
+    mount(parent: Node, after?: Node): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    cleanup(parentIsUnmounting: boolean): void;
+    update(children: Renderable[]): void;
+}
+export {};

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

@@ -0,0 +1,19 @@
+import { type MarkupElement } from "../markup.js";
+import { type MaybeState, type StopFunction } from "../state.js";
+import { IS_MARKUP_ELEMENT } from "../symbols.js";
+/**
+ * Manages several MarkupElements as one.
+ */
+export declare class Outlet implements MarkupElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    node: Text;
+    isMounted: boolean;
+    source: MaybeState<MarkupElement[]>;
+    elements: MarkupElement[];
+    stopCallback?: StopFunction;
+    constructor(source: MaybeState<MarkupElement[]>);
+    mount(parent: Node, after?: Node | undefined): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    cleanup(parentIsUnmounting: boolean): void;
+    update(newElements: MarkupElement[]): void;
+}

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

@@ -0,0 +1,22 @@
+import type { Renderable } from "../../types.js";
+import type { ElementContext } from "../context.js";
+import { type MarkupElement } from "../markup.js";
+import { IS_MARKUP_ELEMENT } from "../symbols.js";
+interface PortalConfig {
+    content: Renderable;
+    parent: Node;
+    elementContext: ElementContext;
+}
+/**
+ * Renders content into a specified parent node.
+ */
+export declare class Portal implements MarkupElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    config: PortalConfig;
+    element?: MarkupElement;
+    get isMounted(): boolean;
+    constructor(config: PortalConfig);
+    mount(_parent: Node, _after?: Node): void;
+    unmount(parentIsUnmounting?: boolean): void;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { type ElementContext } from "../context.js";
+import { type MarkupElement } from "../markup.js";
+import { type Setter, type State, type StopFunction } from "../state.js";
+import { IS_MARKUP_ELEMENT } from "../symbols.js";
+import { type ViewContext, type ViewResult } from "./view.js";
+interface RepeatOptions<T> {
+    elementContext: ElementContext;
+    $items: State<T[]>;
+    keyFn: (value: T, index: number) => string | number | symbol;
+    renderFn: ($value: State<T>, $index: State<number>, ctx: ViewContext) => ViewResult;
+}
+type ConnectedItem<T> = {
+    key: any;
+    $value: State<T>;
+    setValue: Setter<T>;
+    $index: State<number>;
+    setIndex: Setter<number>;
+    element: MarkupElement;
+};
+export declare class Repeat<T> implements MarkupElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    node: Text;
+    $items: State<T[]>;
+    stopCallback?: StopFunction;
+    connectedItems: ConnectedItem<T>[];
+    elementContext: ElementContext;
+    renderFn: (this: ViewContext, $value: State<T>, $index: State<number>, context: ViewContext) => ViewResult;
+    keyFn: (value: T, index: number) => string | number | symbol;
+    get isMounted(): boolean;
+    constructor({ elementContext, $items, renderFn, keyFn }: RepeatOptions<T>);
+    mount(parent: Node, after?: Node): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    _cleanup(parentIsUnmounting: boolean): void;
+    _update(value: T[]): void;
+}
+export {};

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

@@ -0,0 +1,92 @@
+import { Emitter } from "@manyducks.co/emitter";
+import { type WildcardListenerMap, type ElementContext, type StorableContext } from "../context.js";
+import type { Logger } from "../dolla.js";
+import { type Markup, type MarkupElement } from "../markup.js";
+import { type MaybeState, type State, type StateValues, type StopFunction } from "../state.js";
+import { IS_MARKUP_ELEMENT } from "../symbols.js";
+/**
+ * Any valid value that a View can return.
+ */
+export type ViewResult = Node | State<any> | Markup | Markup[] | null;
+export type ViewFunction<P> = (this: ViewContext, props: P, context: ViewContext) => ViewResult;
+/**
+ * A view that has been constructed into DOM nodes.
+ */
+export interface ViewElement extends MarkupElement {
+    /**
+     * Take a ViewFunction and render it as a child of this view.
+     */
+    setChildView(view: ViewFunction<{}>): ViewElement;
+}
+export interface ViewContext extends Logger, StorableContext {
+    /**
+     * An ID unique to this view.
+     */
+    readonly uid: string;
+    /**
+     * Returns an object of all variables stored on this context.
+     */
+    /**
+     * Sets the name of the view's built in logger.
+     */
+    setName(name: string): ViewContext;
+    /**
+     * True while this view is connected to the DOM.
+     */
+    readonly isMounted: boolean;
+    /**
+     * Registers a callback to run just before this view is mounted. DOM nodes are not yet attached to the page.
+     */
+    beforeMount(callback: () => void): void;
+    /**
+     * Registers a callback to run just after this view is mounted.
+     */
+    onMount(callback: () => void): void;
+    /**
+     * Registers a callback to run just before this view is unmounted. DOM nodes are still attached to the page.
+     */
+    beforeUnmount(callback: () => void): void;
+    /**
+     * Registers a callback to run just after this view is unmounted.
+     */
+    onUnmount(callback: () => void): void;
+    /**
+     * Watch a set of states. The callback is called when any of the states receive a new value.
+     * Watchers will be automatically stopped when this view is unmounted.
+     */
+    watch<T extends MaybeState<any>[]>(states: [...T], callback: (...values: StateValues<T>) => void): StopFunction;
+    /**
+     * Returns a Markup element that displays this view's children.
+     */
+    outlet(): Markup;
+}
+export declare function createView<Props extends Record<string, any> = Record<string, unknown>>(fn: ViewFunction<Props>): ViewFunction<Props>;
+type ViewEvents = {
+    beforeMount: [];
+    mounted: [];
+    beforeUnmount: [];
+    unmounted: [];
+};
+export declare class View<P> implements ViewElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    uniqueId: string;
+    _elementContext: ElementContext;
+    _logger: Logger;
+    _view: ViewFunction<P>;
+    _props: P;
+    _element?: MarkupElement;
+    _childMarkup: Markup[];
+    _$children: State<MarkupElement[]>;
+    _setChildren: import("../state.js").Setter<MarkupElement[], MarkupElement[]>;
+    _watcher: import("../state.js").StateWatcher;
+    _emitter: Emitter<ViewEvents>;
+    _wildcardListeners: WildcardListenerMap;
+    constructor(elementContext: ElementContext, view: ViewFunction<P>, props: P, children?: Markup[]);
+    get node(): Node;
+    isMounted: boolean;
+    mount(parent: Node, after?: Node): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    setChildView(fn: ViewFunction<{}>): View<{}>;
+    private _initialize;
+}
+export {};

package/dist/core/ref.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A `Ref` is a function that stores a value when called with a single argument,
+ * and returns the most recently stored value when called with no arguments.
+ */
+export interface Ref<T> {
+    /**
+     * Get: returns the current value stored in the ref (or undefined).
+     */
+    (): T | undefined;
+    /**
+     * Set: stores a new `value` in the ref.
+     */
+    <T>(value: T | undefined): void;
+}
+/**
+ * A Ref is a function that returns the last argument it was called with.
+ * Calling it with no arguments will simply return the latest value.
+ * Calling it with an argument will store that value and immediately return it.
+ *
+ * @param value - An (optional) initial value to store.
+ *
+ * @example
+ * const ref = createRef(5);
+ * ref(); // 5
+ * ref(500);
+ * ref(); // 500
+ */
+export declare function createRef<T>(value?: T): Ref<T>;
+export declare function isRef<T extends Node>(value: any): value is Ref<T>;