@manyducks.co/dolla 2.0.0-alpha.6 → 2.0.0-alpha.60

package/dist/core/context.d.ts

@@ -0,0 +1,144 @@
+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 = 0,
+    DID_MOUNT = 1,
+    WILL_UNMOUNT = 2,
+    DID_UNMOUNT = 3,
+    DISPOSE = 4
+}
+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 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 linked(parent: Context, name: MaybeSignal<string>, options?: LinkedContextOptions): Context;
+    /**
+     * Emit a lifecycle event to `context`.
+     */
+    static emit(context: Context, event: LifecycleEvent): 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.
+     */
+    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.
+     */
+    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.
+     */
+    beforeMount(listener: LifecycleListener): () => void;
+    /**
+     * Schedule a callback function to run after this context is mounted.
+     */
+    onMount(listener: LifecycleListener): () => void;
+    /**
+     * Schedule a callback function to run just before this context is unmounted.
+     */
+    beforeUnmount(listener: LifecycleListener): () => void;
+    /**
+     * Schedule a callback function to run after this context is unmounted.
+     */
+    onUnmount(listener: LifecycleListener): () => void;
+    effect(callback: EffectFn): UnsubscribeFn;
+    /**
+     * Gets the value stored at `key`, or returns the `defaultValue` if none is set.
+     */
+    getState<T>(key: any, defaultValue: T): T;
+    /**
+     * Gets the value stored at `key`, or throws an error if none is set.
+     */
+    getState<T>(key: any): T;
+    /**
+     * Returns a Map containing all state values available to this context.
+     */
+    getState(): 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 declare class StoreError extends Error {
+}
+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/index.d.ts

