@manyducks.co/dolla 0.67.0

package/lib/stores/language.d.ts

@@ -0,0 +1,39 @@
+import { type Readable } from "../state.js";
+import { type StoreContext } from "../store.js";
+import { type Stringable } from "../types.js";
+/**
+ * An object where values are either a translated string or another nested Translation object.
+ */
+type Translation = Record<string, string | Record<string, string | Record<string, string | Record<string, string>>>>;
+export interface LanguageConfig {
+    /**
+     * The translated strings for this language, or a callback function that returns them.
+     */
+    translation: Translation | (() => Translation) | (() => Promise<Translation>);
+}
+type LanguageOptions = {
+    /**
+     * Languages supported by the app (as added with App.language())
+     */
+    languages: {
+        [tag: string]: LanguageConfig;
+    };
+    /**
+     * Default language to load on startup
+     */
+    currentLanguage?: string;
+};
+export declare function LanguageStore(ctx: StoreContext<LanguageOptions>): {
+    $isLoaded: Readable<boolean>;
+    $currentLanguage: Readable<string | undefined>;
+    supportedLanguages: string[];
+    setLanguage(tag: string): Promise<void>;
+    /**
+     * Returns a Readable of the translated value.
+
+     * @param key - Key to the translated value.
+     * @param values - A map of {{placeholder}} names and the values to replace them with.
+     */
+    translate(key: string, values?: Record<string, Stringable | Readable<Stringable>>): Readable<string>;
+};
+export {};

package/lib/stores/render.d.ts

@@ -0,0 +1,18 @@
+import { type StoreContext } from "../store.js";
+/**
+ * Batches DOM updates for better performance.
+ */
+export declare function RenderStore(ctx: StoreContext): {
+    /**
+     * Queues a callback to run in the next render batch.
+     * Running your DOM mutations in update callbacks reduces layout thrashing.
+     * Returns a Promise that resolves once the callback has run.
+     */
+    update(callback: () => void, key?: string): Promise<void>;
+    /**
+     * Queues a callback that reads DOM information to run after the next render batch,
+     * ensuring all writes have been performed before reading.
+     * Returns a Promise that resolves once the callback has run.
+     */
+    read(callback: () => void): Promise<void>;
+};

package/lib/stores/router.d.ts

