@manyducks.co/dolla 0.67.0

package/lib/jsx/jsx-dev-runtime.d.ts

@@ -0,0 +1,3 @@
+export function jsxDEV(element: any, props: any, key: any, isStaticChildren: any, source: any, self: any): import("../markup.js").Markup;
+export { Fragment };
+import { Fragment } from "../index.js";

package/lib/jsx/jsx-dev-runtime.js

@@ -0,0 +1,20 @@
+import { m, Fragment } from "../index.js";
+function jsxDEV(element, props, key, isStaticChildren, source, self) {
+  const attributes = { ...omit(["children", "key"], props) };
+  const children = Array.isArray(props.children) ? props.children : [props.children];
+  return m(element, attributes, ...children);
+}
+function omit(keys, object) {
+  const result = {};
+  for (const key in object) {
+    if (!keys.includes(key)) {
+      result[key] = object[key];
+    }
+  }
+  return result;
+}
+export {
+  Fragment,
+  jsxDEV
+};
+//# sourceMappingURL=jsx-dev-runtime.js.map

package/lib/jsx/jsx-dev-runtime.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/jsx/jsx-dev-runtime.js"],
+  "sourcesContent": ["// This import makes sense when built\nimport { m, Fragment } from \"../index.js\";\n\nexport { Fragment };\n\nexport function jsxDEV(element, props, key, isStaticChildren, source, self) {\n  const attributes = { ...omit([\"children\", \"key\"], props) };\n  const children = Array.isArray(props.children) ? props.children : [props.children];\n\n  return m(element, attributes, ...children);\n}\n\nfunction omit(keys, object) {\n  const result = {};\n  for (const key in object) {\n    if (!keys.includes(key)) {\n      result[key] = object[key];\n    }\n  }\n  return result;\n}\n"],
+  "mappings": "AACA,SAAS,GAAG,gBAAgB;AAIrB,SAAS,OAAO,SAAS,OAAO,KAAK,kBAAkB,QAAQ,MAAM;AAC1E,QAAM,aAAa,EAAE,GAAG,KAAK,CAAC,YAAY,KAAK,GAAG,KAAK,EAAE;AACzD,QAAM,WAAW,MAAM,QAAQ,MAAM,QAAQ,IAAI,MAAM,WAAW,CAAC,MAAM,QAAQ;AAEjF,SAAO,EAAE,SAAS,YAAY,GAAG,QAAQ;AAC3C;AAEA,SAAS,KAAK,MAAM,QAAQ;AAC1B,QAAM,SAAS,CAAC;AAChB,aAAW,OAAO,QAAQ;AACxB,QAAI,CAAC,KAAK,SAAS,GAAG,GAAG;AACvB,aAAO,GAAG,IAAI,OAAO,GAAG;AAAA,IAC1B;AAAA,EACF;AACA,SAAO;AACT;",
+  "names": []
+}

package/lib/jsx/jsx-runtime.d.ts

@@ -0,0 +1,10 @@
+/**
+ * JSX function for elements with dynamic children.
+ */
+export function jsx(element: any, props: any, key: any): import("../markup.js").Markup;
+/**
+ * JSX function for elements with static children.
+ */
+export function jsxs(element: any, props: any, key: any): import("../markup.js").Markup;
+export { Fragment };
+import { Fragment } from "../index.js";

package/lib/jsx/jsx-runtime.js

@@ -0,0 +1,22 @@
+import { m, Fragment } from "../index.js";
+function jsx(element, props, key) {
+  return m(element, props ? { ...omit(["children", "key"], props) } : void 0, ...[props.children]);
+}
+function jsxs(element, props, key) {
+  return m(element, props ? { ...omit(["children", "key"], props) } : void 0, props.children);
+}
+function omit(keys, object) {
+  const result = {};
+  for (const key in object) {
+    if (!keys.includes(key)) {
+      result[key] = object[key];
+    }
+  }
+  return result;
+}
+export {
+  Fragment,
+  jsx,
+  jsxs
+};
+//# sourceMappingURL=jsx-runtime.js.map

