@trypattern/sdk 0.0.0-stage → 0.1.1

package/dist/model.js

@@ -0,0 +1,243 @@
+var _a;
+import { z } from 'zod';
+import { PageStore } from "./page.js";
+import { StoreBase, isDevelopment, keepEqualParts, mergeReads, plainJsonProblem, readsAreCurrent, tracked, whileBuilding } from "./store.js";
+import { restore } from "./state.js";
+const INPUT = Symbol('pattern.commandInput');
+export function command(first, second) {
+    const run = typeof first === 'function' ? first : second;
+    if (typeof run !== 'function')
+        throw new Error('command() needs a handler');
+    const options = typeof first === 'function' ? {} : first;
+    const shape = typeof options === 'object' && options !== null
+        ? Reflect.get(options, 'input')
+        : undefined;
+    return Object.assign((input) => run(input), {
+        [INPUT]: z.object((shape ?? {}))
+    });
+}
+export function commandFromSchema(schema, run) {
+    return Object.assign((input) => run(input), {
+        [INPUT]: schema
+    });
+}
+function isCommand(value) {
+    return typeof value === 'function' && INPUT in value;
+}
+export function commandsOf(model) {
+    const found = {};
+    for (const [name, value] of Object.entries(model)) {
+        if (isCommand(value))
+            found[name] = value[INPUT];
+    }
+    return found;
+}
+function sameEntries(previous, next) {
+    const previousKeys = Object.keys(previous);
+    const nextKeys = Object.keys(next);
+    return (previousKeys.length === nextKeys.length &&
+        nextKeys.every((key) => Object.is(Reflect.get(previous, key), Reflect.get(next, key))));
+}
+const answerNames = new WeakMap();
+export function answerNamesOf(model) {
+    return answerNames.get(model) ?? [];
+}
+function getterOf(instance, name) {
+    let prototype = Object.getPrototypeOf(instance);
+    while (prototype !== null) {
+        const getter = Object.getOwnPropertyDescriptor(prototype, name)?.get;
+        if (getter !== undefined)
+            return getter;
+        prototype = Object.getPrototypeOf(prototype);
+    }
+    return undefined;
+}
+export class ModelBase extends StoreBase {
+    stores;
+    app;
+    #memos = new Map();
+    #snapshot;
+    #published;
+    #isDirty = true;
+    constructor(stores, app) {
+        super();
+        this.stores = stores;
+        this.app = app;
+        const answers = this.#derived();
+        answerNames.set(this, answers);
+        for (const derived of answers) {
+            const compute = getterOf(this, derived);
+            if (compute === undefined)
+                continue;
+            Object.defineProperty(this, derived, {
+                configurable: true,
+                enumerable: false,
+                get: () => this.#evaluate(derived, compute)
+            });
+        }
+        for (const store of Object.values(stores)) {
+            store.subscribe(() => this.changed());
+        }
+    }
+    onPageOpen(_params) {
+        return undefined;
+    }
+    get params() {
+        const page = Reflect.get(this.stores, 'page');
+        return page instanceof PageStore ? page.state.params : {};
+    }
+    initialState() {
+        throw new Error(`${this.constructor.name} must extend Model({ state }) so its first state comes from the config`);
+    }
+    get snapshot() {
+        if (this.#snapshot === undefined || this.#isDirty) {
+            const next = this.#buildSnapshot();
+            const kept = this.#snapshot !== undefined && sameEntries(this.#snapshot, next)
+                ? this.#snapshot
+                : next;
+            if (kept !== this.#snapshot)
+                this.#published = undefined;
+            this.#snapshot = kept;
+            this.#isDirty = false;
+        }
+        return this.#snapshot;
+    }
+    get published() {
+        const snapshot = this.snapshot;
+        this.#published ??= this.#buildPublished(snapshot);
+        return this.#published;
+    }
+    changed() {
+        this.#isDirty = true;
+        const previous = this.#snapshot;
+        if (this.snapshot === previous)
+            return;
+        super.changed();
+    }
+    #evaluate(name, compute) {
+        const memo = this.#memos.get(name);
+        if (memo !== undefined && readsAreCurrent(memo.reads)) {
+            mergeReads(memo.reads);
+            return memo.value;
+        }
+        const { value, reads } = whileBuilding(() => tracked(() => compute.call(this)));
+        if (isDevelopment()) {
+            this.#checkPure(name, compute, value);
+            const problem = plainJsonProblem(value, `${name}`);
+            if (problem !== undefined) {
+                throw new Error(`${this.constructor.name} must publish plain JSON from its getters, because flows compare it: ${problem}`);
+            }
+        }
+        const kept = memo === undefined ? value : keepEqualParts(memo.value, value);
+        this.#memos.set(name, { value: kept, reads });
+        mergeReads(reads);
+        return kept;
+    }
+    #checkPure(name, compute, value) {
+        const again = whileBuilding(() => tracked(() => compute.call(this)).value);
+        if (JSON.stringify(value) !== JSON.stringify(again)) {
+            throw new Error(`${this.constructor.name}.${name} gave two different answers for the same state and stores, so it is not a pure getter. Getters must not read the clock, randomness or a private field.`);
+        }
+    }
+    #buildSnapshot() {
+        const snapshot = {
+            ...this.currentState
+        };
+        for (const name of this.#derived()) {
+            snapshot[name] = Reflect.get(this, name);
+        }
+        return snapshot;
+    }
+    #buildPublished(snapshot) {
+        const published = { ...snapshot };
+        for (const [name, value] of Object.entries(this)) {
+            if (isCommand(value))
+                published[name] = value;
+        }
+        return Object.freeze(published);
+    }
+    #derived() {
+        const names = [];
+        let prototype = Object.getPrototypeOf(this);
+        while (prototype !== null && prototype !== _a.prototype) {
+            for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(prototype))) {
+                if (descriptor.get !== undefined && !names.includes(name)) {
+                    names.push(name);
+                }
+            }
+            prototype = Object.getPrototypeOf(prototype);
+        }
+        return names;
+    }
+}
+_a = ModelBase;
+export function modelSnapshotsOf(models) {
+    return Object.fromEntries(Object.entries(models).map(([key, model]) => [key, model.snapshot]));
+}
+export function defineModel() {
+    return function Model(config = {}) {
+        const persist = config.persist ?? [];
+        class Bound extends ModelBase {
+            static config = config;
+            #device;
+            constructor(stores, app, device) {
+                super(stores, app);
+                this.#device = device;
+            }
+            initialState() {
+                return restore(config.state ?? {}, persist, this.#device);
+            }
+            set(patch) {
+                super.set(patch);
+                for (const key of persist) {
+                    if (key in patch)
+                        this.#device.write(key, this.state[key]);
+                }
+            }
+        }
+        return Bound;
+    };
+}
+export function createModels(classes, stores, services, persistedFor) {
+    const entries = Object.entries(classes).map(([key, Class]) => {
+        const create = Class;
+        return [key, new create(stores, services, persistedFor(key))];
+    });
+    return Object.fromEntries(entries);
+}
+export function splitType(type) {
+    const dot = type.indexOf('.');
+    return dot === -1
+        ? { group: '', name: type }
+        : { group: type.slice(0, dot), name: type.slice(dot + 1) };
+}
+export function parseMessage(raw, models) {
+    const specs = Object.entries(models).map(([group, model]) => [group, commandsOf(model)]);
+    const known = specs.flatMap(([group, spec]) => Object.keys(spec).map((name) => `${group}.${name}`));
+    const unknown = `Unknown command ${JSON.stringify(raw)}. Commands: ${known.join(', ')}`;
+    if (typeof raw !== 'object' || raw === null || !('type' in raw)) {
+        return { error: unknown };
+    }
+    const { type, ...input } = raw;
+    if (typeof type !== 'string')
+        return { error: unknown };
+    const { group, name } = splitType(type);
+    const schema = specs.find(([key]) => key === group)?.[1][name];
+    if (schema === undefined)
+        return { error: unknown };
+    const parsed = schema.safeParse(input);
+    if (!parsed.success) {
+        return { error: `Command ${type}: ${z.prettifyError(parsed.error)}` };
+    }
+    return { type, ...parsed.data };
+}
+export function sendMessage(models, { type, ...input }) {
+    const { group, name } = splitType(type);
+    const model = models[group];
+    const target = model === undefined ? undefined : Reflect.get(model, name);
+    if (!isCommand(target)) {
+        return Promise.reject(new Error(`Unknown command ${type}`));
+    }
+    const run = target;
+    return Promise.resolve(run(input));
+}

package/dist/page.d.ts

@@ -0,0 +1,11 @@
+import type { RouteParams } from './model.ts';
+import { StoreBase } from './store.ts';
+type PageState = {
+    page: string | null;
+    params: RouteParams;
+};
+export declare class PageStore extends StoreBase<PageState> {
+    protected initialState(): PageState;
+    moved(page: string | null, params: RouteParams): void;
+}
+export {};

package/dist/page.js

@@ -0,0 +1,9 @@
+import { StoreBase } from "./store.js";
+export class PageStore extends StoreBase {
+    initialState() {
+        return { page: null, params: {} };
+    }
+    moved(page, params) {
+        this.set({ page, params });
+    }
+}

package/dist/platform.d.ts

@@ -0,0 +1 @@
+export declare function isApplePlatform(): boolean;

package/dist/platform.js

@@ -0,0 +1,5 @@
+export function isApplePlatform() {
+    if (typeof navigator === 'undefined')
+        return false;
+    return /Mac|iPhone|iPad/.test(navigator.userAgent);
+}

package/dist/publishWire.d.ts

@@ -0,0 +1,271 @@
+import { z } from 'zod';
+import { appTitle } from './appTitle.ts';
+export { appTitle };
+export declare const DASHBOARD_URL = "https://onpattern.app";
+export declare const APPS_DOMAIN = "onpattern.app";
+export declare const UPLOAD_LIMIT_BYTES: number;
+export declare const UPLOAD_LIMIT_PARTS = 5000;
+export declare function nameProblem(name: string): string | undefined;
+export declare const appName: z.ZodString;
+export declare function hostnameOf(name: string): string;
+export declare function isPrivatePath(path: string): boolean;
+export declare function sourcePathProblem(path: string): string | undefined;
+export declare const UPLOAD: {
+    readonly worker: "worker/";
+    readonly client: "client/";
+    readonly migrations: "migrations/";
+    readonly source: "source/";
+    readonly compatibilityDate: "compatibilityDate";
+    readonly sdkVersion: "sdkVersion";
+};
+export declare const publishStep: z.ZodEnum<{
+    publish: "publish";
+    reserve: "reserve";
+    database: "database";
+    "sign-in": "sign-in";
+}>;
+export type PublishStep = z.output<typeof publishStep>;
+export declare const publishStatus: z.ZodEnum<{
+    failed: "failed";
+    running: "running";
+    live: "live";
+}>;
+export declare const publishSummary: z.ZodObject<{
+    number: z.ZodNumber;
+    status: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        live: "live";
+    }>;
+    step: z.ZodEnum<{
+        publish: "publish";
+        reserve: "reserve";
+        database: "database";
+        "sign-in": "sign-in";
+    }>;
+    error: z.ZodNullable<z.ZodString>;
+    byEmail: z.ZodString;
+    restoredFrom: z.ZodNullable<z.ZodNumber>;
+    isStarter: z.ZodBoolean;
+    startedAt: z.ZodString;
+    finishedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type PublishSummary = z.output<typeof publishSummary>;
+export declare const appSummary: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodString;
+    url: z.ZodString;
+    pulledAt: z.ZodNullable<z.ZodString>;
+    latest: z.ZodNullable<z.ZodObject<{
+        number: z.ZodNumber;
+        status: z.ZodEnum<{
+            failed: "failed";
+            running: "running";
+            live: "live";
+        }>;
+        step: z.ZodEnum<{
+            publish: "publish";
+            reserve: "reserve";
+            database: "database";
+            "sign-in": "sign-in";
+        }>;
+        error: z.ZodNullable<z.ZodString>;
+        byEmail: z.ZodString;
+        restoredFrom: z.ZodNullable<z.ZodNumber>;
+        isStarter: z.ZodBoolean;
+        startedAt: z.ZodString;
+        finishedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AppSummary = z.output<typeof appSummary>;
+export declare const nameSuggestion: z.ZodObject<{
+    name: z.ZodString;
+    available: z.ZodBoolean;
+    problem: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type NameSuggestion = z.output<typeof nameSuggestion>;
+export declare const loginStarted: z.ZodObject<{
+    secret: z.ZodString;
+    code: z.ZodString;
+    url: z.ZodString;
+}, z.core.$strip>;
+export declare const loginPoll: z.ZodUnion<readonly [z.ZodObject<{
+    status: z.ZodLiteral<"waiting">;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"approved">;
+    cookie: z.ZodString;
+}, z.core.$strip>]>;
+export declare const loginToApprove: z.ZodObject<{
+    code: z.ZodString;
+    label: z.ZodString;
+}, z.core.$strip>;
+export declare const publishServices: {
+    readonly apps: {
+        readonly list: NoInfer<import("./services.ts").ServiceCall<"/apps", {}, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            title: z.ZodString;
+            url: z.ZodString;
+            pulledAt: z.ZodNullable<z.ZodString>;
+            latest: z.ZodNullable<z.ZodObject<{
+                number: z.ZodNumber;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    running: "running";
+                    live: "live";
+                }>;
+                step: z.ZodEnum<{
+                    publish: "publish";
+                    reserve: "reserve";
+                    database: "database";
+                    "sign-in": "sign-in";
+                }>;
+                error: z.ZodNullable<z.ZodString>;
+                byEmail: z.ZodString;
+                restoredFrom: z.ZodNullable<z.ZodNumber>;
+                isStarter: z.ZodBoolean;
+                startedAt: z.ZodString;
+                finishedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>>;
+        readonly read: NoInfer<import("./services.ts").ServiceCall<"/apps/:name", {}, z.ZodObject<{
+            name: z.ZodString;
+            title: z.ZodString;
+            url: z.ZodString;
+            pulledAt: z.ZodNullable<z.ZodString>;
+            latest: z.ZodNullable<z.ZodObject<{
+                number: z.ZodNumber;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    running: "running";
+                    live: "live";
+                }>;
+                step: z.ZodEnum<{
+                    publish: "publish";
+                    reserve: "reserve";
+                    database: "database";
+                    "sign-in": "sign-in";
+                }>;
+                error: z.ZodNullable<z.ZodString>;
+                byEmail: z.ZodString;
+                restoredFrom: z.ZodNullable<z.ZodNumber>;
+                isStarter: z.ZodBoolean;
+                startedAt: z.ZodString;
+                finishedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        readonly create: NoInfer<import("./services.ts").ServiceCall<"/apps", {
+            name: z.ZodString;
+            title: z.ZodString;
+        }, z.ZodObject<{
+            name: z.ZodString;
+            title: z.ZodString;
+            url: z.ZodString;
+            pulledAt: z.ZodNullable<z.ZodString>;
+            latest: z.ZodNullable<z.ZodObject<{
+                number: z.ZodNumber;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    running: "running";
+                    live: "live";
+                }>;
+                step: z.ZodEnum<{
+                    publish: "publish";
+                    reserve: "reserve";
+                    database: "database";
+                    "sign-in": "sign-in";
+                }>;
+                error: z.ZodNullable<z.ZodString>;
+                byEmail: z.ZodString;
+                restoredFrom: z.ZodNullable<z.ZodNumber>;
+                isStarter: z.ZodBoolean;
+                startedAt: z.ZodString;
+                finishedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    };
+    readonly names: {
+        readonly suggest: NoInfer<import("./services.ts").ServiceCall<"/names", {
+            title: z.ZodString;
+        }, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            available: z.ZodBoolean;
+            problem: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>>;
+        readonly check: NoInfer<import("./services.ts").ServiceCall<"/names/:name", {}, z.ZodObject<{
+            name: z.ZodString;
+            available: z.ZodBoolean;
+            problem: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    };
+    readonly publishes: {
+        readonly list: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/publishes", {}, z.ZodArray<z.ZodObject<{
+            number: z.ZodNumber;
+            status: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                live: "live";
+            }>;
+            step: z.ZodEnum<{
+                publish: "publish";
+                reserve: "reserve";
+                database: "database";
+                "sign-in": "sign-in";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+            byEmail: z.ZodString;
+            restoredFrom: z.ZodNullable<z.ZodNumber>;
+            isStarter: z.ZodBoolean;
+            startedAt: z.ZodString;
+            finishedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>>;
+        readonly read: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/publishes/:number", {}, z.ZodObject<{
+            number: z.ZodNumber;
+            status: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                live: "live";
+            }>;
+            step: z.ZodEnum<{
+                publish: "publish";
+                reserve: "reserve";
+                database: "database";
+                "sign-in": "sign-in";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+            byEmail: z.ZodString;
+            restoredFrom: z.ZodNullable<z.ZodNumber>;
+            isStarter: z.ZodBoolean;
+            startedAt: z.ZodString;
+            finishedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+        readonly retry: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/publishes/:number/retry", {}, z.ZodObject<{
+            number: z.ZodNumber;
+            status: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                live: "live";
+            }>;
+            step: z.ZodEnum<{
+                publish: "publish";
+                reserve: "reserve";
+                database: "database";
+                "sign-in": "sign-in";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+            byEmail: z.ZodString;
+            restoredFrom: z.ZodNullable<z.ZodNumber>;
+            isStarter: z.ZodBoolean;
+            startedAt: z.ZodString;
+            finishedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    };
+    readonly logins: {
+        readonly read: NoInfer<import("./services.ts").ServiceCall<"/cli/logins/:approval", {}, z.ZodObject<{
+            code: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>>>;
+        readonly approve: NoInfer<import("./services.ts").ServiceCall<"/cli/logins/:approval/approve", {}, z.ZodObject<{
+            ok: z.ZodBoolean;
+        }, z.core.$strip>>>;
+    };
+};