@manyducks.co/dolla 0.67.0

package/lib/app.d.ts

@@ -0,0 +1,138 @@
+import { CrashCollector } from "./classes/CrashCollector.js";
+import { DebugHub, type DebugOptions } from "./classes/DebugHub.js";
+import { DOMHandle } from "./markup.js";
+import { initStore, type Store } from "./store.js";
+import { type LanguageConfig } from "./stores/language.js";
+import { type RedirectContext, type RouterOptions } from "./stores/router.js";
+import { type BuiltInStores } from "./types.js";
+import { type View } from "./view.js";
+interface AppOptions {
+    /**
+     * Options for the debug system.
+     */
+    debug?: DebugOptions;
+    /**
+     * Options to configure how routing works.
+     */
+    router?: RouterOptions;
+    /**
+     * Configures the app based on the environment it's running in.
+     */
+    mode?: "development" | "production";
+}
+export interface AppContext {
+    crashCollector: CrashCollector;
+    debugHub: DebugHub;
+    stores: Map<keyof BuiltInStores | StoreRegistration["store"], StoreRegistration>;
+    mode: "development" | "production";
+    rootElement?: HTMLElement;
+    rootView?: DOMHandle;
+}
+export interface ElementContext {
+    stores: Map<StoreRegistration["store"], StoreRegistration>;
+    isSVG?: boolean;
+    componentName?: string;
+    parent?: ElementContext;
+}
+/**
+ * An object kept in App for each store registered with `addStore`.
+ */
+export interface StoreRegistration<O = any> {
+    store: Store<O, any>;
+    options?: O;
+    instance?: ReturnType<typeof initStore>;
+}
+interface AppRouter {
+    /**
+     * Adds a new pattern, a view to display while that pattern matches the current URL, and an optional function to configure route chaining.
+     * Route chaining allows you to add nested routes and redirects that are displayed within the `view`'s outlet while `pattern` matches the current URL.
+     *
+     * @param pattern - A URL pattern to match against the current URL.
+     * @param view - The view to display while `pattern` matches the current URL.
+     * @param subroutes - A callback that takes a router object. Use this to append nested routes and redirects.
+     */
+    route<I>(pattern: string, view: View<I>, subroutes?: (router: AppRouter) => void): this;
+    /**
+     * Adds a new pattern and chains a set of nested routes that are displayed without a layout `view`.
+     *
+     * @param pattern - A URL pattern to match against the current URL.
+     * @param view - Pass null to render subroutes without a parent view.
+     * @param subroutes - A callback that takes a router object. Use this to append nested routes and redirects.
+     */
+    route(pattern: string, view: null, subroutes: (router: AppRouter) => void): this;
+    /**
+     * Adds a new pattern that will redirect to a different route when matched.
+     *
+     * @param pattern - A URL pattern to match against the current URL.
+     * @param redirectPath - A path to redirect to when `pattern` matches the current URL.
+     */
+    redirect(pattern: string, redirectPath: string): this;
+    /**
+     * Adds a new pattern that will redirect to a different route when matched, as calculated by a callback function.
+     * Useful when you require more insight into the path that matched the pattern before deciding where to send the user.
+     *
+     * @param pattern - A URL pattern to match against the current URL.
+     * @param createPath - A function that generates a redirect path from the current URL match.
+     */
+    redirect(pattern: string, createPath: (ctx: RedirectContext) => string): this;
+}
+interface ConfigureContext {
+}
+type ConfigureCallback = (ctx: ConfigureContext) => void | Promise<void>;
+export interface App extends AppRouter {
+    readonly isConnected: boolean;
+    /**
+     * Displays view at the root of the app. All other routes render inside this view's outlet.
+     */
+    main<A extends Record<string, any>>(view: View<A>, attributes?: A): this;
+    /**
+     * Makes this store accessible from any other component in the app, except for stores registered before this one.
+     */
+    store<O>(store: Store<O, any>, options?: O): this;
+    /**
+     * 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];
+    /**
+     * Adds a new language translation to the app.
+     *
+     * @param tag - A valid BCP47 language tag, like `en-US`, `en-GB`, `ja`, etc.
+     * @param config - Language configuration.
+     */
+    language(tag: string, config: LanguageConfig): this;
+    /**
+     * Sets the initial language. The app will default to the first language added if this is not called.
+     */
+    setLanguage(tag: string): this;
+    /**
+     * Sets the initial language based on the user's locale.
+     * Falls back to `fallback` language if provided, otherwise falls back to the first language added.
+     *
+     * @param tag - Set to "auto" to autodetect the user's language.
+     * @param fallback - The language tag to default to if the app fails to detect an appropriate language.
+     */
+    setLanguage(tag: "auto", fallback?: string): this;
+    /**
+     * Runs `callback` after app-level stores are connected to the app, but before views are connected to the DOM.
+     * Use this function to run async configuration code before displaying content to the user.
+     *
+     * Note that this will delay content being displayed on the screen, so using some kind of splash screen is recommended.
+     */
+    configure(callback: ConfigureCallback): this;
+    /**
+     * Initializes and connects the app as a child of `element`.
+     *
+     * @param element - A selector string or a DOM node to attach to. If a string, follows the same format as that taken by `document.querySelector`.
+     */
+    connect(selector: string | Node): Promise<void>;
+    /**
+     * Disconnects views and tears down globals, removing the app from the page.
+     */
+    disconnect(): Promise<void>;
+}
+export declare function makeApp(options?: AppOptions): App;
+export {};

