@manyducks.co/dolla 2.0.0-alpha.5 → 2.0.0-alpha.51

package/dist/core/context.d.ts

@@ -0,0 +1,65 @@
+import type { Dolla } from "./dolla";
+import type { View } from "./nodes/view";
+import type { Source } from "./signals-api";
+import type { Store, StoreFunction } from "./store";
+export interface ElementContext {
+    /**
+     * The root Dolla instance this element belongs to.
+     */
+    root: Dolla;
+    /**
+     * Stores attached to this context.
+     */
+    stores: Map<StoreFunction<any, any>, Store<any, any>>;
+    /**
+     * The nearest view.
+     */
+    view?: View<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.
+     */
+    /**
+     * The context of the nearest parent view.
+     */
+    /**
+     * Current route layer of the nearest view.
+     */
+    route?: Source<View<{}> | undefined>;
+}
+export interface ComponentContext {
+    /**
+     * A name for debugging purposes. Prepended to log messages.
+     */
+    name: string;
+}
+/**
+ * A context capable of providing stores.
+ */
+export interface StoreProviderContext {
+    /**
+     * Attaches a new store to this context and returns it.
+     */
+    provide<Value>(store: StoreFunction<{}, Value>): Value;
+    /**
+     * Attaches a new store to this context and returns it.
+     */
+    provide<Value>(store: StoreFunction<undefined, Value>): Value;
+    /**
+     * Attaches a new store to this context and returns it.
+     */
+    provide<Options, Value>(store: StoreFunction<Options, Value>, options: Options): Value;
+}
+export interface StoreConsumerContext {
+    /**
+     * Gets the closest instance of a store. Throws an error if the store isn't provided higher in the tree.
+     */
+    get<Value>(store: StoreFunction<any, Value>): Value;
+}

package/dist/{modules → core}/dolla.d.ts

