@trypattern/sdk 0.0.0-stage → 0.1.1

package/dist/auth/sessionApi.js

@@ -0,0 +1,158 @@
+import { adminEmails } from "../access.js";
+import { MemoryServer } from "../memoryApi.js";
+import { ownerIdOf } from "../table.js";
+import { USER_COOKIE, userSchema } from "./user.js";
+export const sessionCalls = [
+    'me',
+    'devSignIn',
+    'sendEmailCode',
+    'verifyEmailCode',
+    'signOut'
+];
+const MEMORY_EMAIL_CODE = '123456';
+const JSON_HEADERS = { 'content-type': 'application/json' };
+export class HttpSessionApi {
+    #gate;
+    #signedOutListeners = new Set();
+    constructor(gate) {
+        this.#gate = gate;
+    }
+    rememberedUser() {
+        const prefix = `${USER_COOKIE}=`;
+        const cookie = document.cookie
+            .split('; ')
+            .find((part) => part.startsWith(prefix));
+        if (cookie === undefined)
+            return undefined;
+        try {
+            const json = JSON.parse(decodeURIComponent(cookie.slice(prefix.length)));
+            const parsed = userSchema.safeParse(json);
+            return parsed.success ? parsed.data : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    me() {
+        return this.#gate.pass('session.me', async () => {
+            const response = await fetch('/api/me');
+            if (response.status === 401)
+                return undefined;
+            if (!response.ok)
+                throw new Error('session.me failed');
+            return userSchema.parse(await response.json());
+        });
+    }
+    devSignIn(email) {
+        return this.#gate.pass('session.devSignIn', async () => {
+            const response = await fetch('/api/auth/dev-sign-in', {
+                method: 'POST',
+                headers: JSON_HEADERS,
+                body: JSON.stringify({ email })
+            });
+            if (!response.ok)
+                throw new Error('session.devSignIn failed');
+            return userSchema.parse(await response.json());
+        });
+    }
+    sendEmailCode(email) {
+        return this.#gate.pass('session.sendEmailCode', async () => {
+            const response = await fetch('/api/auth/email', {
+                method: 'POST',
+                headers: JSON_HEADERS,
+                body: JSON.stringify({ email })
+            });
+            return response.ok ? 'sent' : 'refused';
+        });
+    }
+    verifyEmailCode(code) {
+        return this.#gate.pass('session.verifyEmailCode', async () => {
+            const response = await fetch('/api/auth/email/verify', {
+                method: 'POST',
+                headers: JSON_HEADERS,
+                body: JSON.stringify({ code })
+            });
+            if (response.status === 401)
+                return undefined;
+            if (!response.ok)
+                throw new Error('session.verifyEmailCode failed');
+            return userSchema.parse(await response.json());
+        });
+    }
+    signOut() {
+        return this.#gate.pass('session.signOut', async () => {
+            await fetch('/api/auth/sign-out', { method: 'POST' });
+        });
+    }
+    startGoogleSignIn() {
+        location.assign('/api/auth/google');
+    }
+    onSignedOut(listener) {
+        this.#signedOutListeners.add(listener);
+    }
+    reportSignedOut() {
+        for (const listener of this.#signedOutListeners)
+            listener();
+    }
+}
+function devUser(email, admins) {
+    const name = email.split('@')[0] ?? email;
+    return {
+        id: ownerIdOf(email),
+        email,
+        name,
+        avatarUrl: null,
+        isAdmin: admins.has(email.toLowerCase())
+    };
+}
+export class MemorySessionApi {
+    #server;
+    #admins;
+    #user;
+    #emailCodeFor;
+    constructor(signedInAs, admins, options) {
+        this.#server = new MemoryServer('session', options);
+        this.#admins = adminEmails(admins);
+        this.#user =
+            signedInAs === null ? undefined : devUser(signedInAs, this.#admins);
+    }
+    rememberedUser() {
+        return this.#user;
+    }
+    me() {
+        return this.#server.reply('me', () => this.#user);
+    }
+    devSignIn(email) {
+        return this.#server.reply('devSignIn', () => {
+            this.#user = devUser(email, this.#admins);
+            return this.#user;
+        });
+    }
+    sendEmailCode(email) {
+        return this.#server.reply('sendEmailCode', () => {
+            this.#emailCodeFor = email;
+            return 'sent';
+        });
+    }
+    verifyEmailCode(code) {
+        return this.#server.reply('verifyEmailCode', () => {
+            if (this.#emailCodeFor === undefined || code !== MEMORY_EMAIL_CODE) {
+                return undefined;
+            }
+            this.#user = devUser(this.#emailCodeFor, this.#admins);
+            this.#emailCodeFor = undefined;
+            return this.#user;
+        });
+    }
+    signOut() {
+        return this.#server.reply('signOut', () => {
+            this.#user = undefined;
+        });
+    }
+    startGoogleSignIn() {
+        return undefined;
+    }
+    onSignedOut() {
+        return undefined;
+    }
+}

