@manyducks.co/dolla 2.0.0-alpha.57 → 2.0.0-alpha.59

package/dist/core/app.d.ts

@@ -0,0 +1,17 @@
+import { Router } from "../router/router";
+import { Env, View } from "../types";
+import { Context } from "./context";
+import { MaybeSignal } from "./signals";
+import { CrashViewProps } from "./views/default-crash-view";
+export declare class App extends Context {
+    #private;
+    constructor(name: MaybeSignal<string>, view: View<{}> | Router);
+    setCrashView(view: View<CrashViewProps>): this;
+    setLogLevels(): this;
+    setLogFilter(): this;
+    setEnv(value: Env): this;
+    getEnv(): Env;
+    mount(parent: Element): Promise<void>;
+    mount(selector: string): Promise<void>;
+    unmount(): Promise<void>;
+}

package/dist/core/context.d.ts

@@ -1,36 +1,56 @@
 import type { Store } from "../types";
 import { type Logger, type LoggerOptions } from "./logger";
 import { type EffectFn, type MaybeSignal, type UnsubscribeFn } from "./signals";
-type StoreMap = Map<Store<any, any>, any>;
 export declare enum LifecycleEvent {
     WILL_MOUNT = 0,
     DID_MOUNT = 1,
     WILL_UNMOUNT = 2,
-    DID_UNMOUNT = 3
+    DID_UNMOUNT = 3,
+    DISPOSE = 4
 }
 type LifecycleListener = () => void;
 declare enum LifecycleState {
     Unmounted = 0,
     WillMount = 1,
-    WillMountByDependent = 2,
-    DidMount = 3,
-    DidMountByDependent = 4,
-    WillUnmount = 5,
-    WillUnmountByDependent = 6,
-    DidUnmount = 7
+    DidMount = 2,
+    WillUnmount = 3,
+    DidUnmount = 4,
+    Disposed = 5
 }