@@ -0,0 +1,118 @@
+import { type Route } from "@borf/bedrock";
+import { type History } from "history";
+import { type Stringable } from "../types.js";
+import { type Markup } from "../markup.js";
+import { type StoreContext } from "../store.js";
+export interface RouterOptions {
+    /**
+     * Use hash-based routing if true.
+     */
+    hash?: boolean;
+    /**
+     * A history object from the `history` package.
+     *
+     * @see https://www.npmjs.com/package/history
+     */
+    history?: History;
+}
+export interface RouteConfig {
+    pattern: string;
+    meta: {
+        redirect?: string | ((ctx: RedirectContext) => void);
+        pattern?: string;
+        layers?: RouteLayer[];
+    };
+}
+export interface RouteLayer {
+    id: number;
+    markup: Markup;
+}
+/**
+ * Properties passed to a redirect function.
+ */
+export interface RedirectContext {
+    /**
+     * The path as it appears in the URL bar.
+     */
+    path: string;
+    /**
+     * The pattern that this path was matched with.
+     */
+    pattern: string;
+    /**
+     * Named route params parsed from `path`.
+     */
+    params: Record<string, string | number | undefined>;
+    /**
+     * Query params parsed from `path`.
+     */
+    query: Record<string, string | number | boolean | undefined>;
+}
+interface ParsedParams {
+    [key: string]: string | number | boolean | (string | number | boolean | null)[] | null;
+}
+interface ParsedQuery extends ParsedParams {
+}
+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.
+     */
+    replace?: boolean;
+}
+interface RouterStoreOptions extends RouterOptions {
+    /**
+     * An instance of Router with the app's routes preloaded.
+     */
+    routes: Route<RouteConfig["meta"]>[];
+}
+export declare function RouterStore(ctx: StoreContext<RouterStoreOptions>): {
+    /**
+     * The currently matched route pattern, if any.
+     */
+    $pattern: import("../state.js").Readable<string | null>;
+    /**
+     * The current URL path.
+     */
+    $path: import("../state.js").Readable<string>;
+    /**
+     * The current named path params.
+     */
+    $params: import("../state.js").Readable<ParsedParams>;
+    /**
+     * The current query params. Changes to this object will be reflected in the URL.
+     */
+    $$query: import("../state.js").Writable<ParsedQuery>;
+    /**
+     * Navigate backward. Pass a number of steps to hit the back button that many times.
+     */
+    back(steps?: number): void;
+    /**
+     * 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.
+ *
+ * This is adapted from https://github.com/choojs/nanohref/blob/master/index.js
+ *
+ * @param root - Element under which to intercept link clicks
+ * @param callback - Function to call when a click event is intercepted
+ * @param _window - (optional) Override for global window object
+ */
+export declare function catchLinks(root: HTMLElement, callback: (anchor: HTMLAnchorElement) => void, _window?: Window & typeof globalThis): () => void;
+export {};

package/lib/testing/classes/MockHTTP.d.ts

@@ -0,0 +1,10 @@
+export class MockHTTP {
+    static label: string;
+    setup(ctx: any): any;
+    respond(to: any): void;
+    beforeConnect(): Promise<void>;
+    afterConnect(): void;
+    beforeDisconnect(): Promise<void>;
+    afterDisconnect(): void;
+    #private;
+}

package/lib/testing/index.d.ts

@@ -0,0 +1,4 @@
+export { wrapStore } from "./wrapStore.js";
+export { makeMockDOMNode } from "./makeMockDOMNode.js";
+export { makeMockFetch } from "./makeMockFetch.js";
+export { MockHTTP } from "./classes/MockHTTP.js";

package/lib/testing/makeMockDOMNode.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a mock DOM node for testing.
+ */
+export function makeMockDOMNode(): {
+    isDOM: boolean;
+    parentNode: null;
+    insertBefore: any;
+    removeChild: any;
+    children: never[];
+};

package/lib/testing/makeMockFetch.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Creates a `fetch`-compatible function that responds with its own mock handlers.
+ *
+ * @example
+ * import { makeMockFetch } from "woofe/testing";
+ *
+ * // Create a mock HTTP instance
+ * const fetch = makeMockFetch((on) => {
+ *   on.get("/example/route", (ctx) => {
+ *     // Respond with JSON
+ *     return {
+ *       message: "success"
+ *     }
+ *   });
+ *
+ *   on.put("/users/:id", (ctx) => {
+ *     ctx.response.status = 200;
+ *
+ *     return {
+ *       message: `user ${ctx.request.params.id} updated`
+ *     }
+ *   });
+ * });
+ *
+ * fetch("/example/route")
+ *   .then(res => res.json())
+ *   .then(json => {
+ *     console.log(json.message); // "success"
+ *   });
+ */
+export function makeMockFetch(fn: any): {
+    (url: any, options?: {}): Promise<any>;
+    mock: {
+        calls: any[];
+    };
+};

package/lib/testing/makeMockFetch.test.d.ts

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

package/lib/testing/stores/dialog.d.ts

@@ -0,0 +1,6 @@
+export class MockDialogStore {
+    static label: string;
+    setup(ctx: any): {
+        makeDialog(...args: any[]): void;
+    };
+}

package/lib/testing/stores/http.d.ts

@@ -0,0 +1,13 @@
+export class MockHTTPStore {
+    static label: string;
+    setup(ctx: any): {
+        request: () => void;
+        use: () => void;
+        get: () => void;
+        put: () => void;
+        patch: () => void;
+        post: () => void;
+        delete: () => void;
+        head: () => void;
+    };
+}

package/lib/testing/stores/page.d.ts

@@ -0,0 +1,7 @@
+export class MockPageStore {
+    static label: string;
+    setup(ctx: any): {
+        $$title: any;
+        $visibility: any;
+    };
+}

package/lib/testing/stores/router.d.ts

@@ -0,0 +1,12 @@
+export class MockRouterStore {
+    static label: string;
+    setup(ctx: any): {
+        $path: any;
+        $route: any;
+        $params: any;
+        $$query: any;
+        back(): void;
+        forward(): void;
+        navigate(): void;
+    };
+}

package/lib/testing/wrapStore.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Wraps a store in a test adapter that lets you call its lifecycle methods and access its exports.
+ * You can pass any 'stores' or 'inputs' this store relies on through the config object.
+ */
+export function wrapStore(store: any, config?: {}): Promise<{
+    exports: any;
+    teardown(): Promise<void>;
+}>;

package/lib/testing/wrapStore.test.d.ts

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