package/lib/jsx/jsx-runtime.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/jsx/jsx-runtime.js"],
+  "sourcesContent": ["// This import makes sense when built\nimport { m, Fragment } from \"../index.js\";\n\nexport { Fragment };\n\n/**\n * JSX function for elements with dynamic children.\n */\nexport function jsx(element, props, key) {\n  return m(element, props ? { ...omit([\"children\", \"key\"], props) } : undefined, ...[props.children]);\n}\n\n/**\n * JSX function for elements with static children.\n */\nexport function jsxs(element, props, key) {\n  return m(element, props ? { ...omit([\"children\", \"key\"], props) } : undefined, props.children);\n}\n\nfunction omit(keys, object) {\n  const result = {};\n  for (const key in object) {\n    if (!keys.includes(key)) {\n      result[key] = object[key];\n    }\n  }\n  return result;\n}\n"],
+  "mappings": "AACA,SAAS,GAAG,gBAAgB;AAOrB,SAAS,IAAI,SAAS,OAAO,KAAK;AACvC,SAAO,EAAE,SAAS,QAAQ,EAAE,GAAG,KAAK,CAAC,YAAY,KAAK,GAAG,KAAK,EAAE,IAAI,QAAW,GAAG,CAAC,MAAM,QAAQ,CAAC;AACpG;AAKO,SAAS,KAAK,SAAS,OAAO,KAAK;AACxC,SAAO,EAAE,SAAS,QAAQ,EAAE,GAAG,KAAK,CAAC,YAAY,KAAK,GAAG,KAAK,EAAE,IAAI,QAAW,MAAM,QAAQ;AAC/F;AAEA,SAAS,KAAK,MAAM,QAAQ;AAC1B,QAAM,SAAS,CAAC;AAChB,aAAW,OAAO,QAAQ;AACxB,QAAI,CAAC,KAAK,SAAS,GAAG,GAAG;AACvB,aAAO,GAAG,IAAI,OAAO,GAAG;AAAA,IAC1B;AAAA,EACF;AACA,SAAO;AACT;",
+  "names": []
+}

package/lib/markup.d.ts

@@ -0,0 +1,81 @@
+import { type AppContext, type ElementContext } from "./app.js";
+import { type Readable } from "./state.js";
+import type { Renderable, Stringable } from "./types.js";
+import { type View, type ViewContext, type ViewResult } from "./view.js";
+/**
+ * Markup is a set of element metadata that hasn't been rendered to a DOMHandle yet.
+ */
+export interface Markup {
+    type: string | View<any>;
+    props?: Record<string, any>;
+    children?: Markup[];
+}
+/**
+ * DOMHandle is the generic interface for an element that can be manipulated by the framework.
+ */
+export interface DOMHandle {
+    readonly node?: Node;
+    readonly connected: boolean;
+    connect(parent: Node, after?: Node): void;
+    disconnect(): void;
+    setChildren(children: DOMHandle[]): void;
+}
+export declare function isMarkup(value: unknown): value is Markup;
+export declare function isDOMHandle(value: unknown): value is DOMHandle;
+export declare function toMarkup(renderables: Renderable | Renderable[]): Markup[];
+export interface MarkupAttributes {
+    $text: {
+        value: Stringable | Readable<Stringable>;
+    };
+    $cond: {
+        $predicate: Readable<any>;
+        thenContent?: Renderable;
+        elseContent?: Renderable;
+    };
+    $repeat: {
+        $items: Readable<any[]>;
+        keyFn: (value: any, index: number) => string | number | symbol;
+        renderFn: ($item: Readable<any>, $index: Readable<number>, c: ViewContext) => ViewResult;
+    };
+    $observer: {
+        readables: Readable<any>[];
+        renderFn: (...items: any) => Renderable;
+    };
+    $outlet: {
+        $children: Readable<DOMHandle[]>;
+    };
+    $node: {
+        value: Node;
+    };
+    $portal: {
+        content: Renderable;
+        parent: Node;
+    };
+    [tag: string]: Record<string, any>;
+}
+export declare function m<T extends keyof MarkupAttributes>(type: T, attributes: MarkupAttributes[T], ...children: Renderable[]): Markup;
+export declare function m<I>(type: View<I>, attributes?: I, ...children: Renderable[]): 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: any | Readable<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: Readable<T[]> | T[], keyFn: (value: T, index: number) => string | number | symbol, renderFn: ($value: Readable<T>, $index: Readable<number>, ctx: ViewContext) => ViewResult): Markup;
+/**
+ * Render `content` into a `parent` node anywhere in the page, rather than at its position in the view.
+ */
+export declare function portal(content: Renderable, parent: Node): Markup;
+interface RenderContext {
+    appContext: AppContext;
+    elementContext: ElementContext;
+}
+export declare function renderMarkupToDOM(markup: Markup | Markup[], ctx: RenderContext): DOMHandle[];
+/**
+ * Combines one or more DOMHandles into a single DOMHandle.
+ */
+export declare function getRenderHandle(handles: DOMHandle[]): DOMHandle;
+export declare function isRenderable(value: unknown): value is Renderable;
+export {};

