@manyducks.co/dolla 2.0.0-alpha.9 → 2.0.0

package/dist/core/app.d.ts

@@ -0,0 +1,24 @@
+import { Router, RouterOptions } from "../router/router";
+import { View } from "../types";
+import { Context } from "./context";
+import { LoggerCrashProps } from "./logger";
+interface AppOptions {
+    view?: View<{}>;
+    router?: Router;
+    context?: Context;
+}
+declare class App {
+    #private;
+    get context(): Context;
+    constructor(options: AppOptions);
+    setCrashView(view: View<LoggerCrashProps>): this;
+    mount(element: string | Element): Promise<void>;
+    unmount(): Promise<void>;
+}
+export interface CreateAppOptions {
+    context?: Context;
+}
+export declare function createApp(view: View<{}>, options?: CreateAppOptions): App;
+export declare function createApp(routerOptions: RouterOptions, options?: CreateAppOptions): App;
+export declare function createApp(router: Router, options?: CreateAppOptions): App;
+export {};

package/dist/core/context.d.ts

@@ -0,0 +1,147 @@
+import type { Store } from "../types";
+import { type Logger, type LoggerOptions } from "./logger";
+import { type EffectFn, type MaybeSignal, type UnsubscribeFn } from "./signals";
+export declare enum LifecycleEvent {
+    WILL_MOUNT = "willMount",
+    DID_MOUNT = "didMount",
+    WILL_UNMOUNT = "willUnmount",
+    DID_UNMOUNT = "didUnmount",
+    DISPOSE = "dispose"
+}
+export type LifecycleEventName = "willMount" | "didMount" | "willUnmount" | "didUnmount" | "dispose";
+type LifecycleListener = () => void;
+declare enum LifecycleState {
+    Unmounted = 0,
+    WillMount = 1,
+    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 context;
+    state: LifecycleState;
+    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;
+    /**
+     * 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 ContextGetStateOptions<T> {
+    fallback?: T;
+    /**
+     * Only check this context; skip parent contexts.
+     */
+    immediate?: boolean;
+}
+export interface ContextGetStateOptionsWithFallbackValue<T> extends ContextGetStateOptions<T> {
+    fallback: T;
+}
+export interface ContextGetStateMapOptions {
+    /**
+     * Only include state from this context; skip parent contexts.
+     */
+    immediate?: boolean;
+}
+export interface ContextOptions {
+    logger?: LoggerOptions;
+}
+export interface LinkedContextOptions extends ContextOptions {
+    bindLifecycleToParent?: boolean;
+}
+export interface Context extends Logger {
+}
+export declare class Context implements Logger {
+    #private;
+    [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 createChildOf(parent: Context, name: MaybeSignal<string>, options?: LinkedContextOptions): Context;
+    /**
+     * Emit a lifecycle event to `context`.
+     */
+    static emit(context: Context, event: LifecycleEvent): void;
+    constructor(name: MaybeSignal<string>, options?: ContextOptions);
+    /**
+     * Returns the current name of this context.
+     */
+    getName(): string;
+    /**
+     * Sets a new name for this context.
+     */
+    setName(name: MaybeSignal<string>): void;
+    /**
+     * Creates an instance of a store and attaches it to this context.
+     */
+    provideStore<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.
+     */
+    useStore<T>(store: Store<any, T>): T;
+    /**
+     * Registers a `listener` to be called at a specific transition point during this context's lifecycle.
+     *
+     * Prefer `useMount` and `useUnmount` hooks for general usage.
+     */
+    onLifecycleTransition(event: LifecycleEventName, listener: LifecycleListener): () => void;
+    effect(callback: EffectFn): UnsubscribeFn;
+    /**
+     * Gets the value stored at `key`, or returns `options.fallback` if none is set.
+     */
+    getState<T>(key: any, options: ContextGetStateOptionsWithFallbackValue<T>): T;
+    /**
+     * Gets the value stored at `key`, or throws an error if none is set.
+     */
+    getState<T>(key: any, options?: ContextGetStateOptions<T>): T;
+    /**
+     * Returns a Map containing all state values available to this context.
+     *
+     * Pass `options.immediate` to only include state stored on this context.
+     * By default all state stored on parent contexts is also included.
+     */
+    getStateMap(options?: ContextGetStateMapOptions): Map<any, any>;
+    /**
+     * Stores `value` at `key` in this context's state.
+     */
+    setState<T>(key: any, value: T): void;
+    /**
+     * For each tuple in `entries`, stores `value` at `key` in this context's state.
+     */
+    setState(entries: [key: any, value: any][]): void;
+}
+export declare function createContext(name: MaybeSignal<string>, options?: ContextOptions): Context;
+export {};

package/dist/core/env.d.ts

@@ -0,0 +1,3 @@
+import type { Env } from "../types";
+export declare function getEnv(): string;
+export declare function setEnv(value: Env): void;

package/dist/core/hooks.d.ts

@@ -0,0 +1,70 @@
+import { type Context, type Ref, type Store } from "../core";
+import { type EffectFn, type MaybeSignal, type Setter, type Signal, type SignalOptions } from "../core/signals";
+/**
+ * Returns the Context object of the `View`, `Store` or `Mixin` this hook is called in.
+ *
+ * @param name - If passed, the context will be renamed. Context takes the name of the component function by default.
+ */
+export declare function useContext(name?: MaybeSignal<string>): Context;
+/**
+ * Returns the nearest instance of a Store provided to this context.
+ */
+export declare function useStore<T>(store: Store<any, T>): T;
+/**
+ * Adds a store to this context and returns the store instance.
+ */
+export declare function useStoreProvider<T, O>(store: Store<O, T>, options?: O): T;
+/**
+ * Schedules `callback` to run just after the component is mounted.
+ * If `callback` returns a function, that function will run when the context is unmounted.
+ */
+export declare function useMount(callback: () => void | (() => void)): void;
+/**
+ * Schedules `callback` to run when the context is unmounted.
+ */
+export declare function useUnmount(callback: () => void): void;
+/**
+ * Creates a new read-only Signal. Returns bound Getter and Setter functions.
+ *
+ * @example
+ * const [$count, setCount] = useSignal(5);
+ * $count(); // 5
+ * setCount(6);
+ * setCount((current) => current + 1);
+ * $count(); // 7
+ */
+export declare function useSignal<T>(value: T, options?: SignalOptions<T>): [Signal<T>, Setter<T>];
+export declare function useSignal<T>(value: undefined, options: SignalOptions<T>): [Signal<T | undefined>, Setter<T | undefined>];
+export declare function useSignal<T>(): [Signal<T | undefined>, Setter<T | undefined>];
+export declare function useMemo<T>(compute: (current?: T) => MaybeSignal<T>, deps?: Signal<any>[], options?: SignalOptions<T>): Signal<T>;
+/**
+ * Takes the current state and a dispatched action. Returns a new state based on the action.
+ * Typically the body of this function will be a large switch statement.
+ */
+export type Reducer<State, Action> = (state: State, action: Action) => State;
+/**
+ * Dispatches an action to this reducer, causing the state to update.
+ */
+export type Dispatcher<Action> = (action: Action) => void;
+/**
+ *
+ */
+export declare function useReducer<State, Action>(reducer: Reducer<State, Action>, initialState: State): [Signal<State>, Dispatcher<Action>];
+/**
+ * Creates an effect bound to the current context.
+ * The `fn` is called when the component is mounted, then again each time the dependencies are updated until the component is unmounted.
+ */
+export declare function useEffect(fn: EffectFn, deps?: Signal<any>[]): void;
+/**
+ * A hybrid Ref which is both a function ref and a React-style object ref with a `current` property.
+ * Both the `current` property and the function syntax access the same value.
+ */
+export interface HybridRef<T> extends Ref<T> {
+    current: T;
+}
+/**
+ * Creates a Ref. Useful for getting references to DOM nodes.
+ *
+ * @deprecated use ref()
+ */
+export declare function useRef<T>(initialValue?: T): HybridRef<T>;

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

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

package/dist/core/index.d.ts

@@ -0,0 +1,25 @@
+export { createApp } from "./app.js";
+export { batch, effect, get, memo, readable, signal, untracked, writable } from "./signals.js";
+export type { MaybeSignal, Signal, Writable, Setter } from "./signals.js";
+export * from "./hooks.js";
+export { createContext } from "./context.js";
+export type { Context } from "./context.js";
+export { createMarkup, Markup, MarkupNode, render } from "./markup.js";
+export { ref, type Ref } from "./ref.js";
+export { For, type ForProps } from "./views/for.js";
+export { Portal, type PortalProps } from "./views/portal.js";
+export { Show, type ShowProps } from "./views/show.js";
+export { deepEqual, shallowEqual, strictEqual } from "../utils.js";
+export { getEnv, setEnv } from "./env.js";
+export { createLogger, onLoggerCrash, setLogFilter, setLogLevels } from "./logger.js";
+export type { Logger, LoggerCrashProps, LoggerOptions, LogLevels } from "./logger.js";
+export type { CSSProperties, Env, InputType, Mixin, Renderable, Store, View } from "../types.js";
+export type { CrashViewProps } from "./views/default-crash-view.js";
+import type { IntrinsicElements as Elements } from "../types.js";
+declare global {
+    namespace JSX {
+        interface IntrinsicElements extends Elements {
+            [tag: string]: any;
+        }
+    }
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,42 @@
+import type { Env } from "../types.js";
+import { type MaybeSignal } from "./signals.js";
+export interface LogLevels {
+    info: boolean | Env;
+    log: boolean | Env;
+    warn: boolean | Env;
+    error: boolean | Env;
+}
+export interface Logger {
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    crash(error: Error): Error;
+}
+export interface LoggerOptions {
+    /**
+     * Tag value to print with logs.
+     */
+    tag?: string;
+    /**
+     * Label for tag value. Will be printed without a label if not specified.
+     */
+    tagName?: string;
+    /**
+     * Console object to use for logging (mostly for testing). Uses window.console by default.
+     */
+    console?: any;
+}
+export interface LoggerCrashProps {
+    error: Error;
+    loggerName: string;
+    tag?: string;
+    tagName?: string;
+}
+/**
+ * Listen for logged crashes.
+ */
+export declare function onLoggerCrash(listener: (context: LoggerCrashProps) => 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

@@ -0,0 +1,82 @@
+import type { IntrinsicElements, Renderable, View } from "../types.js";
+import { Context } from "./context.js";
+import { MarkupNode } from "./nodes/_markup.js";
+import { KeyFn, RenderFn } from "./nodes/repeat.js";
+import { type Signal } from "./signals.js";
+export { MarkupNode };
+type PropsOf<V extends string | View<any>> = V extends View<infer U> ? U : any;
+/**
+ * `Markup` is a set of metadata that will be constructed into a `MarkupNode`.
+ */
+export declare class Markup<Type extends string | View<any> = string | View<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 ""
+     */
+    type: Type;
+    /**
+     * Data that will be passed to a new MarkupNode instance when it is constructed.
+     * Includes a `children` prop if children were passed.
+     */
+    props: PropsOf<Type>;
+    constructor(type: Type, props: PropsOf<Type>);
+}
+export declare enum MarkupType {
+    DOM = "$dom",
+    Dynamic = "$dynamic",
+    Portal = "$portal",
+    Repeat = "$repeat"
+}
+export interface MarkupNodeProps {
+    [MarkupType.DOM]: {
+        value: Node;
+    };
+    [MarkupType.Dynamic]: {
+        source: Signal<any>;
+    };
+    [MarkupType.Portal]: {
+        content: Renderable;
+        parent: Element;
+    };
+    [MarkupType.Repeat]: {
+        items: Signal<any[]>;
+        key: KeyFn<any>;
+        render: RenderFn<any>;
+    };
+}
+export interface MarkupCustomElementProps {
+    /**
+     * Custom element tagName pattern (must include a hyphen).
+     */
+    [tag: `${string}-${string}`]: Record<string, any>;
+}
+/**
+ * Creates a `Markup` element that defines an HTML element.
+ */
+export declare function createMarkup<T extends keyof IntrinsicElements>(tag: T, attrs: IntrinsicElements[T] & {
+    children?: Renderable;
+}): Markup;
+/**
+ * Creates a `Markup` element that defines an HTML custom element.
+ */
+export declare function createMarkup<T extends keyof MarkupCustomElementProps>(type: T, props: MarkupCustomElementProps[T]): Markup;
+/**
+ * Creates a `Markup` element that defines a `MarkupNode`.
+ */
+export declare function createMarkup<T extends keyof MarkupNodeProps>(type: T, props: MarkupNodeProps[T]): Markup;
+/**
+ * Creates a `Markup` element that defines a view.
+ */
+export declare function createMarkup<P extends {}>(type: View<P>, props?: P): Markup;
+/**
+ * Creates a `Markup` element that defines a view.
+ */
+export declare function createMarkup<P>(type: View<P>, props: P): Markup;
+/**
+ * Takes any `Renderable` value and returns a `MarkupNode` that will display it.
+ */
+export declare function render(content: Renderable, context?: Context): MarkupNode;
+/**
+ * Convert basically anything into a set of `MarkupNode`s.
+ */
+export declare function toMarkupNodes(context: Context, ...content: any[]): MarkupNode[];

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

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

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

@@ -0,0 +1,13 @@
+import { MarkupNode } from "./_markup";
+/**
+ * A lightweight MarkupNode wrapper for a plain DOM node.
+ */
+export declare class DOMNode extends MarkupNode {
+    private root;
+    constructor(node: Node);
+    getRoot(): Node;
+    isMounted(): boolean;
+    mount(parent: Element, after?: Node): void;
+    unmount(skipDOM?: boolean): void;
+    move(parent: Element, after?: Node): void;
+}

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

@@ -0,0 +1,22 @@
+import type { Context } from "../context.js";
+import { type Signal } from "../signals.js";
+import { MarkupNode } from "./_markup.js";
+/**
+ * Renders any kind of content; markup, signals, DOM nodes, etc.
+ * If it can be rendered by Dolla then Dynamic will do it.
+ */
+export declare class DynamicNode extends MarkupNode {
+    private root;
+    private children;
+    private context;
+    private $slot;
+    private unsubscribe?;
+    constructor(context: Context, $slot: Signal<any>);
+    getRoot(): Text;
+    isMounted(): boolean;
+    mount(parent: Node, after?: Node): void;
+    unmount(skipDOM?: boolean): void;
+    move(parent: Element, after?: Node): void;
+    private cleanup;
+    private update;
+}

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

@@ -0,0 +1,27 @@
+import { Context } from "../context.js";
+import { MarkupNode } from "./_markup.js";
+/**
+ * Renders an HTML or SVG element.
+ */
+export declare class ElementNode extends MarkupNode {
+    private root;
+    private id;
+    readonly tag: string;
+    readonly props: Record<string, any>;
+    private context;
+    private childNodes;
+    private unsubscribers;
+    private ref?;
+    private canClickAway;
+    constructor(context: Context, tag: string, props: Record<string, any>);
+    getRoot(): HTMLElement | SVGElement;
+    isMounted(): boolean;
+    mount(parent: Node, after?: Node): void;
+    unmount(skipDOM?: boolean): void;
+    move(parent: Element, after?: Node): void;
+    private attachProp;
+    private getKey;
+    private applyProps;
+    private applyStyles;
+    private applyClasses;
+}

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

@@ -0,0 +1,18 @@
+import type { Renderable } from "../../types.js";
+import { Context } from "../context.js";
+import { MarkupNode } from "./_markup.js";
+/**
+ * Renders content into a specified parent node.
+ */
+export declare class PortalNode extends MarkupNode {
+    private context;
+    private value;
+    private parent;
+    private node?;
+    constructor(context: Context, value: Renderable, parent: Element);
+    getRoot(): Node | undefined;
+    isMounted(): boolean;
+    mount(_parent: Element, _after?: Node): void;
+    unmount(skipDOM?: boolean): void;
+    move(_parent: Element, _after?: Node): void;
+}

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

@@ -0,0 +1,27 @@
+import type { Renderable } from "../../types.js";
+import type { Context } from "../context.js";
+import { type Signal } from "../signals.js";
+import { MarkupNode } from "./_markup.js";
+export type Key = any;
+export type KeyFn<T> = (item: T, index: number) => Key;
+export type RenderFn<T> = (item: Signal<T>, index: Signal<number>) => Renderable;
+/**
+ * Renders a list of items.
+ */
+export declare class RepeatNode<T> extends MarkupNode {
+    private root;
+    private context;
+    private items;
+    private key;
+    private render;
+    private unsubscribe;
+    private connectedItems;
+    constructor(context: Context, items: Signal<T[]>, key: KeyFn<T>, render: RenderFn<T>);
+    getRoot(): Text;
+    isMounted(): boolean;
+    mount(parent: Element, after?: Node): void;
+    unmount(skipDOM?: boolean): void;
+    move(parent: Element, after?: Node): void;
+    private _cleanup;
+    private _update;
+}

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

@@ -0,0 +1,25 @@
+import type { View } from "../../types.js";
+import { Context } from "../context.js";
+import { MarkupNode } from "./_markup.js";
+export declare const VIEW: unique symbol;
+/**
+ * Renders a View.
+ */
+export declare class ViewNode<P> extends MarkupNode {
+    readonly id: string;
+    readonly props: P;
+    readonly context: Context;
+    readonly view: View<P>;
+    node?: MarkupNode;
+    /**
+     * @param context - Parent contenxt to link to.
+     * @param view - View function to mount.
+     * @param props - Props to pass to view function.
+     */
+    constructor(context: Context, view: View<P>, props: P);
+    getRoot(): Node | undefined;
+    isMounted(): boolean;
+    mount(parent: Element, after?: Node): void;
+    unmount(skipDOM?: boolean): void;
+    move(parent: Element, after?: Node): void;
+}

package/dist/core/ref.d.ts

@@ -0,0 +1,19 @@
+export declare const EMPTY_REF: unique symbol;
+/**
+ * A hybrid getter/setter function that stores the last value it was called with.
+ * Guarantees a value is held at runtime by throwing an error if no value is set.
+ */
+export interface Ref<T> {
+    /**
+     * Returns the currently stored value of the ref, or throws an error if no value has been set.
+     */
+    (): T;
+    /**
+     * Stores a new value to the ref and returns that value.
+     */
+    (value: T): T;
+}
+/**
+ * Creates a Ref.
+ */
+export declare function ref<T>(value?: T): Ref<T>;

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

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