@primate/core 0.1.10 → 0.2.1

package/lib/private/client/spa/index.js

@@ -0,0 +1,192 @@
+import storage from "#client/spa/storage";
+const APPLICATION_JSON = "application/json";
+const MULTIPART_FORM_DATA = "multipart/form-data";
+const { document } = globalThis;
+const headers = {
+    Accept: APPLICATION_JSON,
+};
+const get_by_id_or_name = (name) => document.getElementById(name) ?? document.getElementsByName(name)[0];
+const scroll = globalThis.scrollTo;
+const scroll_hash = (hash) => {
+    if (hash === "") {
+        scroll(0, 0);
+    }
+    else {
+        // https://html.spec.whatwg.org/browsing-the-web.html#scroll-to-fragid
+        // first try id, then name
+        get_by_id_or_name(hash.slice(1)).scrollIntoView();
+    }
+};
+const sameorigin = (url) => url.origin === globalThis.location.origin;
+const getLocation = (response, base) => {
+    // only readable when not opaqueredirect
+    if (response.type === "opaqueredirect")
+        return null;
+    const location = response.headers.get("Location");
+    return location ? new URL(location, base) : null;
+};
+// Follows same-origin redirects in "manual" mode up to a small limit
+async function refetch(input, init = {}, maxHops = 5) {
+    let url = new URL(input.toString(), globalThis.location.href);
+    let hops = 0;
+    while (hops < maxHops) {
+        const response = await fetch(url.pathname + url.search, {
+            ...init, redirect: "manual",
+        });
+        // cross-origin redirect -> bail
+        if (response.type === "opaqueredirect") {
+            return { requested: url, response: response };
+        }
+        // same-origin redirect we can see?
+        const location = getLocation(response, url.toString());
+        if (location && (response.status >= 300 && response.status < 400)) {
+            // would go cross-origin -> bail
+            if (!sameorigin(location))
+                return { requested: url, response: response };
+            // follow internally without touching history
+            url = location;
+            hops++;
+            continue;
+        }
+        // not a redirect -> return it
+        return { requested: url, response };
+    }
+    throw new Error("Too many redirects");
+}
+function is_json(response) {
+    const raw = response.headers.get("content-type") || "";
+    const mime = raw.split(";")[0].trim();
+    return mime === APPLICATION_JSON;
+}
+;
+const handle = async (response, updater) => {
+    // if it's JSON, process SPA update and keep history under our control
+    if (is_json(response)) {
+        updater(await response.json());
+        return true; // handled in SPA
+    }
+    // not JSON ⇒ we will hard-navigate outside the SPA
+    return false;
+};
+const goto = async ({ hash, pathname }, updater, state = false) => {
+    try {
+        // save before loading next
+        const { scrollTop } = globalThis.document.scrollingElement;
+        const { hash: currentHash, pathname: currentPathname } = globalThis.location;
+        const { requested, response } = await refetch(pathname, { headers });
+        if (await handle(response, updater)) {
+            if (state) {
+                storage.new({ hash: currentHash, pathname: currentPathname, scrollTop });
+                const url = response.redirected ? response.url : `${pathname}${hash}`;
+                history.pushState({}, "", url);
+            }
+            return;
+        }
+        const target = (response.type !== "opaqueredirect")
+            ? requested.toString() + hash
+            : new URL(pathname + hash, globalThis.location.href).toString();
+        globalThis.location.assign(target);
+    }
+    catch (error) {
+        console.warn(error);
+    }
+};
+const submit = async (pathname, body, method, updater) => {
+    try {
+        const { requested, response } = await refetch(pathname, { body, headers, method });
+        if (await handle(response, updater)) {
+            history.replaceState({}, "", requested.pathname + requested.search);
+            return;
+        }
+        const target = (response.type !== "opaqueredirect")
+            ? requested.toString()
+            : new URL(pathname, globalThis.location.href).toString();
+        globalThis.location.assign(target);
+    }
+    catch (error) {
+        console.warn(error);
+    }
+};
+const go = async (href, updater, event) => {
+    const url = new URL(href);
+    const { hash, pathname } = url;
+    const current = globalThis.location.pathname;
+    // hosts must match
+    if (url.host === globalThis.location.host) {
+        // prevent event
+        event?.preventDefault();
+        // pathname differs
+        if (current !== pathname) {
+            await goto(url, props => updater(props, () => {
+                scroll_hash(hash);
+                globalThis.dispatchEvent(new Event("updated"));
+            }), true);
+        }
+        // different hash on same page, jump to hash
+        if (hash !== globalThis.location.hash) {
+            const { scrollTop } = globalThis.document.scrollingElement;
+            storage.new({
+                hash: globalThis.location.hash,
+                pathname: current,
+                scrollTop,
+                stop: true,
+            });
+            history.pushState(null, "", `${current}${hash}`);
+            scroll_hash(hash);
+        }
+    }
+    // external redirect
+};
+export default (updater) => {
+    globalThis.addEventListener("load", _ => {
+        history.scrollRestoration = "manual";
+        if (globalThis.location.hash !== "") {
+            scroll_hash(globalThis.location.hash);
+        }
+    });
+    globalThis.addEventListener("beforeunload", _ => {
+        history.scrollRestoration = "auto";
+    });
+    globalThis.addEventListener("popstate", _ => {
+        const state = storage.peek() ?? { scrollTop: 0 };
+        const { pathname } = globalThis.location;
+        let { scrollTop } = state;
+        if (state.stop) {
+            storage.back();
+            if (state.hash) {
+                scroll_hash(state.hash);
+            }
+            else {
+                scroll(0, state.scrollTop);
+            }
+            return;
+        }
+        const back = state.pathname === pathname;
+        if (back) {
+            storage.back();
+        }
+        else {
+            scrollTop = storage.forward().scrollTop;
+        }
+        goto(globalThis.location, props => updater(props, () => scroll(0, scrollTop ?? 0)));
+    });
+    globalThis.addEventListener("click", event => {
+        const target = event.target.closest("a");
+        if (target?.tagName === "A" && target.href !== "") {
+            go(target.href, updater, event);
+        }
+    });
+    globalThis.addEventListener("submit", (event) => {
+        event.preventDefault();
+        const target = event.target;
+        const { enctype } = target;
+        const action = target.action ?? globalThis.location.pathname;
+        const url = new URL(action);
+        const data = new FormData(target);
+        const form = enctype === MULTIPART_FORM_DATA
+            ? data
+            : new URLSearchParams(data);
+        submit(url.pathname, form, target.method, updater);
+    });
+};
+//# sourceMappingURL=index.js.map

