@manyducks.co/dolla 1.0.1 → 2.0.0-alpha.0

package/dist/modules/language.d.ts

@@ -0,0 +1,41 @@
+import { type Signal } from "../signals.js";
+import type { Stringable } from "../types.js";
+import type { Dolla } from "./dolla.js";
+/**
+ * An object where values are either a translated string or another nested Translation object.
+ */
+type LocalizedStrings = Record<string, string | Record<string, string | Record<string, string | Record<string, string>>>>;
+export interface LanguageConfig {
+    name: string;
+    /**
+     * Path to a JSON file with translated strings for this language.
+     */
+    path?: string;
+    /**
+     * A callback function that returns a Promise that resolves to the translation object for this language.
+     */
+    fetch?: () => Promise<LocalizedStrings>;
+}
+export type LanguageSetupOptions = {
+    /**
+     * Default language to load on startup
+     */
+    initialLanguage?: string | null;
+    languages: LanguageConfig[];
+};
+export declare class Language {
+    #private;
+    $current: Signal<string | undefined>;
+    constructor(dolla: Dolla);
+    get supportedLanguages(): string[];
+    setup(options: LanguageSetupOptions): void;
+    setLanguage(name: string): Promise<void>;
+    /**
+     * Returns a Signal containing the value at `key`.
+    
+     * @param key - Key to the translated value.
+     * @param values - A map of {{placeholder}} names and the values to replace them with.
+     */
+    t(key: string, values?: Record<string, Stringable | Signal<Stringable>>): Signal<string>;
+}
+export {};

package/{lib/stores → dist/modules}/render.d.ts

@@ -1,8 +1,7 @@
-import { type StoreContext } from "../store.js";
-/**
- * Batches DOM updates for better performance.
- */
-export declare function RenderStore(ctx: StoreContext): {
+import type { Dolla } from "./dolla.js";
+export declare class Render {
+    #private;
+    constructor(dolla: Dolla);
     /**
      * Queues a callback to run in the next render batch.
      * Running your DOM mutations in update callbacks reduces layout thrashing.
@@ -15,4 +14,4 @@ export declare function RenderStore(ctx: StoreContext): {
      * Returns a Promise that resolves once the callback has run.
      */
     read(callback: () => void): Promise<void>;
-};
+}

package/{lib/stores → dist/modules}/router.d.ts

