@trypattern/sdk 0.0.0-stage → 0.1.0

package/dist/server/users.d.ts

@@ -0,0 +1,189 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import type { StoredUser } from '../auth/user.ts';
+export declare const users: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "users";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "users";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        email: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "email";
+            tableName: "users";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "name";
+            tableName: "users";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        avatarUrl: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "avatar_url";
+            tableName: "users";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "users";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export declare const userColumns: {
+    id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "id";
+        tableName: "users";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: true;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: number | undefined;
+    }>;
+    email: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "email";
+        tableName: "users";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: number | undefined;
+    }>;
+    name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "name";
+        tableName: "users";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: number | undefined;
+    }>;
+    avatarUrl: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "avatar_url";
+        tableName: "users";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: number | undefined;
+    }>;
+};
+export declare function findUser(d1: D1Database, id: string): Promise<StoredUser | undefined>;
+export type SignedInPerson = {
+    email: string;
+    name: string | null;
+    avatarUrl: string | null;
+};
+export declare function saveUser(d1: D1Database, person: SignedInPerson): Promise<StoredUser>;

package/dist/server/users.js

@@ -0,0 +1,49 @@
+import { eq, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/d1';
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+export const users = sqliteTable('users', {
+    id: text('id').primaryKey(),
+    email: text('email').notNull().unique(),
+    name: text('name').notNull(),
+    avatarUrl: text('avatar_url'),
+    createdAt: text('created_at')
+        .notNull()
+        .default(sql `(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`)
+});
+export const userColumns = {
+    id: users.id,
+    email: users.email,
+    name: users.name,
+    avatarUrl: users.avatarUrl
+};
+export async function findUser(d1, id) {
+    return drizzle(d1)
+        .select(userColumns)
+        .from(users)
+        .where(eq(users.id, id))
+        .get();
+}
+function nameFromEmail(email) {
+    const local = email.split('@')[0] ?? email;
+    return local.charAt(0).toUpperCase() + local.slice(1);
+}
+export async function saveUser(d1, person) {
+    const email = person.email.toLowerCase();
+    return drizzle(d1)
+        .insert(users)
+        .values({
+        id: crypto.randomUUID(),
+        email,
+        name: person.name ?? nameFromEmail(email),
+        avatarUrl: person.avatarUrl
+    })
+        .onConflictDoUpdate({
+        target: users.email,
+        set: {
+            name: person.name === null ? sql `${users.name}` : sql `excluded.name`,
+            avatarUrl: sql `coalesce(excluded.avatar_url, ${users.avatarUrl})`
+        }
+    })
+        .returning(userColumns)
+        .get();
+}

package/dist/shortcuts.d.ts

@@ -0,0 +1,3 @@
+type PressKey = (key: string) => Promise<void> | undefined;
+export declare function useShortcuts(pressKey: PressKey): void;
+export {};

package/dist/shortcuts.js

@@ -0,0 +1,40 @@
+import { useEffect } from 'react';
+const MODIFIER_KEYS = new Set(['Shift', 'Meta', 'Control', 'Alt', 'CapsLock']);
+const OWNS_KEYS = 'input, textarea, select, [contenteditable], [role=menu], [role=listbox], [role=dialog]';
+function isApplePlatform() {
+    if (typeof navigator === 'undefined')
+        return false;
+    return /Mac|iPhone|iPad/.test(navigator.userAgent);
+}
+function isOwnedByControl(target) {
+    return target instanceof Element && target.closest(OWNS_KEYS) !== null;
+}
+function shortcutOf(event) {
+    if (event.defaultPrevented || event.isComposing)
+        return undefined;
+    const hasMod = isApplePlatform() ? event.metaKey : event.ctrlKey;
+    if (hasMod && !event.altKey)
+        return `mod+${event.key.toLowerCase()}`;
+    if (event.metaKey || event.ctrlKey || event.altKey || event.repeat) {
+        return undefined;
+    }
+    if (MODIFIER_KEYS.has(event.key) || isOwnedByControl(event.target)) {
+        return undefined;
+    }
+    return event.key;
+}
+export function useShortcuts(pressKey) {
+    useEffect(() => {
+        const onKeyDown = (event) => {
+            const shortcut = shortcutOf(event);
+            if (shortcut === undefined)
+                return;
+            const ran = pressKey(shortcut);
+            if (ran !== undefined && shortcut.startsWith('mod+')) {
+                event.preventDefault();
+            }
+        };
+        window.addEventListener('keydown', onKeyDown);
+        return () => window.removeEventListener('keydown', onKeyDown);
+    }, [pressKey]);
+}

package/dist/start.d.ts

@@ -0,0 +1,20 @@
+import type { Theme } from '@stylexjs/stylex';
+import './theme/reset.css';
+import type { AppClass, RunningApp } from './app.ts';
+import type { IconDrawing } from './components/icons.ts';
+import type { Interaction } from './components/interaction.ts';
+import type { ReactApp } from './hooks/appContext.ts';
+import type { Tables } from './table.ts';
+import { borders, colors, controls, fontSizes, fonts, iconSizes, lineHeights, radii, shadows, space, widths } from './theme/tokens.stylex.ts';
+type Themeable = typeof colors | typeof radii | typeof fonts | typeof shadows | typeof space | typeof fontSizes | typeof lineHeights | typeof controls | typeof iconSizes | typeof borders | typeof widths;
+export type StartOptions = {
+    theme?: readonly Theme<Themeable>[];
+    icons?: Readonly<Record<string, IconDrawing>>;
+    onInteraction?: (interaction: Interaction) => void;
+};
+type AnyRunningApp = RunningApp<unknown, {
+    readonly path: string;
+}>;
+type RenderableApp = AnyRunningApp & ReactApp;
+export declare function startApp<Group extends Tables, Instance extends RenderableApp>(App: AppClass<Group, Instance>, { theme, icons, onInteraction }?: StartOptions): Instance;
+export {};

package/dist/start.js

@@ -0,0 +1,121 @@
+import * as stylex from '@stylexjs/stylex';
+import { StrictMode, createElement } from 'react';
+import { createRoot } from 'react-dom/client';
+import { createBrowserRouter } from 'react-router';
+import { RouterProvider } from 'react-router/dom';
+import './theme/reset.css';
+import { browserApi } from "./api.js";
+import { Cache } from "./cache.js";
+import { setAppIcons } from "./components/icons.js";
+import { setInteractionSink } from "./components/interaction.js";
+import { Gate } from "./gate.js";
+import { AppProvider } from "./hooks/appContext.js";
+import { routeObjects } from "./routes.js";
+import { borders, breakpoints, colors, controls, fontFeatures, fontSizes, fontWeights, fonts, iconSizes, lineHeights, radii, shadows, space, widths } from "./theme/tokens.stylex.js";
+const TEST_SEED = 'patternSeed';
+const TEST_ADMINS = 'patternAdmins';
+function testSeed() {
+    const seed = Reflect.get(window, TEST_SEED);
+    return typeof seed === 'object' && seed !== null ? seed : {};
+}
+function testAdmins() {
+    const admins = Reflect.get(window, TEST_ADMINS);
+    return Array.isArray(admins)
+        ? admins.filter((email) => typeof email === 'string')
+        : [];
+}
+export function startApp(App, { theme = [], icons = {}, onInteraction } = {}) {
+    setAppIcons(icons);
+    document.body.className = stylex.props(base.body, theme).className ?? '';
+    const hot = import.meta.hot;
+    const testParams = new URLSearchParams(hot ? location.search : '');
+    const gate = new Gate(testParams.getAll('fail'));
+    for (const call of testParams.getAll('hold'))
+        gate.hold(call);
+    const { tables, routes } = App.definition;
+    const inMemory = testParams.has('memory');
+    const router = createBrowserRouter(routeObjects(routes));
+    const app = new App(router, {
+        api: browserApi(tables, inMemory ? testSeed() : {}, gate, {
+            inMemory,
+            admins: inMemory ? testAdmins() : []
+        }),
+        cache: Cache.local(),
+        gate
+    });
+    if (hot)
+        exposeToDevTools(app, gate, hot);
+    followAppearance(app);
+    if (onInteraction !== undefined) {
+        setInteractionSink((interaction) => onInteraction({
+            ...interaction,
+            page: app.router.state.matches.at(-1)?.route.id ?? null
+        }));
+    }
+    const root = document.getElementById('root');
+    if (root === null)
+        throw new Error('index.html needs a <div id="root">');
+    createRoot(root).render(createElement(StrictMode, null, createElement(AppProvider, {
+        app,
+        children: createElement(RouterProvider, { router: app.router })
+    })));
+    return app;
+}
+function followAppearance(app) {
+    const account = app.models.account;
+    const apply = () => {
+        const { appearance } = account.currentState;
+        document.documentElement.style.colorScheme =
+            appearance === 'system' ? 'light dark' : appearance;
+    };
+    account.subscribe(apply);
+    apply();
+}
+function exposeToDevTools(app, gate, hot) {
+    async function snapshotWhenIdle() {
+        await app.whenIdle();
+        return app.getSnapshot();
+    }
+    function dispatch(raw) {
+        const command = app.parse(raw);
+        if (typeof command === 'object' && command !== null && 'error' in command) {
+            return { error: String(command.error) };
+        }
+        void app.send(command);
+        return { ok: true };
+    }
+    Object.assign(window, {
+        pattern: {
+            send: dispatch,
+            snapshot: snapshotWhenIdle,
+            hold: (call) => gate.hold(call),
+            release: (call) => gate.release(call)
+        }
+    });
+    if (navigator.webdriver)
+        return;
+    hot.on('pattern:command', async (message) => {
+        const sent = dispatch(message.command);
+        hot.send('pattern:reply', {
+            id: message.id,
+            ...('error' in sent ? sent : { snapshot: await snapshotWhenIdle() })
+        });
+    });
+}
+const base = stylex.create({
+    body: {
+        fontFamily: fonts.sans,
+        fontSize: {
+            default: fontSizes.bodySm,
+            [breakpoints.compact]: fontSizes.bodyBase
+        },
+        fontWeight: fontWeights.normal,
+        fontFeatureSettings: fontFeatures.sans,
+        lineHeight: {
+            default: lineHeights.bodySm,
+            [breakpoints.compact]: lineHeights.body
+        },
+        color: colors.primaryForeground,
+        backgroundColor: colors.shell
+    }
+});

package/dist/state.d.ts

@@ -0,0 +1,14 @@
+import type { z } from 'zod';
+export type Json = string | number | boolean | null | readonly Json[] | {
+    readonly [key: string]: Json;
+};
+export type StateSpec = Record<string, z.ZodDefault<z.ZodType<Json>>>;
+export type StateOf<Spec extends StateSpec> = {
+    [Key in keyof Spec]: z.output<Spec[Key]>;
+};
+export type Persisted = {
+    read: (key: string) => unknown;
+    write: (key: string, value: unknown) => void;
+};
+export declare function defaultsOf<Spec extends StateSpec>(spec: Spec): StateOf<Spec>;
+export declare function restore<Spec extends StateSpec>(spec: Spec, persist: readonly (keyof Spec & string)[], device: Persisted): StateOf<Spec>;

package/dist/state.js

@@ -0,0 +1,17 @@
+export function defaultsOf(spec) {
+    const entries = Object.entries(spec).map(([key, schema]) => [
+        key,
+        schema.parse(undefined)
+    ]);
+    return Object.fromEntries(entries);
+}
+export function restore(spec, persist, device) {
+    const state = defaultsOf(spec);
+    for (const key of persist) {
+        const parsed = spec[key]?.safeParse(device.read(key));
+        if (parsed?.success) {
+            state[key] = parsed.data;
+        }
+    }
+    return state;
+}

package/dist/store.d.ts

@@ -0,0 +1,43 @@
+import type { Persisted, StateOf, StateSpec } from './state.ts';
+export declare function isDevelopment(): boolean;
+export declare function plainJsonProblem(value: unknown, path: string): string | undefined;
+export declare function keepEqualParts<Value>(previous: unknown, next: Value): Value;
+export type Reads = Map<StoreBase<object, unknown>, Map<string, unknown>>;
+export declare function tracked<Value>(run: () => Value): {
+    value: Value;
+    reads: Reads;
+};
+export declare function mergeReads(from: Reads): void;
+export declare function readsAreCurrent(reads: Reads): boolean;
+export declare function whileBuilding<Value>(run: () => Value): Value;
+export declare function assertNotBuilding(what: string): void;
+export declare abstract class StoreBase<State extends object, Deps = undefined> {
+    #private;
+    protected readonly deps: Deps;
+    constructor(...args: Deps extends undefined ? [] : [deps: Deps]);
+    protected abstract initialState(): State;
+    get state(): State;
+    get currentState(): State;
+    readonly subscribe: (listener: () => void) => (() => void);
+    protected set(patch: Partial<State>): void;
+    protected changed(): void;
+}
+export type StoreConfig<S extends StateSpec, P extends readonly (keyof S & string)[]> = {
+    state?: S;
+    persist?: P;
+};
+export declare abstract class DeclaredStore<State extends object> extends StoreBase<State> {
+    protected initialState(): State;
+}
+export type StoreClass<S extends StateSpec, P extends readonly (keyof S & string)[]> = (abstract new (persisted: Persisted) => DeclaredStore<StateOf<S>>) & {
+    readonly config: StoreConfig<S, P>;
+};
+export declare function Store<S extends StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config: StoreConfig<S, P>): StoreClass<S, P>;
+export type Snapshots<Group> = {
+    [Key in keyof Group]: Group[Key] extends {
+        readonly state: infer State;
+    } ? State : never;
+};
+export declare function snapshotsOf<Group extends Record<string, {
+    readonly state: object;
+}>>(group: Group): Snapshots<Group>;