@@ -0,0 +1,22 @@
+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";
+export { m, portal, render, repeat, unless, when } from "./markup.js";
+export type { MarkupNode } from "./markup.js";
+export { ref, type Ref } from "./ref.js";
+export { mount, type UnmountFn } from "./mount.js";
+export { deepEqual, shallowEqual, strictEqual } from "../utils.js";
+export { getEnv, setEnv } from "./env.js";
+export { createLogger, setLogFilter, setLogLevels, onLoggerCrash } from "./logger.js";
+export type { Logger, LoggerCrashProps, LoggerOptions, LogLevels } from "./logger.js";
+export type { View, Store, Mixin, 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 {
+    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,125 @@
+import type { IntrinsicElements, Renderable, View } from "../types.js";
+import { Context } from "./context.js";
+import { KeyFn, RenderFn } from "./nodes/repeat.js";
+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 = 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: 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;
+    constructor(type: string | View<P>, props?: P);
+}
+/**
+ * A mountable node that has been constructed from Markup metadata.
+ */
+export interface MarkupNode {
+    /**
+     *
+     */
+    readonly root?: Node;
+    /**
+     * Returns true when this MarkupNode is mounted.
+     */
+    isMounted(): boolean;
+    /**
+     * Mount this MarkupNode to a `parent` element.
+     * If passed, this MarkupNode 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;
+}
+export declare function isMarkupNode(value: any): value is MarkupNode;
+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 m<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 m<T extends keyof MarkupCustomElementProps>(type: T, props: MarkupCustomElementProps[T]): Markup;
+/**
+ * Creates a Markup element that defines a MarkupNode.
+ */
+export declare function m<T extends keyof MarkupNodeProps>(type: T, props: MarkupNodeProps[T]): Markup;
+/**
+ * Creates a Markup element that defines a view.
+ */
+export declare function m<P extends {}>(type: View<P>, props?: P): Markup;
+/**
+ * Creates a Markup element that defines a view.
+ */
+export declare function m<P>(type: View<P>, props: P): Markup;
+/**
+ * If `condition` is truthy, displays `thenContent`, otherwise `elseContent`.
+ */
+export declare function when(condition: MaybeSignal<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
+/**
+ * Inverted `when`. If `condition` is falsy, displays `thenContent`, otherwise `elseContent`.
+ */
+export declare function unless(condition: MaybeSignal<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
+/**
+ * Calls `render` for each item in `items`. Dynamically adds and removes views as items change.
+ * The result of `key` is used to compare items and decide if item was added, removed or updated.
+ */
+export declare function repeat<T>(items: MaybeSignal<T[]>, key: KeyFn<T>, render: RenderFn<T>): Markup;
+/**
+ * Renders `content` into a `parent` node anywhere in the page, rather than its usual position in the view.
+ */
+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.
+ */
+export declare function toMarkupNodes(context: Context, ...content: any[]): MarkupNode[];

package/dist/core/mount.d.ts

@@ -0,0 +1,15 @@
+import { Router } from "../router/router";
+import type { View } from "../types";
+import { Context } from "./context";
+import { type LoggerCrashProps } from "./logger";
+export type UnmountFn = () => Promise<void>;
+export interface MountOptions {
+    crashView?: View<LoggerCrashProps>;
+    /**
+     * 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.
+     */
+    context?: Context;
+}
+export declare function mount(view: View<{}>, domNode: Element, options?: MountOptions): Promise<UnmountFn>;
+export declare function mount(router: Router, domNode: Element, options?: MountOptions): Promise<UnmountFn>;

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

@@ -0,0 +1,14 @@
+import type { MarkupNode } from "../markup";
+import { TYPE } from "../symbols";
+/**
+ * Lightweight MarkupNode wrapper for a plain DOM node.
+ */
+export declare class DOMNode implements MarkupNode {
+    [TYPE]: symbol;
+    root: Node;
+    constructor(node: 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,29 @@
+import type { Context } from "../context.js";
+import { type MarkupNode } from "../markup.js";
+import { type Signal } from "../signals.js";
+import { TYPE } from "../symbols.js";
+/**
+ * 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 MarkupNode {
+    [TYPE]: symbol;
+    root: Text;
+    private children;
+    private context;
+    private $slot;
+    private unsubscribe?;
+    constructor(context: Context, $slot: Signal<any>);
+    isMounted(): boolean;
+    mount(parent: Node, after?: Node): void;
+    unmount(skipDOM?: boolean): void;
+    move(parent: Element, after?: Node): void;
+    private cleanup;
+    private update;
+    /**
+     * Move marker node to end of children.
+     */
+    private moveMarker;
+}

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

@@ -0,0 +1,24 @@
+import { Context } from "../context.js";
+import { type MarkupNode } from "../markup.js";
+import { TYPE } from "../symbols.js";
+export declare class HTML implements MarkupNode {
+    [TYPE]: symbol;
+    root: HTMLElement | SVGElement;
+    private parentContext;
+    private context;
+    tag: string;
+    props: Record<string, any>;
+    private childNodes;
+    private unsubscribers;
+    private ref?;
+    private canClickAway;
+    constructor(context: Context, tag: string, props: Record<string, any>);
+    isMounted(): boolean;
+    mount(parent: Node, after?: Node): void;
+    unmount(skipDOM?: boolean): void;
+    move(parent: Element, after?: Node): void;
+    private attachProp;
+    private applyProps;
+    private applyStyles;
+    private applyClasses;
+}

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

@@ -0,0 +1,19 @@
+import type { Renderable } from "../../types.js";
+import { Context } from "../context.js";
+import { type MarkupNode } from "../markup.js";
+import { TYPE } from "../symbols.js";
+/**
+ * Renders content into a specified parent node.
+ */
+export declare class Portal implements MarkupNode {
+    [TYPE]: symbol;
+    private context;
+    private content;
+    private parent;
+    private element?;
+    constructor(context: Context, content: Renderable, parent: Element);
+    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,25 @@
+import type { Renderable } from "../../types.js";
+import type { Context } from "../context.js";
+import type { MarkupNode } from "../markup.js";
+import { type Signal } from "../signals.js";
+import { TYPE } from "../symbols.js";
+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 {
+    [TYPE]: symbol;
+    root: Text;
+    private context;
+    private items;
+    private key;
+    private render;
+    private unsubscribe;
+    private connectedItems;
+    constructor(context: Context, items: Signal<T[]>, key: KeyFn<T>, render: RenderFn<T>);
+    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,24 @@
+import type { View } from "../../types.js";
+import { Context } from "../context.js";
+import { type MarkupNode } from "../markup.js";
+import { TYPE } from "../symbols.js";
+export declare const VIEW: unique symbol;
+export declare class ViewInstance<P> implements MarkupNode {
+    [TYPE]: symbol;
+    uniqueId: string;
+    context: Context;
+    props: P;
+    view: View<P>;
+    node?: MarkupNode;
+    get root(): Node;
+    /**
+     * @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);
+    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,18 @@
+/**
+ * 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/signals.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 EqualityFn<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?: EqualityFn<T>;
+}
+export declare function isSource<T>(value: MaybeSignal<T>): value is Source<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.
+ */
+export type EffectFn = () => void | (() => void);
+export type UnsubscribeFn = () => 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: EffectFn): UnsubscribeFn;
+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/symbols.d.ts

@@ -0,0 +1,2 @@
+export declare const TYPE: unique symbol;
+export declare const MARKUP_NODE: unique symbol;

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

@@ -13,6 +13,10 @@ export type CrashViewProps = {
     /**
      * Unique identifier to pinpoint the specific view that reported the crash.
      */
-    uid?: string;
+    tag?: string;
+    /**
+     * Label for the tag.
+     */
+    tagName?: string;
 };
-export declare function DefaultCrashView(props: CrashViewProps): import("../markup.js").Markup | import("../markup.js").Markup[];
+export declare function DefaultCrashView(props: CrashViewProps): import("../markup.js").Markup<any>;

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

@@ -0,0 +1,7 @@
+import type { Renderable } from "../../types.js";
+/**
+ * A utility view that displays its children.
+ */
+export declare function Fragment(props: {
+    children?: Renderable;
+}): Renderable;

package/dist/fragment-BahD_BJA.js

@@ -0,0 +1,7 @@
+function r(n) {
+  return n.children;
+}
+export {
+  r as F
+};
+//# sourceMappingURL=fragment-BahD_BJA.js.map

package/dist/fragment-BahD_BJA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragment-BahD_BJA.js","sources":["../src/core/views/fragment.ts"],"sourcesContent":["import type { Renderable } from \"../../types.js\";\n\n/**\n * A utility view that displays its children.\n */\nexport function Fragment(props: { children?: Renderable }) {\n  return props.children;\n}\n"],"names":["Fragment","props"],"mappings":"AAKO,SAASA,EAASC,GAAkC;AACzD,SAAOA,EAAM;AACf;"}

package/dist/{modules/http.d.ts → http/index.d.ts}

@@ -37,18 +37,16 @@ export interface RequestOptions<ReqBody> {
 }
 export interface HTTPRequest<Body> {
     method: string;
-    uri: string;
-    readonly sameOrigin: boolean;
+    url: URL;
     headers: Headers;
-    query: URLSearchParams;
     body: Body;
 }
 export interface HTTPResponse<Body> {
     method: string;
-    uri: string;
+    url: URL;
+    headers: Headers;
     status: number;
     statusText: string;
-    headers: Record<string, string>;
     body: Body;
 }
 export declare class HTTPResponseError extends Error {