package/lib/nodes/cond.d.ts

@@ -0,0 +1,28 @@
+import { type AppContext, type ElementContext } from "../app.js";
+import { type DOMHandle, type Markup } from "../markup.js";
+import { type Readable, type StopFunction } from "../state.js";
+import { type Renderable } from "../types.js";
+export interface ConditionalConfig {
+    $predicate: Readable<any>;
+    thenContent?: Renderable;
+    elseContent?: Renderable;
+    appContext: AppContext;
+    elementContext: ElementContext;
+}
+export declare class Conditional implements DOMHandle {
+    node: Node;
+    endNode: Node;
+    $predicate: Readable<any>;
+    stopCallback?: StopFunction;
+    thenContent?: Markup[];
+    elseContent?: Markup[];
+    connectedContent: DOMHandle[];
+    appContext: AppContext;
+    elementContext: ElementContext;
+    constructor(config: ConditionalConfig);
+    get connected(): boolean;
+    connect(parent: Node, after?: Node | undefined): void;
+    disconnect(): void;
+    update(value: any): void;
+    setChildren(children: DOMHandle[]): Promise<void>;
+}

package/lib/nodes/html.d.ts

@@ -0,0 +1,30 @@
+import { type AppContext, type ElementContext } from "../app.js";
+import { type DOMHandle, type Markup } from "../markup.js";
+import { type StopFunction } from "../state.js";
+type HTMLOptions = {
+    appContext: AppContext;
+    elementContext: ElementContext;
+    tag: string;
+    props?: any;
+    children?: Markup[];
+};
+export declare class HTML implements DOMHandle {
+    node: HTMLElement | SVGElement;
+    props: Record<string, any>;
+    children: DOMHandle[];
+    stopCallbacks: StopFunction[];
+    appContext: AppContext;
+    elementContext: ElementContext;
+    uniqueId: string;
+    canClickAway: boolean;
+    get connected(): boolean;
+    constructor({ tag, props, children, appContext, elementContext }: HTMLOptions);
+    connect(parent: Node, after?: Node): void;
+    disconnect(): void;
+    setChildren(next: DOMHandle[]): void;
+    getUpdateKey(type: string, value: string | number): string;
+    applyProps(element: HTMLElement | SVGElement, props: Record<string, unknown>): void;
+    applyStyles(element: HTMLElement | SVGElement, styles: Record<string, any>, stopCallbacks: StopFunction[]): () => void;
+    applyClasses(element: HTMLElement | SVGElement, classes: unknown, stopCallbacks: StopFunction[]): () => void;
+}
+export {};

package/lib/nodes/observer.d.ts

@@ -0,0 +1,33 @@
+import { type AppContext, type ElementContext } from "../app.js";
+import type { Renderable } from "../types.js";
+import { type DOMHandle } from "../markup.js";
+import { type Readable } from "../state.js";
+interface ObserverOptions {
+    appContext: AppContext;
+    elementContext: ElementContext;
+    readables: Readable<any>[];
+    renderFn: (...values: any) => Renderable;
+}
+/**
+ * Displays dynamic children without a parent element.
+ */
+export declare class Observer implements DOMHandle {
+    node: Node;
+    endNode: Node;
+    connectedViews: DOMHandle[];
+    renderFn: (...values: any) => Renderable;
+    appContext: AppContext;
+    elementContext: ElementContext;
+    observerControls: {
+        start: () => void;
+        stop: () => void;
+    };
+    get connected(): boolean;
+    constructor({ readables, renderFn, appContext, elementContext }: ObserverOptions);
+    connect(parent: Node, after?: Node): void;
+    disconnect(): void;
+    setChildren(): Promise<void>;
+    cleanup(): void;
+    update(...children: Renderable[]): void;
+}
+export {};

package/lib/nodes/outlet.d.ts