package/dist/auth/sessionStore.d.ts

@@ -0,0 +1,20 @@
+import { StoreBase } from '../store.ts';
+import type { EmailCodeOutcome, SessionApi } from './sessionApi.ts';
+import type { User } from './user.ts';
+export type SessionState = {
+    user: User | null;
+};
+export declare class SessionStore extends StoreBase<SessionState, {
+    api: SessionApi;
+}> {
+    constructor(deps: {
+        api: SessionApi;
+    });
+    protected initialState(): SessionState;
+    confirm(): Promise<void>;
+    devSignIn(email: string): Promise<void>;
+    sendEmailCode(email: string): Promise<EmailCodeOutcome>;
+    verifyEmailCode(code: string): Promise<boolean>;
+    continueWithGoogle(): void;
+    signOut(): Promise<void>;
+}

package/dist/auth/sessionStore.js

@@ -0,0 +1,40 @@
+import { StoreBase } from "../store.js";
+export class SessionStore extends StoreBase {
+    constructor(deps) {
+        super(deps);
+        deps.api.onSignedOut(() => void this.confirm());
+    }
+    initialState() {
+        return { user: this.deps.api.rememberedUser() ?? null };
+    }
+    async confirm() {
+        if (this.state.user === null)
+            return;
+        try {
+            this.set({ user: (await this.deps.api.me()) ?? null });
+        }
+        catch {
+            return;
+        }
+    }
+    async devSignIn(email) {
+        this.set({ user: await this.deps.api.devSignIn(email) });
+    }
+    sendEmailCode(email) {
+        return this.deps.api.sendEmailCode(email);
+    }
+    async verifyEmailCode(code) {
+        const user = await this.deps.api.verifyEmailCode(code);
+        if (user === undefined)
+            return false;
+        this.set({ user });
+        return true;
+    }
+    continueWithGoogle() {
+        this.deps.api.startGoogleSignIn();
+    }
+    async signOut() {
+        this.set({ user: null });
+        await this.deps.api.signOut();
+    }
+}

package/dist/auth/user.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const userSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodString;
+    name: z.ZodString;
+    avatarUrl: z.ZodNullable<z.ZodString>;
+    isAdmin: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type User = z.output<typeof userSchema>;
+export type StoredUser = Omit<User, 'isAdmin'>;
+export declare const USER_COOKIE = "pattern_user";

package/dist/auth/user.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const userSchema = z.object({
+    id: z.string(),
+    email: z.string(),
+    name: z.string(),
+    avatarUrl: z.string().nullable(),
+    isAdmin: z.boolean().default(false)
+});
+export const USER_COOKIE = 'pattern_user';

package/dist/builtins/Account.d.ts

@@ -0,0 +1,25 @@
+declare const Account_base: import("../model.ts").ModelClass<import("../registered.ts").AppStores, import("../registered.ts").ModelServices, {
+    appearance: import("zod").ZodDefault<import("zod").ZodEnum<{
+        system: "system";
+        light: "light";
+        dark: "dark";
+    }>>;
+}, readonly ["appearance"]>;
+export declare class Account extends Account_base {
+    get user(): {
+        id: string;
+        email: string;
+        name: string;
+        avatarUrl: string | null;
+        isAdmin: boolean;
+    } | null;
+    setAppearance: import("../model.ts").Command<{
+        appearance: import("zod").ZodEnum<{
+            system: "system";
+            light: "light";
+            dark: "dark";
+        }>;
+    }, void>;
+    signOut: import("../model.ts").Command<{}, Promise<void>>;
+}
+export {};

package/dist/builtins/Account.js