package/lib/private/client/spa/storage.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    back(): any;
+    forward(): any;
+    get(): any;
+    name: string;
+    "new"(entry: any): void;
+    peek(): any;
+    set(item: any): void;
+    storage: Storage;
+};
+export default _default;
+//# sourceMappingURL=storage.d.ts.map

package/lib/private/client/spa/storage.js

@@ -0,0 +1,54 @@
+const global = globalThis;
+const last = -1;
+const scrollTop = () => global.document.scrollingElement.scrollTop;
+export default {
+    // going back in the history
+    back() {
+        const { next = [], old = [], stack = [] } = this.get();
+        const top = stack.at(last);
+        this.set({
+            // place the current scrolling state in next
+            next: [...next, { scrollTop: scrollTop() }],
+            // add the top of the stack to old
+            old: [...old, top],
+            // remove top of stack
+            stack: stack.slice(0, last),
+        });
+        return top;
+    },
+    // going forward in the history
+    forward() {
+        const { next = [], old = [], stack = [] } = this.get();
+        this.set({
+            // remove top of next
+            next: next.slice(0, last),
+            // remove top of old
+            old: old.slice(0, last),
+            // add the top of old to stack, with current scrollTop
+            stack: [...stack, { ...old.at(last), scrollTop: scrollTop() }],
+        });
+        return next.at(last);
+    },
+    get() {
+        return JSON.parse(this.storage.getItem(this.name)) ?? [];
+    },
+    name: "$$primate$$",
+    // placing a new item into the history
+    new(entry) {
+        const { stack = [] } = this.get();
+        this.set({
+            next: [],
+            // pushing a new entry invalidates all old and next items
+            old: [],
+            stack: [...stack, entry],
+        });
+    },
+    peek() {
+        return this.get().stack.at(last);
+    },
+    set(item) {
+        this.storage.setItem(this.name, JSON.stringify(item));
+    },
+    storage: global.sessionStorage,
+};
+//# sourceMappingURL=storage.js.map

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