@@ -0,0 +1,26 @@
+import { type ElementContext, type AppContext } from "../app.js";
+import { type DOMHandle } from "../markup.js";
+import { type Readable, type StopFunction } from "../state.js";
+export interface OutletConfig {
+    $children: Readable<DOMHandle[]>;
+    appContext: AppContext;
+    elementContext: ElementContext;
+}
+/**
+ * Manages an array of DOMHandles.
+ */
+export declare class Outlet implements DOMHandle {
+    node: Node;
+    endNode: Node;
+    $children: Readable<DOMHandle[]>;
+    stopCallback?: StopFunction;
+    connectedChildren: DOMHandle[];
+    appContext: AppContext;
+    elementContext: ElementContext;
+    constructor(config: OutletConfig);
+    get connected(): boolean;
+    connect(parent: Node, after?: Node | undefined): void;
+    disconnect(): void;
+    update(newChildren: DOMHandle[]): void;
+    setChildren(children: DOMHandle[]): void;
+}

package/lib/nodes/portal.d.ts

@@ -0,0 +1,22 @@
+import { type AppContext, type ElementContext } from "../app.js";
+import { type DOMHandle } from "../markup.js";
+import { type Renderable } from "../types.js";
+interface PortalConfig {
+    content: Renderable;
+    parent: Node;
+    appContext: AppContext;
+    elementContext: ElementContext;
+}
+/**
+ * Renders content into a specified parent node.
+ */
+export declare class Portal implements DOMHandle {
+    config: PortalConfig;
+    handle?: DOMHandle;
+    get connected(): boolean;
+    constructor(config: PortalConfig);
+    connect(_parent: Node, _after?: Node): void;
+    disconnect(): void;
+    setChildren(children: DOMHandle[]): void;
+}
+export {};

package/lib/nodes/repeat.d.ts

@@ -0,0 +1,36 @@
+import { type AppContext, type ElementContext } from "../app.js";
+import { type DOMHandle } from "../markup.js";
+import { type Readable, type StopFunction, type Writable } from "../state.js";
+import { type ViewContext, type ViewResult } from "../view.js";
+interface RepeatOptions<T> {
+    appContext: AppContext;
+    elementContext: ElementContext;
+    $items: Readable<T[]>;
+    keyFn: (value: T, index: number) => string | number | symbol;
+    renderFn: ($value: Readable<T>, $index: Readable<number>, ctx: ViewContext) => ViewResult;
+}
+type ConnectedItem<T> = {
+    key: any;
+    $$value: Writable<T>;
+    $$index: Writable<number>;
+    handle: DOMHandle;
+};
+export declare class Repeat<T> implements DOMHandle {
+    node: Node;
+    endNode: Node;
+    $items: Readable<T[]>;
+    stopCallback?: StopFunction;
+    connectedItems: ConnectedItem<T>[];
+    appContext: AppContext;
+    elementContext: ElementContext;
+    renderFn: ($value: Readable<T>, $index: Readable<number>, ctx: ViewContext) => ViewResult;
+    keyFn: (value: T, index: number) => string | number | symbol;
+    get connected(): boolean;
+    constructor({ appContext, elementContext, $items, renderFn, keyFn }: RepeatOptions<T>);
+    connect(parent: Node, after?: Node): void;
+    disconnect(): void;
+    setChildren(): void;
+    _cleanup(): void;
+    _update(value: T[]): void;
+}
+export {};

package/lib/nodes/text.d.ts

@@ -0,0 +1,20 @@
+import { type Readable, type StopFunction } from "../state.js";
+import { type DOMHandle } from "../markup.js";
+interface Stringable {
+    toString(): string;
+}
+interface TextOptions {
+    value: Stringable | Readable<Stringable>;
+}
+export declare class Text implements DOMHandle {
+    node: globalThis.Text;
+    value: Stringable | Readable<Stringable>;
+    stopCallback?: StopFunction;
+    get connected(): boolean;
+    constructor({ value }: TextOptions);
+    connect(parent: Node, after?: Node | null): Promise<void>;
+    disconnect(): Promise<void>;
+    update(value?: Stringable): void;
+    setChildren(): Promise<void>;
+}
+export {};

package/lib/spring.d.ts

