@primate/core 0.4.6 → 0.6.0

package/lib/private/client/create-form.js

@@ -0,0 +1,123 @@
+import extract_issues from "#client/extract-issues";
+import submit from "#client/submit";
+function decode_pointer_segment(segment) {
+    // decode JSON Pointer: ~1 -> /, ~0 -> ~
+    return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function pointer_to_fieldname(path) {
+    // if server didn't send a pointer, assume it's already a field name
+    if (!path.startsWith("/"))
+        return path;
+    // root pointer "" is handled before calling this
+    // "/" is not a valid root pointer, but treat as form-level
+    if (path === "/")
+        return "";
+    const segments = path.split("/").slice(1).map(decode_pointer_segment);
+    if (segments.length === 0 || segments[0] === "")
+        return "";
+    let name = segments[0];
+    for (let i = 1; i < segments.length; i++) {
+        name += `[${segments[i]}]`;
+    }
+    return name;
+}
+export default function createForm(init) {
+    const id = init.id ?? `form-${crypto.randomUUID()}`;
+    let snapshot = {
+        id,
+        submitting: false,
+        submitted: false,
+        errors: { form: [], fields: {} },
+    };
+    const subscribers = new Set();
+    function publish() {
+        for (const s of subscribers)
+            s(snapshot);
+    }
+    function setSubmitting(submitting) {
+        snapshot = { ...snapshot, submitting };
+        publish();
+    }
+    function setErrors(issues) {
+        const by_field = {};
+        const form_errors = [];
+        for (const issue of issues) {
+            const path = issue.path;
+            // no path or empty string -> form-level error
+            if (path === undefined) {
+                form_errors.push(issue.message);
+                continue;
+            }
+            const key = pointer_to_fieldname(path);
+            // if normalizes to empty (e.g. "/"), treat as form-level
+            if (key.length === 0) {
+                form_errors.push(issue.message);
+                continue;
+            }
+            (by_field[key] ??= []).push(issue.message);
+        }
+        snapshot = {
+            ...snapshot,
+            submitted: false,
+            errors: {
+                form: form_errors,
+                fields: by_field,
+            },
+        };
+        publish();
+    }
+    async function submit_form(event) {
+        if (event !== undefined) {
+            event.preventDefault();
+            event.stopPropagation();
+        }
+        const form_element = event?.currentTarget ??
+            document.getElementById(id);
+        // no form element
+        if (form_element === null)
+            return;
+        const method = init.method
+            ?? form_element.method.toUpperCase()
+            ?? "POST";
+        const url = init.url ?? form_element.action;
+        const form_data = new FormData(form_element);
+        setSubmitting(true);
+        try {
+            const response = await submit(url, form_data, method);
+            if (response.ok) {
+                // on success: clear errors, let the app decide what to do next
+                // (redirect/reload)
+                snapshot = { ...snapshot, submitted: true, errors: { form: [], fields: {} } };
+                publish();
+                return;
+            }
+            const payload = await response.json();
+            const issues = extract_issues(payload); // all issues, all paths
+            setErrors(issues);
+        }
+        catch (error) {
+            // network error
+            setErrors([{ type: "network_error", message: error.message, path: "" }]);
+        }
+        finally {
+            setSubmitting(false);
+        }
+    }
+    function subscribe(fn) {
+        subscribers.add(fn);
+        fn(snapshot); // emit current
+        return () => subscribers.delete(fn);
+    }
+    function read() {
+        return snapshot;
+    }
+    return {
+        subscribe,
+        read,
+        submit: submit_form,
+        get id() {
+            return snapshot.id;
+        },
+    };
+}
+//# sourceMappingURL=create-form.js.map

package/lib/private/client/extract-issues.d.ts

@@ -0,0 +1,4 @@
+import type { JSONPointer } from "@rcompat/type";
+import type { Issue, JSONPayload } from "pema";
+export default function extractIssues(payload: JSONPayload, defaultPath?: JSONPointer | ""): Issue[];
+//# sourceMappingURL=extract-issues.d.ts.map

package/lib/private/client/extract-issues.js

@@ -0,0 +1,21 @@
+export default function extractIssues(payload, defaultPath = "") {
+    // scalar: { message, messages }
+    if ("messages" in payload) {
+        return payload.messages.map(m => ({
+            type: payload.type,
+            message: m,
+            // for forms, defaultPath is "", but Issue.path expects a JSONPointer
+            // so we cast here; form-level errors are handled separately anyway
+            path: defaultPath,
+        }));
+    }
+    // keyed: { "/field": { message, messages }, ... }
+    const issues = [];
+    for (const [path, bundle] of Object.entries(payload)) {
+        for (const message of bundle.messages) {
+            issues.push({ type: bundle.type, message, path: path });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=extract-issues.js.map

package/lib/private/client/http.d.ts

@@ -0,0 +1,13 @@
+declare function refetch(input: string | URL, init?: RequestInit, max_hops?: number): Promise<{
+    requested: URL;
+    response: Response;
+}>;
+declare function is_json(response: Response): boolean;
+declare function submit(pathname: string, body: any, method: string): Promise<Response>;
+declare const http: {
+    refetch: typeof refetch;
+    is_json: typeof is_json;
+    submit: typeof submit;
+};
+export default http;
+//# sourceMappingURL=http.d.ts.map

package/lib/private/client/http.js

@@ -0,0 +1,57 @@
+import { MIME } from "@rcompat/http";
+const sameorigin = (url) => url.origin === globalThis.location.origin;
+const get_location = (response, base) => {
+    if (response.type === "opaqueredirect")
+        return null;
+    const location = response.headers.get("Location");
+    return location !== null ? new URL(location, base) : null;
+};
+async function refetch(input, init = {}, max_hops = 5) {
+    let url = new URL(input.toString(), globalThis.location.href);
+    const method = (init.method ?? "GET").toUpperCase();
+    let hops = 0;
+    if (method !== "GET") {
+        const response = await fetch(url.pathname + url.search, {
+            ...init, redirect: "follow",
+        });
+        return { requested: new URL(response.url), response };
+    }
+    while (hops < max_hops) {
+        const response = await fetch(url.pathname + url.search, {
+            ...init, redirect: "manual",
+        });
+        if (response.type === "opaqueredirect")
+            return { requested: url, response };
+        const location = get_location(response, url.toString());
+        if (location !== null && response.status >= 300 && response.status < 400) {
+            if (!sameorigin(location))
+                return { requested: url, response };
+            url = location;
+            hops++;
+            continue;
+        }
+        return { requested: url, response };
+    }
+    throw new Error("Too many redirects");
+}
+function is_json(response) {
+    const raw = response.headers.get("content-type") ?? "";
+    return raw.split(";")[0].trim() === MIME.APPLICATION_JSON;
+}
+async function submit(pathname, body, method) {
+    const { requested, response } = await refetch(pathname, { body, method });
+    if (is_json(response)) {
+        history.replaceState({}, "", requested.pathname + requested.search);
+    }
+    else {
+        globalThis.location.assign(requested.toString());
+    }
+    return response;
+}
+const http = {
+    refetch,
+    is_json,
+    submit,
+};
+export default http;
+//# sourceMappingURL=http.js.map

package/lib/private/client/index.d.ts

@@ -0,0 +1,23 @@
+import type { FormInit, FormView } from "#client/create-form";
+import createForm from "#client/create-form";
+import type Data from "#client/Data";
+import type Publish from "#client/Publish";
+import type Render from "#client/Render";
+import submit from "#client/submit";
+import toValidated from "#client/to-validated";
+import validateField from "#client/validate-field";
+import type ValidateInit from "#client/ValidateInit";
+import type ValidateUpdater from "#client/ValidateUpdater";
+import type ValidationError from "#client/ValidationError";
+import type ViewResponse from "#client/ViewResponse";
+declare const client: {
+    boot: <T extends import("@rcompat/type").Dict>(u: import("./root.js").Updater<T>) => void;
+    navigate: (href: string, event?: Event) => Promise<void>;
+    submit: typeof submit;
+    createForm: typeof createForm;
+    validateField: typeof validateField;
+    toValidated: typeof toValidated;
+};
+export default client;
+export type { Data, FormInit, FormView, Publish, Render, ValidateInit, ValidateUpdater, ValidationError, ViewResponse, };
+//# sourceMappingURL=index.d.ts.map

package/lib/private/client/index.js

@@ -0,0 +1,16 @@
+import boot from "#client/boot";
+import createForm from "#client/create-form";
+import navigate from "#client/navigate";
+import submit from "#client/submit";
+import toValidated from "#client/to-validated";
+import validateField from "#client/validate-field";
+const client = {
+    boot,
+    navigate: navigate.go,
+    submit,
+    createForm,
+    validateField,
+    toValidated,
+};
+export default client;
+//# sourceMappingURL=index.js.map

package/lib/private/client/navigate.d.ts

@@ -0,0 +1,13 @@
+type Location = {
+    hash: string;
+    pathname: string;
+};
+declare function goto(target: Location, state?: boolean, after?: () => void): Promise<void>;
+declare function go(href: string, event?: Event): Promise<void>;
+declare const navigate: {
+    go: typeof go;
+    goto: typeof goto;
+    scroll_hash: (hash: string) => void;
+};
+export default navigate;
+//# sourceMappingURL=navigate.d.ts.map

package/lib/private/client/navigate.js

@@ -0,0 +1,67 @@
+import http from "#client/http";
+import root from "#client/root";
+import storage from "#client/storage";
+import { MIME } from "@rcompat/http";
+const headers = {
+    Accept: MIME.APPLICATION_JSON,
+};
+const get_by_id_or_name = (name) => document.getElementById(name) ?? document.getElementsByName(name)[0];
+const scroll_hash = (hash) => {
+    if (hash === "") {
+        globalThis.scrollTo(0, 0);
+    }
+    else {
+        get_by_id_or_name(hash.slice(1)).scrollIntoView();
+    }
+};
+async function goto(target, state = false, after) {
+    try {
+        const { scrollTop } = globalThis.document.scrollingElement;
+        const { location } = globalThis;
+        const { requested, response } = await http.refetch(target.pathname, { headers });
+        if (http.is_json(response)) {
+            if (response.ok)
+                root.update(await response.json());
+            if (state) {
+                storage.new({ hash: location.hash, pathname: location.pathname, scrollTop });
+                history.pushState({}, "", `${target.pathname}${target.hash}`);
+            }
+            after?.();
+            return;
+        }
+        const dest = response.type !== "opaqueredirect"
+            ? requested.toString() + target.hash
+            : new URL(target.pathname + target.hash, location.href).toString();
+        location.assign(dest);
+    }
+    catch (error) {
+        console.warn(error);
+    }
+}
+async function go(href, event) {
+    const url = new URL(href);
+    const { hash, pathname } = url;
+    const { location } = globalThis;
+    if (url.host === location.host) {
+        event?.preventDefault();
+        if (location.pathname !== pathname) {
+            await goto(url, true, () => {
+                scroll_hash(hash);
+                globalThis.dispatchEvent(new Event("updated"));
+            });
+        }
+        if (location.hash !== hash) {
+            const { scrollTop } = globalThis.document.scrollingElement;
+            storage.new({ hash: location.hash, pathname: location.pathname, scrollTop, stop: true });
+            history.pushState(null, "", `${location.pathname}${hash}`);
+            scroll_hash(hash);
+        }
+    }
+}
+const navigate = {
+    go,
+    goto,
+    scroll_hash,
+};
+export default navigate;
+//# sourceMappingURL=navigate.js.map

package/lib/private/client/root.d.ts

@@ -0,0 +1,9 @@
+import type ClientData from "#client/Data";
+import type { Dict } from "@rcompat/type";
+export type Updater<T extends Dict> = (json: ClientData<T>, after?: () => void) => void;
+declare const root: {
+    set(updater: Updater<any>): void;
+    update(data: any, after?: () => void): void;
+};
+export default root;
+//# sourceMappingURL=root.d.ts.map

package/lib/private/client/root.js

@@ -0,0 +1,11 @@
+let current;
+const root = {
+    set(updater) {
+        current = updater;
+    },
+    update(data, after) {
+        current(data, after);
+    },
+};
+export default root;
+//# sourceMappingURL=root.js.map

package/lib/private/client/submit.d.ts

@@ -0,0 +1,2 @@
+export default function submit(pathname: string, body: any, method: string): Promise<Response>;
+//# sourceMappingURL=submit.d.ts.map

package/lib/private/client/submit.js

@@ -0,0 +1,41 @@
+import http from "#client/http";
+import root from "#client/root";
+import storage from "#client/storage";
+import { MIME } from "@rcompat/http";
+const headers = {
+    Accept: MIME.APPLICATION_JSON,
+};
+export default async function submit(pathname, body, method) {
+    const { requested, response } = await http.refetch(pathname, {
+        body, headers, method,
+    });
+    if (response.redirected) {
+        const { location, document, history } = globalThis;
+        const scrollTop = document.scrollingElement?.scrollTop ?? 0;
+        if (http.is_json(response))
+            root.update(await response.json());
+        storage.new({
+            hash: location.hash,
+            pathname: location.pathname,
+            scrollTop,
+        });
+        const url = new URL(response.url);
+        history.pushState({}, "", url.pathname + url.search);
+        return response;
+    }
+    if (http.is_json(response)) {
+        if (response.ok) {
+            root.update(await response.json());
+            history.replaceState({}, "", requested.pathname + requested.search);
+        }
+        return response;
+    }
+    if (response.status === 204)
+        return response;
+    const target = response.type !== "opaqueredirect"
+        ? requested.toString()
+        : new URL(pathname, globalThis.location.href).toString();
+    globalThis.location.assign(target);
+    return response;
+}
+//# sourceMappingURL=submit.js.map

package/lib/private/client/{toValidated.d.ts → to-validated.d.ts}

@@ -1,7 +1,5 @@
 import type ValidateInit from "#client/ValidateInit";
-import type Dict from "@rcompat/type/Dict";
-import type JSONPointer from "@rcompat/type/JSONPointer";
-import type JSONValue from "@rcompat/type/JSONValue";
+import type { Dict, JSONPointer, JSONValue } from "@rcompat/type";
 type Options<T> = {
     headers?: Dict<string>;
     map?: (v: T) => JSONValue;
@@ -14,4 +12,4 @@ export default function toValidated<T, R>(validateSignal: (init: ValidateInit<T>
     put: (url: string, options?: Options<T>) => R;
 };
 export {};
-//# sourceMappingURL=toValidated.d.ts.map
+//# sourceMappingURL=to-validated.d.ts.map

package/lib/private/client/{toValidated.js → to-validated.js}

@@ -18,4 +18,4 @@ export default function toValidated(validateSignal) {
         };
     };
 }
-//# sourceMappingURL=toValidated.js.map
+//# sourceMappingURL=to-validated.js.map

package/lib/private/client/validate-field.d.ts

@@ -0,0 +1,3 @@
+import type ValidateInit from "#client/ValidateInit";
+export default function validateField<T>(init: ValidateInit<T>, value: T): Promise<void>;
+//# sourceMappingURL=validate-field.d.ts.map

package/lib/private/client/validate-field.js

@@ -0,0 +1,41 @@
+import extract_issues from "#client/extract-issues";
+function focus(issues, path) {
+    if (path === undefined) {
+        return issues;
+    }
+    const focused = issues.filter(i => i.path === path);
+    return focused.length ? focused : issues;
+}
+export default async function validateField(init, value) {
+    const headers = {
+        "content-type": "application/json",
+        ...(init.headers ?? {}),
+    };
+    if (init.path !== undefined) {
+        headers["x-validate-path"] = init.path;
+    }
+    const body_value = init.map?.(value) ?? value;
+    let body;
+    try {
+        body = JSON.stringify(body_value);
+    }
+    catch {
+        const message = "Cannot serialize body. Provide a `map` that returns JSON.";
+        throw new Error(message);
+    }
+    const { method, url } = init;
+    const response = await fetch(url, { body, headers, method });
+    if (response.ok)
+        return;
+    const payload = await response.json();
+    const default_path = init.path ?? "";
+    const default_issues = [{ message: "Validation failed", path: default_path }];
+    const all_issues = extract_issues(payload, default_path);
+    const focused_issues = focus(all_issues, init.path);
+    const issues = focused_issues.length > 0 ? focused_issues : default_issues;
+    throw Object.assign(new Error(issues[0].message), {
+        issues,
+        name: "ValidationError",
+    });
+}
+//# sourceMappingURL=validate-field.js.map

package/lib/private/config/index.d.ts

@@ -1,24 +1,10 @@
+import type EnvSchema from "#app/EnvSchema";
+import AppFacade from "#app/Facade";
 import schema from "#config/schema";
-declare const _default: (config?: typeof schema.input) => {
-    http: {
-        csp: Record<string, string[]> | undefined;
-        headers: Record<string, string> | undefined;
-        host: string;
-        port: number;
-        ssl: {
-            cert: string | import("@rcompat/fs/FileRef").default | undefined;
-            key: string | import("@rcompat/fs/FileRef").default | undefined;
-        };
-        static: {
-            root: string;
-        };
+import type { ObjectType } from "pema";
+export default function config<P extends EnvSchema = EnvSchema>(input?: typeof schema.input & {
+    env?: {
+        schema?: ObjectType<P>;
     };
-    modules: import("../Module.js").default[] | undefined;
-    request: {
-        body: {
-            parse: boolean;
-        };
-    };
-};
-export default _default;
+}): AppFacade<P>;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/config/index.js

@@ -1,3 +1,6 @@
+import AppFacade from "#app/Facade";
 import schema from "#config/schema";
-export default (config = {}) => schema.parse(config);
+export default function config(input = {}) {
+    return new AppFacade(schema.parse(input));
+}
 //# sourceMappingURL=index.js.map

package/lib/private/config/schema.d.ts

@@ -1,25 +1,85 @@
-import Module from "#Module";
-import FileRef from "@rcompat/fs/FileRef";
-declare const _default: import("pema").ObjectType<{
-    http: import("pema").ObjectType<{
-        csp: import("pema").OptionalType<import("pema/record").RecordType<import("pema/string").StringType, import("pema").ArrayType<import("pema/string").StringType>>>;
-        headers: import("pema").OptionalType<import("pema/record").RecordType<import("pema/string").StringType, import("pema/string").StringType>>;
-        host: import("pema").DefaultType<import("pema/string").StringType, "localhost">;
-        port: import("pema").DefaultType<import("pema/uint").UintType<"u32">, 6161>;
-        ssl: import("pema").ObjectType<{
-            cert: import("pema").OptionalType<import("pema/union").UnionType<[import("pema").ConstructorType<typeof FileRef>, import("pema/string").StringType]>>;
-            key: import("pema").OptionalType<import("pema/union").UnionType<[import("pema").ConstructorType<typeof FileRef>, import("pema/string").StringType]>>;
-        }>;
-        static: import("pema").ObjectType<{
-            root: import("pema").DefaultType<import("pema/string").StringType, "/">;
-        }>;
-    }>;
-    modules: import("pema").OptionalType<import("pema").ArrayType<import("pema").ConstructorType<typeof Module>>>;
-    request: import("pema").ObjectType<{
-        body: import("pema").ObjectType<{
-            parse: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
-        }>;
-    }>;
+import type DB from "#db/DB";
+import type Module from "#Module";
+import type { Dict } from "@rcompat/type";
+import type { ObjectType, Parsed } from "pema";
+declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly http: {
+        readonly csp: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").ArrayType<import("pema").StringType>>>;
+        readonly headers: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").StringType>>;
+        readonly host: import("pema").DefaultType<import("pema").StringType, "localhost">;
+        readonly port: import("pema").DefaultType<import("pema").UintType<"u32">, 6161>;
+        readonly ssl: {
+            readonly cert: import("pema").OptionalType<import("pema").UnionType<[import("pema").IsType<import("@rcompat/fs").FileRef>, import("pema").StringType]>>;
+            readonly key: import("pema").OptionalType<import("pema").UnionType<[import("pema").IsType<import("@rcompat/fs").FileRef>, import("pema").StringType]>>;
+        };
+        readonly static: {
+            readonly root: import("pema").DefaultType<import("pema").StringType, "/">;
+        };
+    };
+    readonly livereload: {
+        readonly exclude: import("pema").OptionalType<import("pema").ArrayType<import("pema").StringType>>;
+        readonly host: import("pema").OptionalType<import("pema").StringType>;
+        readonly port: import("pema").OptionalType<import("pema").UintType<"u32">>;
+    };
+    readonly db: {
+        readonly migrations: import("pema").OptionalType<ObjectType<{
+            table: import("pema").StringType;
+            db: import("pema").PureType<DB, "PureType">;
+        }, {
+            table: string;
+            db: DB;
+        }>>;
+    };
+    readonly env: {
+        readonly schema: import("pema").OptionalType<import("pema").PureType<ObjectType<Dict<Parsed<unknown>>, {
+            [x: string]: unknown;
+        }>, "PureType">>;
+    };
+    readonly modules: import("pema").DefaultType<import("pema").ArrayType<ObjectType<{
+        name: import("pema").StringType;
+        setup: import("pema").FunctionType;
+    }, Module>>, Module[]>;
+    readonly request: {
+        readonly body: {
+            readonly parse: import("pema").DefaultType<import("pema").BooleanType, true>;
+        };
+    };
+}>, {
+    http: {
+        csp: Record<string, string[]> | undefined;
+        headers: Record<string, string> | undefined;
+        host: string;
+        port: number;
+        ssl: {
+            cert: string | import("@rcompat/fs").FileRef | undefined;
+            key: string | import("@rcompat/fs").FileRef | undefined;
+        };
+        static: {
+            root: string;
+        };
+    };
+    livereload: {
+        exclude: string[] | undefined;
+        host: string | undefined;
+        port: number | undefined;
+    };
+    db: {
+        migrations: {
+            table: string;
+            db: DB;
+        } | undefined;
+    };
+    env: {
+        schema: ObjectType<Dict<Parsed<unknown>>, {
+            [x: string]: unknown;
+        }> | undefined;
+    };
+    modules: Module[];
+    request: {
+        body: {
+            parse: boolean;
+        };
+    };
 }>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map