@@ -1,17 +1,8 @@
-import { type History } from "history";
-import { type Markup } from "../markup.js";
-import { type Store, type StoreContext } from "../store.js";
-import { type BuiltInStores, type Stringable } from "../types.js";
-import { type View } from "../view.js";
+import { type DOMHandle, type Markup } from "../markup.js";
+import { type Stringable } from "../types.js";
+import { type ViewFunction } from "../view.js";
+import type { Dolla } from "./dolla.js";
 export interface RouteMatchContext {
-    /**
-     * Returns the shared instance of `store`.
-     */
-    getStore<T extends Store<any, any>>(store: T): ReturnType<T>;
-    /**
-     * Returns the shared instance of a built-in store.
-     */
-    getStore<N extends keyof BuiltInStores>(name: N): BuiltInStores[N];
     /**
      * Redirects the user to a different route instead of matching the current one.
      */
@@ -29,7 +20,7 @@ export interface Route {
     /**
      * View to display when this route is matched.
      */
-    view?: View<any>;
+    view?: ViewFunction<any>;
     /**
      * Subroutes.
      */
@@ -78,7 +69,7 @@ interface ParsedParams {
 }
 interface ParsedQuery extends ParsedParams {
 }
-interface NavigateOptions {
+export interface NavigateOptions {
     /**
      * Replace the current item in the history stack instead of adding a new one.
      * The back button will send the user to the page they visited before this. Defaults to false.
@@ -89,20 +80,31 @@ interface NavigateOptions {
      */
     preserveQuery?: boolean;
 }
-interface RouterStoreOptions {
-    routes: Route[];
+export declare enum RoutingStyle {
     /**
-     * Use hash-based routing if true.
+     * Constructs routes like "https://www.example.com/#/sub/route" which work without any server-side setup.
+     * A good choice if your app has no backend.
      */
-    hash?: boolean;
+    hash = "hash",
     /**
-     * A history object from the `history` package.
-     *
-     * @see https://www.npmjs.com/package/history
+     * Constructs routes like "https://www.example.com/sub/route" which look nicer (subjective?) than hash routes and are what most users will expect URLs to look like, but require additional backend setup.
+     * Path routing requires you to configure your backend to redirect to the app's index.html when subpaths are requested.
+     */
+    path = "path"
+}
+export interface RouterSetupOptions {
+    routes: Route[];
+    /**
+     * The routing style to use; "hash" will construct routes like "https://www.example.com/#/sub/route" which work without any server-side setup, while "path" will construct routes that use paths directly.
      */
-    history?: History;
+    style?: RoutingStyle;
+}
+export interface RouterElements {
+    readonly rootElement?: HTMLElement;
+    readonly rootView?: DOMHandle;
 }
-export declare function RouterStore(ctx: StoreContext<RouterStoreOptions>): {
+export declare class Router {
+    #private;
     /**
      * The currently matched route pattern, if any.
      */
@@ -119,7 +121,16 @@ export declare function RouterStore(ctx: StoreContext<RouterStoreOptions>): {
      * The current query params. Changes to this object will be reflected in the URL.
      */
     $query: import("../signals.js").Signal<ParsedQuery>;
-    setQuery: import("../signals.js").SignalSetter<ParsedQuery, ParsedQuery>;
+    constructor(dolla: Dolla, elements: RouterElements);
+    setup(options: RouterSetupOptions): void;
+    /**
+     * Navigates to another route.
+     *
+     * @example
+     * navigate("/login"); // navigate to `/login`
+     * navigate(["/users", 215], { replace: true }); // replace current history entry with `/users/215`
+     */
+    go(path: Stringable | Stringable[], options?: NavigateOptions): void;
     /**
      * Navigate backward. Pass a number of steps to hit the back button that many times.
      */
@@ -128,20 +139,7 @@ export declare function RouterStore(ctx: StoreContext<RouterStoreOptions>): {
      * Navigate forward. Pass a number of steps to hit the forward button that many times.
      */
     forward(steps?: number): void;
-    /**
-     * Navigates to another route.
-     *
-     * @example
-     * navigate("/login"); // navigate to `/login`
-     * navigate(["/users", 215], { replace: true }); // replace current history entry with `/users/215`
-     *
-     * @param args - One or more path segments optionally followed by an options object.
-     */
-    navigate: {
-        (path: Stringable, options?: NavigateOptions): void;
-        (fragments: Stringable[], options?: NavigateOptions): void;
-    };
-};
+}
 /**
  * Intercepts links within the root node.
  *

package/{lib → dist}/nodes/cond.d.ts

@@ -1,12 +1,10 @@
-import { type AppContext, type ElementContext } from "../app.js";
-import { type DOMHandle, type Markup } from "../markup.js";
+import { type DOMHandle, type ElementContext, type Markup } from "../markup.js";
 import { type Signal, type StopFunction } from "../signals.js";
 import { type Renderable } from "../types.js";
 export interface ConditionalConfig {
     $predicate: Signal<any>;
     thenContent?: Renderable;
     elseContent?: Renderable;
-    appContext: AppContext;
     elementContext: ElementContext;
 }
 export declare class Conditional implements DOMHandle {
@@ -17,7 +15,6 @@ export declare class Conditional implements DOMHandle {
     thenContent?: Markup[];
     elseContent?: Markup[];
     connectedContent: DOMHandle[];
-    appContext: AppContext;
     elementContext: ElementContext;
     initialUpdateHappened: boolean;
     previousValue?: any;

package/{lib → dist}/nodes/html.d.ts

@@ -1,8 +1,6 @@
-import { type AppContext, type ElementContext } from "../app.js";
-import { type DOMHandle, type Markup } from "../markup.js";
+import { type DOMHandle, type ElementContext, type Markup } from "../markup.js";
 import { type StopFunction } from "../signals.js";
 type HTMLOptions = {
-    appContext: AppContext;
     elementContext: ElementContext;
     tag: string;
     props?: any;
@@ -13,12 +11,11 @@ export declare class HTML implements DOMHandle {
     props: Record<string, any>;
     children: DOMHandle[];
     stopCallbacks: StopFunction[];
-    appContext: AppContext;
     elementContext: ElementContext;
     uniqueId: string;
     canClickAway: boolean;
     get connected(): boolean;
-    constructor({ tag, props, children, appContext, elementContext }: HTMLOptions);
+    constructor({ tag, props, children, elementContext }: HTMLOptions);
     connect(parent: Node, after?: Node): void;
     disconnect(): void;
     setChildren(next: DOMHandle[]): void;

package/{lib → dist}/nodes/observer.d.ts

@@ -1,9 +1,7 @@
-import { type AppContext, type ElementContext } from "../app.js";
-import { type DOMHandle } from "../markup.js";
+import { type DOMHandle, type ElementContext } from "../markup.js";
 import { type Signal } from "../signals.js";
 import type { Renderable } from "../types.js";
 interface ObserverOptions {
-    appContext: AppContext;
     elementContext: ElementContext;
     signals: Signal<any>[];
     renderFn: (...values: any) => Renderable;
@@ -16,14 +14,13 @@ export declare class Observer implements DOMHandle {
     endNode: Node;
     connectedViews: DOMHandle[];
     renderFn: (...values: any) => Renderable;
-    appContext: AppContext;
     elementContext: ElementContext;
     observerControls: {
         start: () => void;
         stop: () => void;
     };
     get connected(): boolean;
-    constructor({ signals, renderFn, appContext, elementContext }: ObserverOptions);
+    constructor({ signals, renderFn, elementContext }: ObserverOptions);
     connect(parent: Node, after?: Node): void;
     disconnect(): void;
     setChildren(): Promise<void>;

package/{lib → dist}/nodes/outlet.d.ts

@@ -1,9 +1,7 @@
-import { type AppContext, type ElementContext } from "../app.js";
-import { type DOMHandle } from "../markup.js";
+import { type DOMHandle, type ElementContext } from "../markup.js";
 import { type Signal, type StopFunction } from "../signals.js";
 export interface OutletConfig {
     $children: Signal<DOMHandle[]>;
-    appContext: AppContext;
     elementContext: ElementContext;
 }
 /**
@@ -15,7 +13,6 @@ export declare class Outlet implements DOMHandle {
     $children: Signal<DOMHandle[]>;
     stopCallback?: StopFunction;
     connectedChildren: DOMHandle[];
-    appContext: AppContext;
     elementContext: ElementContext;
     constructor(config: OutletConfig);
     get connected(): boolean;

package/{lib → dist}/nodes/portal.d.ts

@@ -1,10 +1,8 @@
-import { type AppContext, type ElementContext } from "../app.js";
-import { type DOMHandle } from "../markup.js";
+import { type DOMHandle, type ElementContext } from "../markup.js";
 import { type Renderable } from "../types.js";
 interface PortalConfig {
     content: Renderable;
     parent: Node;
-    appContext: AppContext;
     elementContext: ElementContext;
 }
 /**

package/{lib → dist}/nodes/repeat.d.ts

@@ -1,9 +1,7 @@
-import { type AppContext, type ElementContext } from "../app.js";
-import { type DOMHandle } from "../markup.js";
+import { type DOMHandle, type ElementContext } from "../markup.js";
 import { type Signal, type SignalSetter, type StopFunction } from "../signals.js";
 import { type ViewContext, type ViewResult } from "../view.js";
 interface RepeatOptions<T> {
-    appContext: AppContext;
     elementContext: ElementContext;
     $items: Signal<T[]>;
     keyFn: (value: T, index: number) => string | number | symbol;
@@ -23,12 +21,11 @@ export declare class Repeat<T> implements DOMHandle {
     $items: Signal<T[]>;
     stopCallback?: StopFunction;
     connectedItems: ConnectedItem<T>[];
-    appContext: AppContext;
     elementContext: ElementContext;
     renderFn: ($value: Signal<T>, $index: Signal<number>, ctx: ViewContext) => ViewResult;
     keyFn: (value: T, index: number) => string | number | symbol;
     get connected(): boolean;
-    constructor({ appContext, elementContext, $items, renderFn, keyFn }: RepeatOptions<T>);
+    constructor({ elementContext, $items, renderFn, keyFn }: RepeatOptions<T>);
     connect(parent: Node, after?: Node): void;
     disconnect(): void;
     setChildren(): void;

package/{lib → dist}/nodes/text.d.ts

@@ -1,5 +1,5 @@
 import { type DOMHandle } from "../markup.js";
-import { MaybeSignal, type StopFunction } from "../signals.js";
+import { type MaybeSignal, type StopFunction } from "../signals.js";
 interface Stringable {
     toString(): string;
 }

package/{lib → dist}/signals.d.ts

@@ -9,16 +9,16 @@ type Unwrapped<T> = T extends Signal<infer V> ? V : T;
 export type SignalValues<T extends MaybeSignal<any>[]> = {
     [K in keyof T]: Unwrapped<T[K]>;
 };
-export interface SignalCreateOptions<T> {
+export interface CreateSignalOptions<T> {
     /**
-     * Determines if the `next` value is equal to the `previous` value.
+     * Determines if the `next` value is equal to the `current` value.
      * If this function returns true, watchers will be notified of changes. If it returns false, watchers will not be notified.
      * By default equality is defined as deep equality.
      *
      * @param next - The new value being set.
-     * @param previous - The previous value being replaced.
+     * @param current - The current value being replaced.
      */
-    equality?: (next: T, previous: T) => boolean;
+    equality?: (next: T, current: T) => boolean;
 }
 export interface SignalWatchOptions<T> {
     /**
@@ -34,23 +34,17 @@ export interface Signal<T> {
     get(): T;
     /**
      * Watch this signal's value with a `callback` function.
-     * The `callback` is only called if the value is not equal to the previous value.
+     * The `callback` is only called if the value is not equal to the current value.
      *
      * > NOTE: If watching a signal inside a view, use the `.watch` method on the `ViewContext`. That method will automatically
      * clean up all watchers when the view is disconnected. Watchers created here must be cleaned up manually.
      */
     watch(callback: (value: T) => void, options?: SignalWatchOptions<T>): StopFunction;
 }
-export interface SignalSetter<I, O = I> {
-    /**
-     * Updates the signal's value.
-     */
-    (value: O): void;
-    /**
-     * Takes a callback that receives the signal's current value and returns a new one.
-     */
-    (callback: (current: I) => O): void;
-}
+/** A new value for a signal, or a callback that receives the current value and returns a new one. */
+export type SignalSetAction<I, O = I> = O | ((current: I) => O);
+/** Callback that updates the value of a signal. */
+export type SignalSetter<I, O = I> = (value: SignalSetAction<I, O>) => void;
 export type MaybeSignal<T> = Signal<T> | T;
 /**
  * A signal and setter in one. Useful for passing signals that are intended to be updated by subviews.
@@ -63,7 +57,7 @@ export interface SettableSignal<I, O = I> extends Signal<I> {
     /**
      * Takes a callback that recieves the signal's current value and returns a new one.
      */
-    set(callback: (previous: I) => O): void;
+    set(callback: (current: I) => O): void;
 }
 export declare function isSignal<T>(value: any): value is Signal<T>;
 export declare function isSettableSignal<T>(value: any): value is Signal<T>;
@@ -75,44 +69,33 @@ export declare function designalify<T>(value: MaybeSignal<T>): T;
  * Ensures a variable that may be a signal or plain value is a signal.
  */
 export declare function signalify<T>(value: MaybeSignal<T>): Signal<T>;
-export interface signal {
-    /**
-     * Creates a new Signal and setter.
-     */
-    /**
-     * Creates a new Signal and setter.
-     */
-    /**
-     * Creates a SettableSignal with an initial value.
-     */
-    settable<T>(initialValue: T, options?: SignalCreateOptions<T>): SettableSignal<T>;
-    /**
-     * Creates a SettableSignal.
-     */
-    settable<T>(initialValue?: T, options?: SignalCreateOptions<T | undefined>): SettableSignal<T | undefined>;
-    /**
-     * Combines a Signal and setter into a SettableSignal.
-     */
-    toSettable<I, O = I>(signal: Signal<I>, setter: SignalSetter<I, O>): SettableSignal<I>;
-    /**
-     * Creates a SignalSetter with custom logic provided by `callback`.
-     */
-    createSetter<I, O = I>(signal: Signal<I>, callback: (next: O, previous: I) => void): SignalSetter<I, O>;
-}
-export declare function signal<T>(initialValue: T, options?: SignalCreateOptions<T>): [Signal<T>, SignalSetter<T>];
-export declare function signal<T>(initialValue?: T, options?: SignalCreateOptions<T | undefined>): [Signal<T | undefined>, SignalSetter<T | undefined>];
-export declare namespace signal {
-    var settable: typeof createSettableSignal;
-    var toSettable: typeof createSettableSignalFrom;
-    var createSetter: typeof createSignalSetter;
-}
-declare function createSettableSignal<T>(initialValue: T, options?: SignalCreateOptions<T>): SettableSignal<T>;
-declare function createSettableSignal<T>(initialValue?: T, options?: SignalCreateOptions<T | undefined>): SettableSignal<T | undefined>;
-declare function createSettableSignalFrom<I, O = I>(signal: Signal<I>, setter: SignalSetter<I, O>): SettableSignal<I, O>;
-declare function createSignalSetter<I, O = I>(signal: Signal<I>, callback: (next: O, previous: I) => void): SignalSetter<I, O>;
-export interface SignalDeriveOptions {
-    equality?: (next: unknown, previous: unknown) => boolean;
+/**
+ * Creates a SettableSignal.
+ */
+export declare function createSettableSignal<T>(initialValue: T, options?: CreateSignalOptions<T>): SettableSignal<T>;
+/**
+ * Creates a SettableSignal.
+ */
+export declare function createSettableSignal<T>(initialValue?: T, options?: CreateSignalOptions<T | undefined>): SettableSignal<T | undefined>;
+/**
+ * Join a signal and its setter into a single SettableSignal object.
+ */
+export declare function toSettableSignal<I, O = I>(signal: Signal<I>, setter: SignalSetter<I, O>): SettableSignal<I, O>;
+/**
+ * Creates a SignalSetter with custom logic provided by `callback`.
+ */
+export declare function createSignalSetter<I, O = I>(signal: Signal<I>, callback: (next: O, current: I) => void): SignalSetter<I, O>;
+/**
+ * Creates a signal and setter.
+ */
+export declare function createSignal<T>(initialValue: T, options?: CreateSignalOptions<T>): [Signal<T>, SignalSetter<T>];
+/**
+ * Creates a signal and setter.
+ */
+export declare function createSignal<T>(initialValue?: T, options?: CreateSignalOptions<T | undefined>): [Signal<T | undefined>, SignalSetter<T | undefined>];
+export interface DeriveSignalOptions {
+    equality?: (next: unknown, current: unknown) => boolean;
 }
-export declare function derive<Inputs extends MaybeSignal<any>[], T>(signals: [...Inputs], fn: (...currentValues: SignalValues<Inputs>) => T | Signal<T>, options?: SignalDeriveOptions): Signal<T>;
+export declare function derive<Inputs extends MaybeSignal<any>[], T>(signals: [...Inputs], fn: (...currentValues: SignalValues<Inputs>) => T | Signal<T>, options?: DeriveSignalOptions): Signal<T>;
 export declare function watch<I extends MaybeSignal<any>[]>(signals: [...I], fn: (...currentValues: SignalValues<I>) => void): StopFunction;
 export {};

package/{lib → dist}/types.d.ts

@@ -1,19 +1,11 @@
 import type * as CSS from "csstype";
 import { Ref, type Markup } from "./markup.js";
-import { type Store } from "./store.js";
-import { type DocumentStore } from "./stores/document.js";
-import { type RenderStore } from "./stores/render.js";
 import { SettableSignal, Signal } from "./signals.js";
 /**
  * Represents everything that can be handled as a DOM node.
  * These are all the items considered valid to pass as children to any element.
  */
 export type Renderable = string | number | Markup | false | null | undefined | Signal<any> | (string | number | Markup | false | null | undefined | Signal<any>)[];
-export type StoreExports<T> = T extends Store<any, infer O> ? O : unknown;
-export interface BuiltInStores {
-    document: StoreExports<typeof DocumentStore>;
-    render: StoreExports<typeof RenderStore>;
-}
 export type Stringable = {
     toString(): string;
 };

package/{lib → dist}/utils.d.ts

@@ -1,3 +1,4 @@
+export declare const noOp: () => void;
 export declare function deepEqual(one: any, two: any): boolean;
 /**
  * Takes an old value and a new value.  Returns a merged copy if both are objects, otherwise returns the new value.
@@ -12,3 +13,12 @@ export declare function merge(one: unknown, two: unknown): any;
  * @param object - An object to clone without the omitted keys.
  */
 export declare function omit<O extends Record<any, any>>(keys: (keyof O)[], object: O): Record<any, any>;
+export declare function getDefaultConsole(): any;
+export declare function colorFromString(value: string): string;
+export type MatcherFunction = (value: string) => boolean;
+/**
+ * Parses a filter string into a match function.
+ *
+ * @param pattern - A string or regular expression that specifies a pattern for names of debug channels you want to display.
+ */
+export declare function createMatcher(pattern: string | RegExp): (value: string) => boolean;

package/dist/view.d.ts

@@ -0,0 +1,44 @@
+import { type DOMHandle, type ElementContext, type Markup } from "./markup.js";
+import type { Logger } from "./modules/dolla.js";
+import { type MaybeSignal, Signal, type SignalValues, type StopFunction } from "./signals.js";
+/**
+ * Any valid value that a View can return.
+ */
+export type ViewResult = Node | Signal<any> | Markup | Markup[] | null;
+export type ViewFunction<P> = (props: P, context: ViewContext) => ViewResult;
+export interface ViewContext extends Logger {
+    /**
+     * A string ID unique to this view.
+     */
+    readonly uid: string;
+    /**
+     * Sets the name of the view's built in logger.
+     */
+    setName(name: string): void;
+    /**
+     * 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;
+    /**
+     * Watch a set of signals. The callback is called when any of the signals receive a new value.
+     * Watchers will be stopped when this view is unmounted. Returns a function to stop watching early.
+     */
+    watch<T extends MaybeSignal<any>[]>(signals: [...T], callback: (...values: SignalValues<T>) => void): StopFunction;
+    /**
+     * Returns a Markup element that displays this view's children.
+     */
+    outlet(): Markup;
+}
+export declare function constructView<P>(elementContext: ElementContext, view: ViewFunction<P>, props: P, children?: Markup[]): DOMHandle;

package/dist/views/default-crash-page.d.ts

@@ -0,0 +1,8 @@
+type CrashPageProps = {
+    message: string;
+    error: Error;
+    loggerName: string;
+    uid?: string;
+};
+export declare function DefaultCrashPage(props: CrashPageProps): import("../markup.js").Markup;
+export {};