@@ -0,0 +1,40 @@
+import { type Readable, type Writable } from "./state.js";
+export interface SpringParameters {
+    /**
+     * How heavy the spring is.
+     */
+    mass: number | Readable<number>;
+    /**
+     * Amount of stiffness or tension in the spring.
+     */
+    stiffness: number | Readable<number>;
+    /**
+     * Amount of smoothing. Affects the speed of transitions.
+     */
+    damping: number | Readable<number>;
+    /**
+     * How much force the spring's motion begins with.
+     */
+    velocity: number | Readable<number>;
+}
+interface SpringOptions extends Partial<SpringParameters> {
+    /**
+     * Difference in average amplitude across the last several frames before the animation is considered done.
+     * The exact number of frames to average is specified by `endWindow`.
+     */
+    endAmplitude?: number | Readable<number>;
+    /**
+     * Specifies the number of frames across which to measure the average amplitude to determine when the animation is considered done.
+     * The maximum amplitude is specified by `endAmplitude`.
+     */
+    endWindow?: number | Readable<number>;
+}
+export interface Spring extends Writable<number> {
+    /**
+     * Takes a new value and animates to it. Returns a promise that resolves when the animation ends.
+     * Optionally takes a set of override spring options to animate with.
+     */
+    animateTo(newValue: number, options?: SpringOptions): Promise<void>;
+}
+export declare function spring(initialValue: number, options?: SpringOptions): Spring;
+export {};

package/lib/state.d.ts

@@ -0,0 +1,84 @@
+export declare const OBSERVE: unique symbol;
+/**
+ * Stops the observer that created it when called.
+ */
+export type StopFunction = () => void;
+type ObserveMethod<T> = (callback: (currentValue: T, previousValue?: T) => void) => StopFunction;
+/**
+ * Extracts value types from an array of Readables.
+ */
+export type ReadableValues<T extends Readable<any>[]> = {
+    [K in keyof T]: T[K] extends Readable<infer U> ? U : never;
+};
+export type Unwrapped<T> = T extends Readable<infer U> ? U : T;
+export interface Observable<T> {
+    /**
+     * Receives the latest value with `callback` whenever the value changes.
+     * The `previousValue` is always undefined the first time the callback is called, then the same value as the last time it was called going forward.
+     */
+    [OBSERVE]: ObserveMethod<T>;
+}
+export interface Readable<T> extends Observable<T> {
+    /**
+     * Returns the current value.
+     */
+    get(): T;
+}
+export interface Writable<T> extends Readable<T> {
+    /**
+     * Sets a new value.
+     */
+    set(value: T): void;
+    /**
+     * Passes the current value to `callback` and takes `callback`'s return value as the new value.
+     */
+    update(callback: (currentValue: T) => T): void;
+}
+export declare function isObservable<T>(value: any): value is Observable<T>;
+export declare function isReadable<T>(value: any): value is Readable<T>;
+export declare function isWritable<T>(value: any): value is Writable<T>;
+export declare function readable<T>(value: Writable<T>): Readable<Unwrapped<T>>;
+export declare function readable<T>(value: Readable<T>): Readable<Unwrapped<T>>;
+export declare function readable<T>(value: undefined): Readable<T | undefined>;
+export declare function readable<T>(): Readable<T | undefined>;
+export declare function readable<T>(value: T): Readable<Unwrapped<T>>;
+export declare function writable<T>(value: Writable<T>): Writable<Unwrapped<T>>;
+export declare function writable<T>(value: Readable<T>): never;
+export declare function writable<T>(value: undefined): Writable<T | undefined>;
+export declare function writable<T>(): Writable<T | undefined>;
+export declare function writable<T>(value: T): Writable<Unwrapped<T>>;
+/**
+ * Observes a readable value. Calls `callback` each time the value changes.
+ * Returns a function to stop observing changes. This MUST be called when you are done
+ * with this observer to prevent memory leaks.
+ */
+export declare function observe<T>(readable: Readable<T>, callback: (currentValue: T, previousValue: T) => void): StopFunction;
+/**
+ * Observes a set of readable values.
+ * Calls `callback` with each value in the same order as `readables` each time any of their values change.
+ * Returns a function to stop observing changes. This MUST be called when you are done
+ * with this observer to prevent memory leaks.
+ */
+export declare function observe<T extends Readable<any>[]>(readables: [...T], callback: (currentValues: ReadableValues<T>, previousValues: ReadableValues<T>) => void): StopFunction;
+export declare function computed<I, O>(readable: Readable<I>, compute: (currentValue: I, previousValue?: I) => O): Readable<O>;
+export declare function computed<I extends Readable<any>[], O>(readables: [...I], compute: (currentValues: ReadableValues<I>, previousValues?: ReadableValues<I>) => O): Readable<O>;
+interface ProxyConfig<Source, Value> {
+    get(source: Source): Value;
+    set(source: Source, value: Value): void;
+}
+/**
+ * Creates a proxy `Writable` around an existing `Writable`.
+ * The config object takes custom `get` and `set` methods.
+ * All reads of this proxy goes through the `get` method
+ * and all writes go through `set`.
+ */
+export declare function proxy<Source extends Writable<any>, Value>(source: Source, config: ProxyConfig<Source, Value>): Writable<Value>;
+/**
+ * Creates a proxy `Writable` around an existing `Readable`.
+ * The config object takes custom `get` and `set` methods.
+ * All reads of this proxy goes through the `get` method
+ * and all writes go through `set`.
+ */
+export declare function proxy<Source extends Readable<any>, Value>(source: Source, config: ProxyConfig<Source, Value>): Writable<Value>;
+export declare function unwrap<T>(value: Readable<T> | T): T;
+export {};