+declare const NAME: unique symbol;
+declare const LIFECYCLE: unique symbol;
+declare const PARENT: unique symbol;
+declare const STORES: unique symbol;
+declare const STATE: unique symbol;
 /**
  * Manages lifecycle events for a Context.
  */
 declare class ContextLifecycle {
-    #private;
+    private context;
     state: LifecycleState;
-    dependents: number;
+    listeners: Map<LifecycleEvent, Set<LifecycleListener>>;
+    bound?: Set<Context>;
+    constructor(context: Context);
+    /**
+     * Listen for a certain event to be emitted. Listeners are called when the event results in a state change.
+     */
     on<E extends LifecycleEvent>(event: E, listener: LifecycleListener): void;
+    /**
+     * Stop a particular listener from being called when an event is emitted.
+     */
     off<E extends LifecycleEvent>(event: E, listener: LifecycleListener): void;
-    notify<E extends LifecycleEvent>(event: E): void;
-    emit<E extends LifecycleEvent>(event: E, dependent?: boolean): void;
-    dispose(): void;
+    /**
+     * Advance the lifecycle state machine.
+     */
+    emit<E extends LifecycleEvent>(event: E): void;
+    /**
+     * Bind `context` to this lifecycle; when any event is emitted here it will be emitted for `context` as well.
+     */
+    bind(context: Context): void;
+    /**
+     * Call all the event's listeners and re-emit to bound contexts.
+     */
+    private notify;
 }
 export interface ContextOptions {
     logger?: LoggerOptions;
@@ -42,17 +62,41 @@ export interface Context extends Logger {
 }
 export declare class Context implements Logger {
     #private;
-    _name: string;
-    _lifecycle: ContextLifecycle;
-    _parent?: Context;
-    _stores?: StoreMap;
-    _state?: Map<any, any>;
+    [NAME]: string;
+    [LIFECYCLE]: ContextLifecycle;
+    [PARENT]?: Context;
+    [STORES]?: Map<Store<any, any>, any>;
+    [STATE]?: Map<any, any>;
     get isMounted(): boolean;
     /**
      * Returns a new Context with this one as its parent.
      */
     static linked(parent: Context, name: MaybeSignal<string>, options?: LinkedContextOptions): Context;
-    static emit(event: LifecycleEvent, context: Context): void;
+    /**
+     * Emit "will mount" lifecycle event to `context`.
+     */
+    static willMount(context: Context): void;
+    /**
+     * Emit "did mount" lifecycle event to `context`.
+     */
+    static didMount(context: Context): void;
+    /**
+     * Emit "will unmount" lifecycle event to `context`.
+     */
+    static willUnmount(context: Context): void;
+    /**
+     * Emit "did unmount" lifecycle event to `context`.
+     */
+    static didUnmount(context: Context): void;
+    /**
+     * Emit "dispose" lifecycle event to `context`.
+     */
+    static dispose(context: Context): void;
+    /**
+     * Traverses _parent contexts until arriving at one that doesn't have a parent itself.
+     * Returns null if this context is the parent.
+     */
+    static getRoot(context: Context): Context | null;
     constructor(name: MaybeSignal<string>, options?: ContextOptions);
     /**
      * Returns the current name of this context.
@@ -62,7 +106,15 @@ export declare class Context implements Logger {
      * Sets a new name for this context.
      */
     setName(name: MaybeSignal<string>): void;
+    /**
+     * Creates an instance of a store and attaches it to this context.
+     */
     addStore<T>(store: Store<any, T>, options?: any): this;
+    /**
+     * Retrieves the nearest instance of `store`. If this context doesn't have it, the parent context is checked. This process continues until either:
+     * 1. An instance of the store is found and returned.
+     * 2. No instance is found and an error is thrown.
+     */
     getStore<T>(store: Store<any, T>): T;
     /**
      * Schedule a callback function to run just before this context is mounted.

package/dist/core/index.d.ts

@@ -1,4 +1,4 @@
-export { $, effect, get, peek } from "./signals.js";
+export { $, effect, get, untracked, batch } from "./signals.js";
 export type { MaybeSignal, Signal, Source } from "./signals.js";
 export { createContext } from "./context.js";
 export type { Context } from "./context.js";
@@ -10,8 +10,8 @@ export { mount, type UnmountFn } from "./mount.js";
 export { deepEqual, shallowEqual, strictEqual } from "../utils.js";
 export { getEnv, setEnv } from "./env.js";
 export { createLogger, setLogFilter, setLogLevels } from "./logger.js";
-export type { Logger, LoggerErrorContext, LoggerOptions, LogLevels } from "./logger.js";
-export type { View, Store, InputType, Renderable, Env } from "../types.js";
+export type { Logger, LoggerErrorProps as LoggerErrorContext, LoggerOptions, LogLevels } from "./logger.js";
+export type { View, Store, InputType, Renderable, Env, CSSProperties } 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/logger.d.ts

@@ -27,13 +27,13 @@ export interface LoggerOptions {
      */
     console?: any;
 }
-export interface LoggerErrorContext {
+export interface LoggerErrorProps {
     error: Error;
     loggerName: string;
     tag?: string;
     tagName?: string;
 }
-export declare function onLoggerCrash(listener: (context: LoggerErrorContext) => void): () => void;
+export declare function onLoggerCrash(listener: (context: LoggerErrorProps) => void): () => void;
 export declare function createLogger(name: MaybeSignal<string>, options?: LoggerOptions): Logger;
 export declare function setLogFilter(filter: string | RegExp): void;
 export declare function setLogLevels(options: Partial<LogLevels>): void;

package/dist/core/markup.d.ts

@@ -5,7 +5,7 @@ import { type MaybeSignal, type Signal } from "./signals.js";
 /**
  * Markup is a set of element metadata that hasn't been constructed into a MarkupElement yet.
  */
-export declare class Markup<P extends Record<any, any> = Record<any, any>> {
+export declare class Markup<P = any> {
     /**
      * 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 ""
@@ -13,13 +13,10 @@ export declare class Markup<P extends Record<any, any> = Record<any, any>> {
     type: string | View<P>;
     /**
      * Data that will be passed to a new MarkupNode instance when it is constructed.
+     * Includes a `children` prop if children were passed.
      */
     props: P | undefined;
-    /**
-     *
-     */
-    children: Renderable[];
-    constructor(type: string | View<P>, props?: P, ...children: Renderable[]);
+    constructor(type: string | View<P>, props?: P);
 }
 /**
  * A mountable node that has been constructed from Markup metadata.
@@ -32,15 +29,19 @@ export interface MarkupNode {
     /**
      *
      */
-    readonly isMounted: boolean;
+    isMounted(): boolean;
     /**
      *
      */
-    mount(parent: Node, after?: Node): void;
+    mount(parent: Element, after?: Node): void;
     /**
      *
      */
     unmount(parentIsUnmounting?: 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 {
@@ -67,13 +68,13 @@ export interface MarkupProps {
     };
     [MarkupType.Portal]: {
         content: Renderable;
-        parent: Node;
+        parent: Element;
     };
     [tag: string]: Record<string, any>;
 }
-export declare function m<T extends keyof MarkupProps>(type: T, props: MarkupProps[T], ...children: Renderable[]): Markup;
-export declare function m<P extends {}>(type: View<P>, props?: P, ...children: Renderable[]): Markup;
-export declare function m<P>(type: View<P>, props: P, ...children: any[]): Markup;
+export declare function m<T extends keyof MarkupProps>(type: T, props: MarkupProps[T]): Markup;
+export declare function m<P extends {}>(type: View<P>, props?: P): Markup;
+export declare function m<P>(type: View<P>, props: P): Markup;
 /**
  * If `condition` is truthy, displays `thenContent`, otherwise `elseContent`.
  */
@@ -90,7 +91,7 @@ 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: Node, content: Renderable): Markup;
+export declare function portal(parent: Element, content: Renderable): Markup;
 export declare function render(content: Renderable, context?: Context): MarkupNode;
 /**
  * Convert basically anything into a set of MarkupElements.

package/dist/core/mount.d.ts

@@ -1,10 +1,10 @@
 import { Router } from "../router/router";
 import type { View } from "../types";
 import { Context } from "./context";
-import { type LoggerErrorContext } from "./logger";
+import { type LoggerErrorProps } from "./logger";
 export type UnmountFn = () => Promise<void>;
 export interface MountOptions {
-    crashView?: View<LoggerErrorContext>;
+    crashView?: View<LoggerErrorProps>;
     /**
      * An existing Context to use as the root, otherwise a new one will be created.
      * Use this to provide top-level stores and state to the whole app.

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

@@ -6,8 +6,9 @@ import { IS_MARKUP_NODE } from "../symbols";
 export declare class DOMNode implements MarkupNode {
     [IS_MARKUP_NODE]: boolean;
     root: Node;
-    get isMounted(): boolean;
     constructor(node: Node);
-    mount(parent: Node, after?: Node): void;
+    isMounted(): boolean;
+    mount(parent: Element, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
+    move(parent: Element, after?: Node): void;
 }

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

@@ -15,10 +15,11 @@ export declare class Dynamic implements MarkupNode {
     private context;
     private $slot;
     private unsubscribe?;
-    get isMounted(): boolean;
     constructor(context: Context, $slot: Signal<any>);
+    isMounted(): boolean;
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
+    move(parent: Element, after?: Node): void;
     private cleanup;
     private update;
     /**

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

@@ -4,18 +4,20 @@ import { IS_MARKUP_NODE } from "../symbols.js";
 export type Mixin<E extends Element = Element> = (element: E, context: Context) => void;
 export declare class HTML implements MarkupNode {
     [IS_MARKUP_NODE]: boolean;
-    root: HTMLElement | SVGElement;
+    root?: HTMLElement | SVGElement;
+    private parentContext;
     private context;
-    private props;
-    private children?;
+    tag: string;
+    props: Record<string, any>;
     private childNodes;
     private unsubscribers;
     private ref?;
     private canClickAway;
-    get isMounted(): boolean;
-    constructor(context: Context, tag: string, props: Record<string, any>, children?: any[]);
+    constructor(context: Context, tag: string, props: Record<string, any>);
+    isMounted(): boolean;
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
+    move(parent: Element, after?: Node): void;
     private attachProp;
     private applyProps;
     private applyStyles;

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

@@ -11,8 +11,9 @@ export declare class Portal implements MarkupNode {
     private content;
     private parent;
     private element?;
-    get isMounted(): boolean;
-    constructor(context: Context, content: Renderable, parent: Node);
-    mount(_parent: Node, _after?: Node): void;
+    constructor(context: Context, content: Renderable, parent: Element);
+    isMounted(): boolean;
+    mount(_parent: Element, _after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
+    move(_parent: Element, _after?: Node): void;
 }

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

@@ -3,7 +3,8 @@ import type { Context } from "../context.js";
 import type { MarkupNode } from "../markup.js";
 import { type Signal } from "../signals.js";
 import { IS_MARKUP_NODE } from "../symbols.js";
-export type KeyFn<T> = (item: T, index: number) => string | number | symbol;
+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 {
     [IS_MARKUP_NODE]: boolean;
@@ -14,10 +15,11 @@ export declare class Repeat<T> implements MarkupNode {
     private render;
     private unsubscribe;
     private connectedItems;
-    get isMounted(): boolean;
     constructor(context: Context, items: Signal<T[]>, key: KeyFn<T>, render: RenderFn<T>);
-    mount(parent: Node, after?: Node): void;
+    isMounted(): boolean;
+    mount(parent: Element, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
+    move(parent: Element, after?: Node): void;
     private _cleanup;
     private _update;
 }

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

@@ -7,15 +7,13 @@ export declare class ViewInstance<P> implements MarkupNode {
     [IS_MARKUP_NODE]: boolean;
     uniqueId: string;
     context: Context;
-    props: P & {
-        children: any[] | undefined;
-    };
-    fn: View<P>;
+    props: P;
+    view: View<P>;
     node?: MarkupNode;
-    constructor(context: Context, fn: View<P>, props: P, children?: any[]);
     get root(): Node;
-    get isMounted(): boolean;
-    mount(parent: Node, after?: Node): void;
+    constructor(context: Context, view: View<P>, props: P);
+    isMounted(): boolean;
+    mount(parent: Element, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
-    private _initialize;
+    move(parent: Element, after?: Node): void;
 }

package/dist/core/signals.d.ts

@@ -1,24 +1,3 @@
-import { type Dependency, type Subscriber, SubscriberFlags } from "alien-signals";
-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: EqualityFn<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;
 /**
  * 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.
@@ -42,7 +21,8 @@ export interface SignalOptions<T> {
     equals?: EqualityFn<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 batch(fn: () => void): void;
+export declare function untracked<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.
@@ -57,7 +37,7 @@ 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: () => MaybeSignal<T>, options?: SignalOptions<T>): Signal<T>;
+export declare function $<T>(compute: (previousValue: 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>;

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

@@ -1,3 +1,4 @@
+import { Markup } from "../markup.js";
 /**
  * Props passed to the crash view when a crash occurs.
  */
@@ -19,4 +20,14 @@ export type CrashViewProps = {
      */
     tagName?: string;
 };
-export declare function DefaultCrashView(props: CrashViewProps): import("../markup.js").Markup<Record<any, any>>;
+export declare function DefaultCrashView(props: CrashViewProps): Markup<{
+    style: {
+        backgroundColor: string;
+        color: string;
+        padding: string;
+        position: string;
+        inset: number;
+        fontSize: string;
+    };
+    children: Markup<any>[];
+}>;

package/dist/i18n.js

@@ -5,7 +5,7 @@ var D = (o) => {
 var J = (o, t, e) => t in o ? B(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
 var O = (o, t, e) => J(o, typeof t != "symbol" ? t + "" : t, e), _ = (o, t, e) => t.has(o) || D("Cannot " + e);
 var i = (o, t, e) => (_(o, t, "read from private field"), e ? e.call(o) : t.get(o)), m = (o, t, e) => t.has(o) ? D("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(o) : t.set(o, e), N = (o, t, e, n) => (_(o, t, "write to private field"), n ? n.call(o, e) : t.set(o, e), e), g = (o, t, e) => (_(o, t, "access private method"), e);
-import { $, f as K, d as Q, g as x } from "./logger-sSxIw5od.js";
+import { $, h as K, d as Q, g as x } from "./logger-Ck_9LCem.js";
 import { b as C, i as j, c as U, t as P } from "./typeChecking-BJ-ymQ2F.js";
 var I, F, p, S, G;
 class W {