@@ -0,0 +1,15 @@
+import { appearance } from "../appearance.js";
+import { command } from "../model.js";
+import { Model } from "../registered.js";
+export class Account extends Model({
+    state: { appearance: appearance.default('system') },
+    persist: ['appearance']
+}) {
+    get user() {
+        return this.stores.session.state.user;
+    }
+    setAppearance = command({ input: { appearance } }, ({ appearance }) => {
+        this.set({ appearance });
+    });
+    signOut = command(() => this.stores.session.signOut());
+}

package/dist/builtins/AppSettings.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+declare const AppSettings_base: import("../model.ts").ModelClass<import("../registered.ts").AppStores, import("../registered.ts").ModelServices, {
+    isRenaming: z.ZodDefault<z.ZodBoolean>;
+}, []>;
+export declare class AppSettings extends AppSettings_base {
+    get title(): string;
+    get canRename(): boolean;
+    rename: import("../model.ts").Command<{
+        title: z.ZodString;
+    }, Promise<void>>;
+}
+export {};

package/dist/builtins/AppSettings.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { appTitle } from "../appTitle.js";
+import { command } from "../model.js";
+import { Model } from "../registered.js";
+export class AppSettings extends Model({
+    state: { isRenaming: z.boolean().default(false) }
+}) {
+    get title() {
+        return this.stores.app.state.title;
+    }
+    get canRename() {
+        return this.stores.session.state.user?.isAdmin === true;
+    }
+    rename = command({ input: { title: appTitle } }, async ({ title }) => {
+        this.set({ isRenaming: true });
+        try {
+            await this.stores.app.rename(title);
+            this.stores.toasts.show({ tone: 'success', title: 'Name saved' });
+        }
+        catch {
+            this.stores.toasts.show({
+                tone: 'error',
+                title: 'Couldn’t save the name',
+                description: 'Check your connection and try again.'
+            });
+        }
+        finally {
+            this.set({ isRenaming: false });
+        }
+    });
+}