@@ -0,0 +1,17 @@
+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";
+type Options<T> = {
+    headers?: Dict<string>;
+    map?: (v: T) => JSONValue;
+    path?: JSONPointer;
+};
+export default function toValidated<T, R>(validateSignal: (init: ValidateInit<T>) => R): (initial: T) => {
+    delete: (url: string, options?: Options<T>) => R;
+    patch: (url: string, options?: Options<T>) => R;
+    post: (url: string, options?: Options<T>) => R;
+    put: (url: string, options?: Options<T>) => R;
+};
+export {};
+//# sourceMappingURL=toValidated.d.ts.map

package/lib/private/client/toValidated.js

@@ -0,0 +1,21 @@
+export default function toValidated(validateSignal) {
+    return (initial) => {
+        const verb = (method) => (url, options) => {
+            return validateSignal({
+                headers: options?.headers,
+                initial,
+                map: options?.map,
+                method,
+                path: options?.path,
+                url,
+            });
+        };
+        return {
+            delete: verb("DELETE"),
+            patch: verb("PATCH"),
+            post: verb("POST"),
+            put: verb("PUT"),
+        };
+    };
+}
+//# sourceMappingURL=toValidated.js.map

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

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

package/lib/private/client/validate.js

@@ -0,0 +1,54 @@
+function extract(payload, defaultPath) {
+    // scalar: { message, messages }
+    if ("messages" in payload) {
+        return payload.messages.map(m => ({ message: m, path: defaultPath }));
+    }
+    // keyed: { "/field": { message, messages }, ... }
+    const issues = [];
+    for (const [path, bundle] of Object.entries(payload)) {
+        for (const message of bundle.messages) {
+            issues.push({ message, path: path });
+        }
+    }
+    return 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 validate(init, value) {
+    const headers = {
+        "content-type": "application/json",
+        ...(init.headers ?? {}),
+    };
+    if (init.path !== undefined) {
+        headers["x-validate-path"] = init.path;
+    }
+    const bodyValue = init.map?.(value) ?? value;
+    let body;
+    try {
+        body = JSON.stringify(bodyValue);
+    }
+    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 defaultPath = init.path ?? "";
+    const defaultIssues = [{ message: "Validation failed", path: defaultPath }];
+    const allIssues = extract(payload, defaultPath);
+    const focusedIssues = focus(allIssues, init.path);
+    const issues = focusedIssues.length > 0 ? focusedIssues : defaultIssues;
+    throw Object.assign(new Error(issues[0].message), {
+        issues,
+        name: "ValidationError",
+    });
+}
+//# sourceMappingURL=validate.js.map

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

@@ -0,0 +1,4 @@
+import type schema from "#config/schema";
+type Config = typeof schema.infer;
+export type { Config as default };
+//# sourceMappingURL=Config.d.ts.map

package/lib/private/config/Config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Config.js.map

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

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=app.d.ts.map

package/lib/private/config/config/app.js

@@ -0,0 +1,3 @@
+import config from "primate/config";
+export default config();
+//# sourceMappingURL=app.js.map

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

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/private/config/config/database/index.js

@@ -0,0 +1,3 @@
+import DefaultDatabase from "primate/database/default";
+export default new DefaultDatabase();
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=session.d.ts.map

package/lib/private/config/config/session.js

@@ -0,0 +1,3 @@
+import session from "primate/config/session";
+export default session();
+//# sourceMappingURL=session.js.map

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

@@ -0,0 +1,25 @@
+import schema from "#config/schema";
+declare const _default: (config?: typeof schema.input) => {
+    build: Record<string, unknown> | undefined;
+    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;
+        };
+    };
+    modules: import("../Module.js").default[] | undefined;
+    request: {
+        body: {
+            parse: boolean;
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/private/config/index.js

@@ -0,0 +1,3 @@
+import schema from "#config/schema";
+export default (config = {}) => schema.parse(config);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,26 @@
+import Module from "#Module";
+import FileRef from "@rcompat/fs/FileRef";
+declare const _default: import("pema").ObjectType<{
+    build: import("pema").OptionalType<import("pema/record").RecordType<import("pema/string").StringType, import("pema/unknown").UnknownType>>;
+    http: import("pema").ObjectType<{
+        csp: import("pema").OptionalType<import("pema/record").RecordType<import("pema/string").StringType, import("pema/array").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/constructor").ConstructorType<typeof FileRef>, import("pema/string").StringType]>>;
+            key: import("pema").OptionalType<import("pema/union").UnionType<[import("pema/constructor").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/array").ArrayType<import("pema/constructor").ConstructorType<typeof Module>>>;
+    request: import("pema").ObjectType<{
+        body: import("pema").ObjectType<{
+            parse: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
+        }>;
+    }>;
+}>;
+export default _default;
+//# sourceMappingURL=schema.d.ts.map

package/lib/private/config/schema.js

@@ -0,0 +1,34 @@
+import Module from "#Module";
+import FileRef from "@rcompat/fs/FileRef";
+import pema from "pema";
+import array from "pema/array";
+import boolean from "pema/boolean";
+import constructor from "pema/constructor";
+import record from "pema/record";
+import string from "pema/string";
+import uint from "pema/uint";
+import union from "pema/union";
+import unknown from "pema/unknown";
+export default pema({
+    build: record(string, unknown).optional(),
+    http: {
+        csp: record(string, array(string)).optional(),
+        headers: record(string, string).optional(),
+        host: string.default("localhost"),
+        port: uint.port().default(6161),
+        ssl: {
+            cert: union(FileRef, string).optional(),
+            key: union(FileRef, string).optional(),
+        },
+        static: {
+            root: string.default("/"),
+        },
+    },
+    modules: array(constructor(Module)).optional(),
+    request: {
+        body: {
+            parse: boolean.default(true),
+        },
+    },
+});
+//# sourceMappingURL=schema.js.map

package/lib/private/cookie.d.ts

@@ -0,0 +1,11 @@
+declare const Schema: import("pema").ObjectType<{
+    httpOnly: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
+    path: import("pema").DefaultType<import("pema/string").StringType, "/">;
+    sameSite: import("pema/union").UnionType<[import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">, import("pema").LiteralType<"Strict">]>;
+    secure: import("pema/boolean").BooleanType;
+    maxAge: import("pema").OptionalType<import("pema/number").NumberType<"f64">>;
+}>;
+type Options = typeof Schema.input;
+export default function cookie(name: string, value: string, options: Options): string;
+export {};
+//# sourceMappingURL=cookie.d.ts.map

package/lib/private/cookie.js

@@ -0,0 +1,30 @@
+import is from "@rcompat/assert/is";
+import pema from "pema";
+import boolean from "pema/boolean";
+import number from "pema/number";
+import string from "pema/string";
+import union from "pema/union";
+const Schema = pema({
+    httpOnly: boolean.default(true),
+    path: string.default("/"),
+    sameSite: union("Lax", "None", "Strict"),
+    secure: boolean,
+    maxAge: number.optional(), // seconds
+});
+export default function cookie(name, value, options) {
+    is(name).string();
+    is(value).string();
+    const parsed = Schema.parse(options);
+    const parts = [`${name}=${value}`];
+    parts.push(`Path=${parsed.path}`);
+    parts.push(`SameSite=${parsed.sameSite}`);
+    if (parsed.maxAge !== undefined)
+        parts.push(`Max-Age=${parsed.maxAge}`);
+    if (parsed.httpOnly)
+        parts.push("HttpOnly");
+    if (parsed.secure && parsed.sameSite !== "None")
+        parts.push("Secure");
+    return parts.join("; ");
+}
+;
+//# sourceMappingURL=cookie.js.map

package/lib/private/database/As.d.ts

@@ -0,0 +1,7 @@
+import type Types from "#database/Types";
+type As = {
+    name: string;
+    types: Types;
+};
+export type { As as default };
+//# sourceMappingURL=As.d.ts.map

package/lib/private/database/As.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=As.js.map

package/lib/private/database/Binds.d.ts

@@ -0,0 +1,4 @@
+import type Dict from "@rcompat/type/Dict";
+type Binds = Dict;
+export type { Binds as default };
+//# sourceMappingURL=Binds.d.ts.map

package/lib/private/database/Binds.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Binds.js.map

package/lib/private/database/Changes.d.ts

@@ -0,0 +1,11 @@
+import type InferStore from "pema/InferStore";
+import type StoreSchema from "pema/StoreSchema";
+type X<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type OrNull<T> = {
+    [P in keyof T]?: null | T[P];
+};
+type Changes<T extends StoreSchema> = X<OrNull<InferStore<T>>>;
+export type { Changes as default };
+//# sourceMappingURL=Changes.d.ts.map

package/lib/private/database/Changes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Changes.js.map

package/lib/private/database/ColumnTypes.d.ts

@@ -0,0 +1,11 @@
+type ColumnTypes = {
+    BIGINT: bigint;
+    BLOB: Blob;
+    BOOLEAN: boolean;
+    DATE: Date;
+    NUMBER: number;
+    STRING: string;
+    URL: URL;
+};
+export type { ColumnTypes as default };
+//# sourceMappingURL=ColumnTypes.d.ts.map

package/lib/private/database/ColumnTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ColumnTypes.js.map

package/lib/private/database/DataDict.d.ts

@@ -0,0 +1,5 @@
+import type Dict from "@rcompat/type/Dict";
+import type DataValue from "#database/DataValue";
+type DataDict = Dict<DataValue>;
+export type { DataDict as default };
+//# sourceMappingURL=DataDict.d.ts.map

package/lib/private/database/DataDict.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DataDict.js.map

package/lib/private/database/DataKey.d.ts

@@ -0,0 +1,4 @@
+import type DataType from "pema/DataType";
+type DataKey = keyof DataType;
+export type { DataKey as default };
+//# sourceMappingURL=DataKey.d.ts.map

package/lib/private/database/DataKey.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DataKey.js.map

package/lib/private/database/DataRecord.d.ts

@@ -0,0 +1,8 @@
+import type InferStoreOut from "pema/InferStoreOut";
+import type StoreSchema from "pema/StoreSchema";
+type X<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type DataRecord<T extends StoreSchema> = X<InferStoreOut<T>>;
+export type { DataRecord as default };
+//# sourceMappingURL=DataRecord.d.ts.map

package/lib/private/database/DataRecord.js

@@ -0,0 +1,3 @@
+;
+export {};
+//# sourceMappingURL=DataRecord.js.map

package/lib/private/database/DataValue.d.ts

@@ -0,0 +1,5 @@
+import type DataKey from "#database/DataKey";
+import type DataType from "pema/DataType";
+type DataValue = DataType[DataKey] | null;
+export type { DataValue as default };
+//# sourceMappingURL=DataValue.d.ts.map

package/lib/private/database/DataValue.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DataValue.js.map