package/lib/classes/CrashCollector.d.ts

@@ -0,0 +1,30 @@
+interface ErrorContext {
+    error: Error;
+    severity: "error" | "crash";
+    componentName: string;
+}
+interface CrashOptions {
+    error: Error;
+    componentName?: string;
+}
+type ErrorCallback = (ctx: ErrorContext) => void;
+/**
+ * Receives errors that occur in components.
+ */
+export declare class CrashCollector {
+    #private;
+    /**
+     * Registers a callback to receive all errors that pass through the CrashCollector.
+     * Returns a function that cancels this listener when called.
+     */
+    onError(callback: ErrorCallback): () => void;
+    /**
+     * Reports an unrecoverable error that requires crashing the whole app.
+     */
+    crash({ error, componentName }: CrashOptions): void;
+    /**
+     * Reports a recoverable error.
+     */
+    error({ error, componentName }: CrashOptions): void;
+}
+export {};

package/lib/classes/DebugHub.d.ts

@@ -0,0 +1,60 @@
+import { type CrashCollector } from "./CrashCollector.js";
+export type DebugOptions = {
+    /**
+     * Determines which debug channels are printed. Supports multiple filters with commas,
+     * a prepended `-` to exclude a channel and wildcards to match partial channels.
+     *
+     * @example "store:*,-store:test" // matches everything starting with "store" except "store:test"
+     */
+    filter?: string | RegExp;
+    /**
+     * Print info messages when true. Default: true for development builds, false for production builds.
+     */
+    info?: boolean | "development";
+    /**
+     * Print log messages when true. Default: true for development builds, false for production builds.
+     */
+    log?: boolean | "development";
+    /**
+     * Print warn messages when true. Default: true for development builds, false for production builds.
+     */
+    warn?: boolean | "development";
+    /**
+     * Print error messages when true. Default: true.
+     */
+    error?: boolean | "development";
+};
+type DebugHubOptions = DebugOptions & {
+    crashCollector: CrashCollector;
+    mode: "development" | "production";
+};
+export interface DebugChannelOptions {
+    name: string;
+}
+export interface DebugChannel {
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}
+/**
+ * The central trunk from which all channels branch.
+ * Changing the filter here determines what kind of messages are printed across the app.
+ */
+export declare class DebugHub {
+    #private;
+    constructor(options: DebugHubOptions, _console?: any);
+    /**
+     * Returns a debug channel labelled by `name`. Used for logging from components.
+     */
+    channel(options: DebugChannelOptions): DebugChannel;
+    get filter(): string | RegExp;
+    set filter(pattern: string | RegExp);
+}
+/**
+ * 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 makeMatcher(pattern: string | RegExp): (value: string) => boolean;
+export {};

package/lib/index.d.ts

@@ -0,0 +1,23 @@
+export { makeApp } from "./app.js";
+export { spring } from "./spring.js";
+export { readable, writable, computed, proxy, observe, unwrap, isReadable, isWritable } from "./state.js";
+export { m, cond, repeat, portal } from "./markup.js";
+export { Fragment } from "./views/fragment.js";
+export { StoreScope } from "./views/store-scope.js";
+export type { DialogProps } from "./stores/dialog.js";
+export type { StoreScopeProps } from "./views/store-scope.js";
+export type { Spring } from "./spring.js";
+export type { Readable, Writable } from "./state.js";
+export type { ViewContext } from "./view.js";
+export type { StoreContext } from "./store.js";
+export type { Markup } from "./markup.js";
+export type { HTTPMiddleware } from "./stores/http.js";
+export type { InputType } from "./types.js";
+import type { IntrinsicElements as Elements } from "./types";
+declare global {
+    namespace JSX {
+        interface IntrinsicElements extends Elements {
+            [tag: string]: any;
+        }
+    }
+}