package/dist/builtins/Palette.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import type { AppAction } from '../registered.ts';
+declare const Palette_base: import("../model.ts").ModelClass<import("../registered.ts").AppStores, import("../registered.ts").ModelServices, {
+    isOpen: z.ZodDefault<z.ZodBoolean>;
+    query: z.ZodDefault<z.ZodString>;
+    highlightedId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, []>;
+export declare class Palette extends Palette_base {
+    get results(): AppAction[];
+    get highlighted(): string | null;
+    open: import("../model.ts").Command<{}, void>;
+    close: import("../model.ts").Command<{}, void>;
+    toggle: import("../model.ts").Command<{}, void>;
+    setQuery: import("../model.ts").Command<{
+        query: z.ZodString;
+    }, void>;
+    highlight: import("../model.ts").Command<{
+        id: z.ZodString;
+    }, void>;
+    moveHighlight: import("../model.ts").Command<{
+        by: z.ZodNumber;
+    }, void>;
+    submit: import("../model.ts").Command<{}, Promise<void> | undefined>;
+    run: import("../model.ts").Command<{
+        id: z.ZodString;
+    }, Promise<void> | undefined>;
+    private runAction;
+}
+export {};

package/dist/builtins/Palette.js

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { rankActions } from "../actions.js";
+import { command } from "../model.js";
+import { Model } from "../registered.js";
+export class Palette extends Model({
+    state: {
+        isOpen: z.boolean().default(false),
+        query: z.string().default(''),
+        highlightedId: z.string().nullable().default(null)
+    }
+}) {
+    get results() {
+        return rankActions(this.stores.actions.state.items, this.state.query);
+    }
+    get highlighted() {
+        const { highlightedId } = this.state;
+        const { results } = this;
+        if (results.some((result) => result.id === highlightedId)) {
+            return highlightedId;
+        }
+        return results[0]?.id ?? null;
+    }
+    open = command(() => {
+        this.set({ isOpen: true, query: '', highlightedId: null });
+    });
+    close = command(() => {
+        this.set({ isOpen: false });
+    });
+    toggle = command(() => {
+        if (this.state.isOpen)
+            this.close();
+        else
+            this.open();
+    });
+    setQuery = command({ input: { query: z.string() } }, ({ query }) => {
+        this.set({ query, highlightedId: null });
+    });
+    highlight = command({ input: { id: z.string() } }, ({ id }) => {
+        if (this.results.some((result) => result.id === id)) {
+            this.set({ highlightedId: id });
+        }
+    });
+    moveHighlight = command({ input: { by: z.number().int() } }, ({ by }) => {
+        const { results } = this;
+        if (results.length === 0)
+            return;
+        const index = results.findIndex((result) => result.id === this.highlighted);
+        const next = (((index + by) % results.length) + results.length) % results.length;
+        this.set({ highlightedId: results[next]?.id ?? null });
+    });
+    submit = command(() => {
+        const chosen = this.results.find((result) => result.id === this.highlighted);
+        return chosen === undefined ? undefined : this.runAction(chosen);
+    });
+    run = command({ input: { id: z.string() } }, ({ id }) => {
+        const chosen = this.results.find((result) => result.id === id);
+        return chosen === undefined ? undefined : this.runAction(chosen);
+    });
+    async runAction(chosen) {
+        this.close();
+        await this.stores.actions.run(chosen);
+    }
+}

package/dist/builtins/SignIn.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+declare const SignIn_base: import("../model.ts").ModelClass<import("../registered.ts").AppStores, import("../registered.ts").ModelServices, {
+    step: z.ZodDefault<z.ZodEnum<{
+        code: "code";
+        choose: "choose";
+    }>>;
+    email: z.ZodDefault<z.ZodString>;
+    signingIn: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        email: "email";
+        google: "google";
+        dev: "dev";
+    }>>>;
+    notice: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, []>;
+export declare class SignIn extends SignIn_base {
+    continueWithGoogle: import("../model.ts").Command<{}, void>;
+    sendEmailCode: import("../model.ts").Command<{
+        email: z.ZodEmail;
+    }, Promise<void>>;
+    verifyEmailCode: import("../model.ts").Command<{
+        code: z.ZodString;
+    }, Promise<void>>;
+    startOver: import("../model.ts").Command<{}, void>;
+    signInAsDevUser: import("../model.ts").Command<{
+        email: z.ZodEmail;
+    }, Promise<void>>;
+}
+export {};

package/dist/builtins/SignIn.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { command } from "../model.js";
+import { Model } from "../registered.js";
+export class SignIn extends Model({
+    state: {
+        step: z.enum(['choose', 'code']).default('choose'),
+        email: z.string().default(''),
+        signingIn: z.enum(['google', 'email', 'dev']).nullable().default(null),
+        notice: z.string().nullable().default(null)
+    }
+}) {
+    continueWithGoogle = command(() => {
+        this.set({ signingIn: 'google', notice: null });
+        this.stores.session.continueWithGoogle();
+    });
+    sendEmailCode = command({ input: { email: z.email() } }, async ({ email }) => {
+        this.set({ signingIn: 'email', notice: null });
+        try {
+            const outcome = await this.stores.session.sendEmailCode(email);
+            this.set(outcome === 'sent'
+                ? { signingIn: null, step: 'code', email }
+                : {
+                    signingIn: null,
+                    notice: `Couldn’t send a code to ${email}. Try again in a few minutes.`
+                });
+        }
+        catch {
+            this.set({ signingIn: null, notice: UNREACHABLE });
+        }
+    });
+    verifyEmailCode = command({ input: { code: z.string() } }, async ({ code }) => {
+        this.set({ signingIn: 'email', notice: null });
+        try {
+            const isSignedIn = await this.stores.session.verifyEmailCode(code);
+            this.set(isSignedIn
+                ? { signingIn: null, step: 'choose', email: '' }
+                : { signingIn: null, notice: 'That code is wrong or has expired.' });
+        }
+        catch {
+            this.set({ signingIn: null, notice: UNREACHABLE });
+        }
+    });
+    startOver = command(() => {
+        this.set({ step: 'choose', email: '', signingIn: null, notice: null });
+    });
+    signInAsDevUser = command({ input: { email: z.email() } }, async ({ email }) => {
+        this.set({ signingIn: 'dev', notice: null });
+        try {
+            await this.stores.session.devSignIn(email);
+            this.set({ signingIn: null });
+        }
+        catch {
+            this.set({
+                signingIn: null,
+                notice: `Couldn’t sign in as ${email}. Is the dev server running?`
+            });
+        }
+    });
+}
+const UNREACHABLE = 'Couldn’t reach the server. Check your connection and try again.';

package/dist/builtins/Toasts.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+declare const toast: z.ZodObject<{
+    id: z.ZodString;
+    tone: z.ZodEnum<{
+        success: "success";
+        error: "error";
+        neutral: "neutral";
+    }>;
+    title: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type Toast = z.output<typeof toast>;
+type ToastInput = Pick<Toast, 'tone' | 'title'> & {
+    description?: string;
+};
+declare const Toasts_base: import("../store.ts").StoreClass<{
+    items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tone: z.ZodEnum<{
+            success: "success";
+            error: "error";
+            neutral: "neutral";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+}, [], Record<never, never>>;
+export declare class Toasts extends Toasts_base {
+    show({ description, ...shown }: ToastInput): void;
+    dismiss(id: string): void;
+}
+export {};

package/dist/builtins/Toasts.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { defineStore } from "../store.js";
+const Store = defineStore();
+const toast = z.object({
+    id: z.string(),
+    tone: z.enum(['neutral', 'success', 'error']),
+    title: z.string(),
+    description: z.string().nullable()
+});
+const TOAST_MS = 4000;
+export class Toasts extends Store({
+    state: { items: z.array(toast).default([]) }
+}) {
+    show({ description, ...shown }) {
+        const id = crypto.randomUUID();
+        const added = { id, description: description ?? null, ...shown };
+        this.set({ items: [...this.state.items, added] });
+        setTimeout(() => this.dismiss(id), TOAST_MS);
+    }
+    dismiss(id) {
+        const items = this.state.items.filter((item) => item.id !== id);
+        if (items.length !== this.state.items.length)
+            this.set({ items });
+    }
+}

package/dist/builtins/actions.d.ts

@@ -0,0 +1,2 @@
+export declare const BUILT_IN_GROUPS: readonly ["Preferences", "Account"];
+export declare const builtInActions: import("../actions.ts").ActionsBuilder<import("../registered.ts").ActionContext, import("../registered.ts").AppAction>[];

package/dist/builtins/actions.js

@@ -0,0 +1,45 @@
+import { appearance } from "../appearance.js";
+import { action, defineActions } from "../registered.js";
+export const BUILT_IN_GROUPS = ['Preferences', 'Account'];
+const appearanceEntries = {
+    system: { label: 'Match the system appearance', icon: 'monitor' },
+    light: { label: 'Switch to light appearance', icon: 'sun' },
+    dark: { label: 'Switch to dark appearance', icon: 'moon' }
+};
+const paletteActions = defineActions(() => [
+    action({
+        id: 'palette.toggle',
+        label: 'Open command menu',
+        group: 'Preferences',
+        icon: 'search',
+        keys: ['mod+k'],
+        isHidden: true,
+        send: [{ type: 'palette.toggle' }]
+    })
+]);
+const appearanceActions = defineActions(({ models }) => appearance.options
+    .filter((option) => option !== models.account.appearance)
+    .map((option) => action({
+    id: `appearance.${option}`,
+    label: appearanceEntries[option].label,
+    group: 'Preferences',
+    icon: appearanceEntries[option].icon,
+    keywords: 'theme mode color scheme',
+    send: [{ type: 'account.setAppearance', appearance: option }]
+})));
+const accountActions = defineActions(({ models }) => [
+    models.account.user !== null &&
+        action({
+            id: 'account.signOut',
+            label: 'Log out',
+            group: 'Account',
+            icon: 'logOut',
+            keywords: 'sign out',
+            send: [{ type: 'account.signOut' }]
+        })
+]);
+export const builtInActions = [
+    paletteActions,
+    appearanceActions,
+    accountActions
+];

package/dist/cache.d.ts

@@ -0,0 +1,24 @@
+import type { z } from 'zod';
+import type { Persisted } from './state.ts';
+export type CacheStorage = {
+    get: (key: string) => string | undefined;
+    set: (key: string, value: string) => void;
+    keys: () => readonly string[];
+    remove: (key: string) => void;
+};
+export type CacheKey = string | (() => string);
+export declare class Cached<Value> {
+    #private;
+    constructor(storage: CacheStorage, key: CacheKey, schema: z.ZodType<Value>);
+    read(): Value | undefined;
+    write(value: Value): void;
+}
+export declare class Cache {
+    #private;
+    constructor(storage: CacheStorage);
+    static local(): Cache;
+    static memory(): Cache;
+    scope<Value>(key: CacheKey, schema: z.ZodType<Value>): Cached<Value>;
+    persisted(model: string): Persisted;
+    clear(): void;
+}