package/lib/store.d.ts

@@ -0,0 +1,67 @@
+import { type AppContext, type ElementContext } from "./app.js";
+import { type DebugChannel } from "./classes/DebugHub.js";
+import { Readable, type ReadableValues } from "./state.js";
+import type { BuiltInStores } from "./types.js";
+export type Store<O, E> = (context: StoreContext<O>) => E | Promise<E>;
+export interface StoreContext<Options = any> extends DebugChannel {
+    /**
+     * Returns the shared instance of `store`.
+     */
+    getStore<T extends Store<any, any>>(store: T): ReturnType<T>;
+    /**
+     * Returns the shared instance of a built-in store.
+     */
+    getStore<N extends keyof BuiltInStores>(name: N): BuiltInStores[N];
+    /**
+     * Runs `callback` after this store is connected.
+     */
+    onConnected(callback: () => any): void;
+    /**
+     * Runs `callback` after this store is disconnected.
+     */
+    onDisconnected(callback: () => any): void;
+    /**
+     * The name of this store for logging and debugging purposes.
+     */
+    name: string;
+    /**
+     * Takes an Error object, unmounts the app and displays its crash page.
+     */
+    crash(error: Error): void;
+    /**
+     * Observes a readable value while this store is connected. Calls `callback` each time the value changes.
+     */
+    observe<T>(readable: Readable<T>, callback: (currentValue: T, previousValue: T) => void): void;
+    /**
+     * Observes a set of readable values while this store is connected.
+     * Calls `callback` with each value in the same order as `readables` each time any of their values change.
+     */
+    observe<T extends Readable<any>[], V>(readables: [...T], callback: (currentValues: ReadableValues<T>, previousValues: ReadableValues<T>) => void): void;
+    /**
+     * Options this store was initialized with.
+     */
+    options: Options;
+}
+export interface StoreContextSecrets {
+    appContext: AppContext;
+    elementContext: ElementContext;
+}
+export declare function getStoreSecrets(c: StoreContext): StoreContextSecrets;
+export declare function store<O>(callback: Store<any, O>): Store<any, O>;
+/**
+ * Parameters passed to the makeStore function.
+ */
+interface StoreConfig<O> {
+    store: Store<O, any>;
+    appContext: AppContext;
+    elementContext: ElementContext;
+    options: O;
+}
+export declare function initStore<O>(config: StoreConfig<O>): {
+    readonly name: string;
+    readonly exports: any;
+    setup(): void;
+    connect(): void;
+    disconnect(): void;
+};
+export {};

package/lib/stores/dialog.d.ts