@@ -1,11 +1,11 @@
-import { createRef, isRef, MarkupNode, type Markup } from "../markup.js";
-import { createSettableSignal, createSignal, derive, designalify, signalify, toSettableSignal, watch, type Signal } from "../signals.js";
-import { type ViewFunction, type ViewNode } from "../view.js";
-import { type CrashViewProps } from "../views/default-crash-view.js";
-import { HTTP } from "./http.js";
-import { Language } from "./language.js";
-import { Render } from "./render.js";
-import { Router } from "./router.js";
+import { HTTP } from "../http/index.js";
+import { type Router } from "../router/index.js";
+import { I18n } from "../translate/index.js";
+import type { StoreConsumerContext, StoreProviderContext } from "./context.js";
+import { type Markup, type MarkupElement } from "./markup.js";
+import { type ViewElement, type ViewFunction } from "./nodes/view.js";
+import { StoreFunction } from "./store.js";
+import { type CrashViewProps } from "./views/default-crash-view.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.
@@ -22,6 +22,7 @@ export interface Logger {
     warn(...args: any[]): void;
     error(...args: any[]): void;
     crash(error: Error): void;
+    setName(name: string): Logger;
 }
 export interface LoggerErrorContext {
     error: Error;
@@ -38,22 +39,11 @@ export type LoggerOptions = {
      */
     uid?: string;
 };
-export declare class Dolla {
+export declare class Dolla implements StoreProviderContext, StoreConsumerContext {
     #private;
     readonly http: HTTP;
-    readonly language: Language;
-    readonly render: Render;
-    readonly router: Router;
+    readonly i18n: I18n;
     constructor();
-    createSignal: typeof createSignal;
-    createSettableSignal: typeof createSettableSignal;
-    toSettableSignal: typeof toSettableSignal;
-    signalify: typeof signalify;
-    designalify: typeof designalify;
-    derive: typeof derive;
-    watch: typeof watch;
-    createRef: typeof createRef;
-    isRef: typeof isRef;
     /**
      * True when the app is connected to a DOM node and displayed to the user.
      */
@@ -73,8 +63,34 @@ export declare class Dolla {
      * When a crash is reported the app will be unmounted and replaced with this crash page.
      */
     setCrashView(view: ViewFunction<CrashViewProps>): void;
-    mount(selector: string, view?: ViewFunction<any>): Promise<void>;
-    mount(element: HTMLElement, view?: ViewFunction<any>): Promise<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;
+    /**
+     * Attaches a new store to this context.
+     */
+    provide<Value>(store: StoreFunction<{}, Value>): Value;
+    /**
+     * Attaches a new store to this context.
+     */
+    provide<Value>(store: StoreFunction<undefined, Value>): Value;
+    /**
+     * Attaches a new store to this context.
+     */
+    provide<Options, Value>(store: StoreFunction<Options, Value>, options: Options): Value;
+    /**
+     * Gets the nearest instance of a store. Throws an error if the store isn't provided higher in the tree.
+     */
+    get<Value>(store: StoreFunction<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,
@@ -99,13 +115,14 @@ export declare class Dolla {
      */
     setLoggles(options: Partial<Loggles>): void;
     setLogFilter(filter: string | RegExp): void;
-    createLogger(name: string | Signal<string>, options?: LoggerOptions): Logger;
+    createLogger(name: string, options?: LoggerOptions): Logger;
     /**
      *
      */
-    constructView<P>(view: ViewFunction<P>, props: P, children?: Markup[]): ViewNode;
+    constructView<P>(view: ViewFunction<P>, props: P, children?: Markup[]): ViewElement;
     /**
      *
      */
-    constructMarkup(markup: Markup | Markup[]): MarkupNode;
+    constructMarkup(markup: Markup | Markup[]): MarkupElement;
 }
+export declare function getDefaultConsole(): Console | undefined;

package/dist/core/markup.d.ts

@@ -0,0 +1,102 @@
+import type { Renderable } from "../types.js";
+import type { ElementContext } from "./context.js";
+import { View, type ViewContext, type ViewFunction, type ViewResult } from "./nodes/view.js";
+import { type MaybeSignal, type Signal } from "./signals-api.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?: any[];
+}
+/**
+ * A DOM node that has been constructed from a Markup object.
+ */
+export interface MarkupElement {
+    readonly domNode?: 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 declare enum MarkupType {
+    Text = "$text",
+    Repeat = "$repeat",
+    Dynamic = "$dynamic",
+    Outlet = "$outlet",
+    Fragment = "$fragment",
+    Node = "$node",
+    Portal = "$portal"
+}
+export interface MarkupAttributes {
+    [MarkupType.Text]: {
+        value: any;
+    };
+    [MarkupType.Repeat]: {
+        items: Signal<any[]>;
+        keyFn: (value: any, index: number) => string | number | symbol;
+        renderFn: (item: Signal<any>, index: Signal<number>, ctx: ViewContext) => ViewResult;
+    };
+    [MarkupType.Dynamic]: {
+        source: Signal<Renderable>;
+    };
+    [MarkupType.Outlet]: {
+        view: Signal<View<{}> | undefined>;
+    };
+    [MarkupType.Fragment]: {
+        children: MaybeSignal<MarkupElement[]>;
+    };
+    [MarkupType.Node]: {
+        value: Node;
+    };
+    [MarkupType.Portal]: {
+        content: Renderable;
+        parent: Node;
+    };
+    [tag: string]: Record<string, any>;
+}
+export declare function markup<T extends keyof MarkupAttributes>(type: T, attributes: MarkupAttributes[T], ...children: Renderable[]): Markup;
+export declare function markup<I>(type: ViewFunction<I>, attributes?: I, ...children: any[]): Markup;
+/**
+ * Displays `thenContent` when `condition` is truthy and `elseContent` when falsy.
+ */
+export declare function when(condition: MaybeSignal<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
+/**
+ * Inverted `when`. Displays `thenContent` when `condition` is falsy and `elseContent` when truthy.
+ */
+export declare function unless(condition: MaybeSignal<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: MaybeSignal<T[]>, keyFn: (value: T, index: number) => string | number | symbol, renderFn: (item: Signal<T>, index: Signal<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;
+    domNode: Node;
+    get isMounted(): boolean;
+    constructor(node: Node);
+    mount(parent: Node, after?: Node): void;
+    unmount(parentIsUnmounting?: boolean): void;
+}

package/dist/core/nodes/dynamic.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 { Signal } from "../signals-api.js";
+import { IS_MARKUP_ELEMENT } from "../symbols.js";
+interface DynamicOptions {
+    source: Signal<Renderable>;
+    elementContext: ElementContext;
+}
+/**
+ * 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.
+ */
+export declare class Dynamic implements MarkupElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    domNode: Text;
+    private children;
+    private elementContext;
+    private source;
+    private unsubscribe?;
+    get isMounted(): boolean;
+    constructor(options: DynamicOptions);
+    mount(parent: Node, after?: Node): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    cleanup(parentIsUnmounting: boolean): void;
+    update(children: Renderable[]): void;
+}
+export {};

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

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

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

@@ -0,0 +1,34 @@
+import { type ElementContext } from "../context.js";
+import { type MarkupElement } from "../markup.js";
+import { IS_MARKUP_ELEMENT } from "../symbols.js";
+type HTMLOptions = {
+    elementContext: ElementContext;
+    tag: string;
+    props: Record<string, any>;
+    children?: any[];
+};
+export declare class HTML implements MarkupElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    domNode: HTMLElement | SVGElement;
+    private props;
+    private childMarkup;
+    private children;
+    private unsubscribers;
+    private elementContext;
+    private logger;
+    private ref?;
+    private canClickAway;
+    get isMounted(): boolean;
+    constructor({ tag, props, children, elementContext }: HTMLOptions);
+    mount(parent: Node, after?: Node): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    private attachProp;
+    private applyProps;
+    private applyStyles;
+    private applyClasses;
+}
+/**
+ * Converts a camelCase string to kebab-case.
+ */
+export declare function camelToKebab(value: string): string;
+export {};

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

@@ -0,0 +1,20 @@
+import { type MarkupElement } from "../markup.js";
+import { type Signal } from "../signals-api.js";
+import { IS_MARKUP_ELEMENT } from "../symbols.js";
+import { View } from "./view.js";
+/**
+ * Renders the subroute of the nearest view.
+ */
+export declare class Outlet implements MarkupElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    domNode: Text;
+    isMounted: boolean;
+    private view;
+    private mountedView?;
+    private unsubscribe?;
+    constructor(view: Signal<View<{}> | undefined>);
+    mount(parent: Node, after?: Node | undefined): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    private cleanup;
+    private update;
+}

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;
+    private config;
+    private element?;
+    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,28 @@
+import { type ElementContext } from "../context.js";
+import { type MarkupElement } from "../markup.js";
+import { type Signal } from "../signals-api.js";
+import { IS_MARKUP_ELEMENT } from "../symbols.js";
+import { type ViewContext, type ViewResult } from "./view.js";
+interface RepeatOptions<T> {
+    elementContext: ElementContext;
+    items: Signal<T[]>;
+    keyFn: (item: T, index: number) => string | number | symbol;
+    renderFn: (item: Signal<T>, index: Signal<number>, ctx: ViewContext) => ViewResult;
+}
+export declare class Repeat<T> implements MarkupElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    domNode: Text;
+    private items;
+    private unsubscribe;
+    private connectedItems;
+    private elementContext;
+    private renderFn;
+    private keyFn;
+    get isMounted(): boolean;
+    constructor({ elementContext, items, renderFn, keyFn }: RepeatOptions<T>);
+    mount(parent: Node, after?: Node): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    private _cleanup;
+    private _update;
+}
+export {};

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

@@ -0,0 +1,97 @@
+import type { ComponentContext, ElementContext, StoreConsumerContext, StoreProviderContext } from "../context.js";
+import type { Logger } from "../dolla.js";
+import { type Markup, type MarkupElement } from "../markup.js";
+import { type Signal, type EffectCallback, type UnsubscribeFunction } from "../signals-api.js";
+import { StoreFunction } from "../store.js";
+import { IS_MARKUP_ELEMENT } from "../symbols.js";
+/**
+ * Any valid value that a View can return.
+ */
+export type ViewResult = Node | Signal<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 {
+    setRouteView(view: ViewFunction<{}>): ViewElement;
+}
+export interface ViewContext extends Omit<Logger, "setName">, ComponentContext, StoreProviderContext, StoreConsumerContext {
+    /**
+     * An ID unique to this view.
+     */
+    readonly uid: string;
+    /**
+     * 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;
+    /**
+     * Passes a getter function to `callback` that will track reactive states and return their current values.
+     * Callback will be run each time a tracked state gets a new value.
+     */
+    effect(callback: EffectCallback): UnsubscribeFunction;
+    /**
+     * Displays this view's subroutes if mounted as a router view.
+     */
+    outlet(): Markup;
+}
+interface Context extends Omit<Logger, "setName"> {
+}
+declare class Context implements ViewContext {
+    private view;
+    constructor(view: View<any>);
+    get uid(): string;
+    get isMounted(): boolean;
+    get name(): string;
+    set name(value: string);
+    provide<Value>(store: StoreFunction<any, Value>, options?: any): Value;
+    get<Value>(store: StoreFunction<any, Value>): Value;
+    beforeMount(callback: () => void): void;
+    onMount(callback: () => void): void;
+    beforeUnmount(callback: () => void): void;
+    onUnmount(callback: () => void): void;
+    effect(callback: EffectCallback): UnsubscribeFunction;
+    outlet(): Markup;
+}
+export declare class View<P> implements ViewElement {
+    [IS_MARKUP_ELEMENT]: boolean;
+    uniqueId: string;
+    elementContext: ElementContext;
+    logger: Logger;
+    props: P & {
+        children: Markup[] | undefined;
+    };
+    fn: ViewFunction<P>;
+    element?: MarkupElement;
+    name: string;
+    context: Context;
+    lifecycleListeners: {
+        beforeMount: (() => any)[];
+        mount: (() => any)[];
+        beforeUnmount: (() => any)[];
+        unmount: (() => any)[];
+    };
+    constructor(elementContext: ElementContext, fn: ViewFunction<P>, props: P, children?: Markup[]);
+    get domNode(): Node;
+    isMounted: boolean;
+    mount(parent: Node, after?: Node): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    setRouteView(fn: ViewFunction<{}>): View<{}>;
+    private _initialize;
+}
+export {};

package/dist/core/signals-api.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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.
+ */
+export interface Signal<T> {
+    (): T;
+}
+/**
+ * Extends Signal with the ability to pass a value or an updater function to change the Signal's value.
+ */
+export interface Source<T> extends Signal<T> {
+    (value: T): void;
+    (updater: (value: T) => T): void;
+}
+export type MaybeSignal<T> = Signal<T> | T;
+export type EqualityFunction<T> = (current: T, next: T) => boolean;
+export interface SignalOptions<T> {
+    /**
+     * A function to compare the current and next values. Returning `true` means the value has changed.
+     */
+    equals?: EqualityFunction<T>;
+}
+export declare function isSource<T>(value: MaybeSignal<T>): value is Source<T>;
+export declare function peek<T>(value: MaybeSignal<T>): T;
+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.
+ */
+export type EffectCallback = () => void | (() => void);
+export type UnsubscribeFunction = () => void;
+/**
+ * Creates a tracked scope that re-runs whenever the values of any tracked reactives changes.
+ * Reactives are tracked by accessing their `value` within the body of the function.
+ *
+ * NOTE: You must call the unsubscribe function to stop watching for changes.
+ * 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: EffectCallback): UnsubscribeFunction;
+export declare function $<T>(compute: () => 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>;

package/dist/core/signals.d.ts

@@ -0,0 +1,22 @@
+import { type Dependency, type Subscriber, SubscriberFlags } from "alien-signals";
+import type { EqualityFunction } from "./signals-api";
+export interface Effect extends Subscriber, Dependency {
+    /**
+     * Effect function. Can return an optional cleanup callback to be invoked before the next fn() call.
+     */
+    fn(): (() => void) | void;
+    cleanup?: () => void;
+}
+export interface Computed<T = any> extends Value<T | undefined>, Subscriber {
+    getter: (cachedValue?: T) => T;
+    equals: EqualityFunction<T>;
+}
+export interface Value<T = any> extends Dependency {
+    current: T;
+}
+export declare const link: (dep: Dependency, sub: Subscriber) => import("alien-signals").Link | undefined, propagate: (link: import("alien-signals").Link) => void, updateDirtyFlag: (sub: Subscriber, flags: SubscriberFlags) => boolean, startTracking: (sub: Subscriber) => void, endTracking: (sub: Subscriber) => void, processEffectNotifications: () => void, processComputedUpdate: (computed: Dependency & Subscriber, flags: SubscriberFlags) => void, processPendingInnerEffects: (sub: Subscriber, flags: SubscriberFlags) => void;
+export declare let activeSub: Subscriber | undefined;
+export declare function queueEffect(e: Effect): void;
+export declare function stopEffect(this: Effect): void;
+export declare function pauseTracking(): void;
+export declare function resumeTracking(): void;

package/dist/core/store.d.ts

@@ -0,0 +1,52 @@
+import type { ComponentContext, ElementContext, StoreConsumerContext } from "./context.js";
+import type { Logger } from "./dolla.js";
+import { type EffectCallback, type UnsubscribeFunction } from "./signals-api.js";
+export type StoreFunction<Options, Value> = (this: StoreContext, options: Options, context: StoreContext) => Value;
+export type StoreFactory<Options, Value> = Options extends undefined ? () => Store<Options, Value> : (options: Options) => Store<Options, Value>;
+export interface StoreContext extends Omit<Logger, "setName">, ComponentContext, StoreConsumerContext {
+    /**
+     * True while this store is attached to a context that is currently mounted in the view tree.
+     */
+    readonly isMounted: boolean;
+    /**
+     * Registers a callback to run just after this store is mounted.
+     */
+    onMount(callback: () => void): void;
+    /**
+     * Registers a callback to run just after this store is unmounted.
+     */
+    onUnmount(callback: () => void): void;
+    /**
+     * Passes a getter function to `callback` that will track reactive states and return their current values.
+     * Callback will be run each time a tracked state gets a new value.
+     */
+    effect(callback: EffectCallback): UnsubscribeFunction;
+}
+export declare class Store<Options, Value> {
+    readonly fn: StoreFunction<Options, Value>;
+    private _options;
+    /**
+     * Value is guaranteed to be set after `attach` is called.
+     */
+    value: Value;
+    isMounted: boolean;
+    elementContext: ElementContext;
+    lifecycleListeners: {
+        mount: (() => any)[];
+        unmount: (() => any)[];
+    };
+    logger: Logger;
+    id: string;
+    name: string;
+    constructor(fn: StoreFunction<Options, Value>, options: Options);
+    /**
+     * Attaches this Store to the elementContext.
+     * Returns false if there was already an instance attached, and true otherwise.
+     */
+    attach(elementContext: ElementContext): boolean;
+    handleMount(): void;
+    handleUnmount(): void;
+}
+export declare function isStore<Options, Value>(value: any): value is Store<Options, Value>;
+export declare class StoreError extends Error {
+}

package/dist/core/symbols.d.ts

@@ -0,0 +1,4 @@
+export declare const IS_MARKUP: unique symbol;
+export declare const IS_MARKUP_ELEMENT: unique symbol;
+export declare const IS_STORE: unique symbol;
+export declare const IS_ROUTER: unique symbol;