@@ -0,0 +1,30 @@
+import { type DOMHandle } from "../markup.js";
+import { type Writable } from "../state.js";
+import { type StoreContext } from "../store.js";
+import { type View } from "../view.js";
+export interface DialogProps {
+    /**
+     * Whether the dialog is currently open.
+     */
+    $$open: Writable<boolean>;
+    /**
+     * Calls `callback` immediately after dialog has been connected.
+     */
+    transitionIn: (callback: () => Promise<void>) => void;
+    /**
+     * Calls `callback` and awaits its Promise before disconnecting the dialog.
+     */
+    transitionOut: (callback: () => Promise<void>) => void;
+}
+export interface OpenDialog {
+    instance: DOMHandle;
+    transitionInCallback?: () => Promise<void>;
+    transitionOutCallback?: () => Promise<void>;
+}
+/**
+ * Manages dialogs. Also known as modals.
+ * TODO: Describe this better.
+ */
+export declare function DialogStore(ctx: StoreContext): {
+    open: <P extends DialogProps>(view: View<P>, props?: Omit<P, keyof DialogProps> | undefined) => () => void;
+};

package/lib/stores/document.d.ts

@@ -0,0 +1,10 @@
+import { type StoreContext } from "../store.js";
+type ScreenOrientation = "landscape" | "portrait";
+type ColorScheme = "light" | "dark";
+export declare function DocumentStore(ctx: StoreContext): {
+    $$title: import("../state.js").Writable<string>;
+    $visibility: import("../state.js").Readable<DocumentVisibilityState>;
+    $orientation: import("../state.js").Readable<ScreenOrientation>;
+    $colorScheme: import("../state.js").Readable<ColorScheme>;
+};
+export {};

package/lib/stores/http.d.ts

@@ -0,0 +1,60 @@
+import { type StoreContext } from "../store.js";
+interface HTTPStoreOptions {
+    /**
+     * The fetch function to use for requests. Pass this to mock for testing.
+     */
+    fetch?: typeof window.fetch;
+}
+/**
+ * A simple HTTP client with middleware support. Middleware applies to all requests made through this store,
+ * so it's the perfect way to handle things like auth headers and permission checks for API calls.
+ */
+export declare function HTTPStore(ctx: StoreContext<HTTPStoreOptions>): {
+    /**
+     * Adds a new middleware that will apply to subsequent requests.
+     * Returns a function to remove this middleware.
+     *
+     * @param middleware - A middleware function that will intercept requests.
+     */
+    middleware(fn: HTTPMiddleware): () => void;
+    get<ResBody = unknown>(uri: string, options?: RequestOptions<never>): Promise<HTTPResponse<ResBody>>;
+    put<ResBody_1 = unknown, ReqBody = unknown>(uri: string, options?: RequestOptions<ReqBody> | undefined): Promise<HTTPResponse<ResBody_1>>;
+    patch<ResBody_2 = unknown, ReqBody_1 = unknown>(uri: string, options?: RequestOptions<ReqBody_1> | undefined): Promise<HTTPResponse<ResBody_2>>;
+    post<ResBody_3 = unknown, ReqBody_2 = unknown>(uri: string, options?: RequestOptions<ReqBody_2> | undefined): Promise<HTTPResponse<ResBody_3>>;
+    delete<ResBody_4 = unknown>(uri: string, options?: RequestOptions<never>): Promise<HTTPResponse<ResBody_4>>;
+    head<ResBody_5 = unknown, ReqBody_3 = unknown>(uri: string, options?: RequestOptions<ReqBody_3> | undefined): Promise<HTTPResponse<ResBody_5>>;
+    options<ResBody_6 = unknown, ReqBody_4 = unknown>(uri: string, options?: RequestOptions<ReqBody_4> | undefined): Promise<HTTPResponse<ResBody_6>>;
+    trace<ResBody_7 = unknown, ReqBody_5 = unknown>(uri: string, options?: RequestOptions<ReqBody_5> | undefined): Promise<HTTPResponse<ResBody_7>>;
+};
+export type HTTPMiddleware = (request: HTTPRequest<unknown>, next: () => Promise<HTTPResponse<unknown>>) => void | Promise<void>;
+interface RequestOptions<ReqBody> {
+    /**
+     * Body to send with the request.
+     */
+    body?: ReqBody;
+    /**
+     * Headers to send with the request.
+     */
+    headers?: Record<string, string | number | boolean> | Headers;
+    /**
+     * Query params to interpolate into the URL.
+     */
+    query?: Record<string, string | number | boolean> | URLSearchParams;
+}
+interface HTTPRequest<Body> {
+    method: string;
+    uri: string;
+    readonly sameOrigin: boolean;
+    headers: Headers;
+    query: URLSearchParams;
+    body: Body;
+}
+interface HTTPResponse<Body> {
+    method: string;
+    uri: string;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: Body;
+}
+export {};