@trypattern/sdk 0.0.0-stage → 0.1.0

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>>>;
+}, []>;
+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,24 @@
+import { z } from 'zod';
+import { Store } from "../store.js";
+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;
+}

package/dist/cache.js

@@ -0,0 +1,112 @@
+const PREFIX = 'pattern:';
+export class Cached {
+    #storage;
+    #key;
+    #schema;
+    constructor(storage, key, schema) {
+        this.#storage = storage;
+        this.#key = key;
+        this.#schema = schema;
+    }
+    get #fullKey() {
+        return PREFIX + (typeof this.#key === 'string' ? this.#key : this.#key());
+    }
+    read() {
+        try {
+            const text = this.#storage.get(this.#fullKey);
+            if (text === undefined)
+                return undefined;
+            const parsed = this.#schema.safeParse(JSON.parse(text));
+            return parsed.success ? parsed.data : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    write(value) {
+        try {
+            this.#storage.set(this.#fullKey, JSON.stringify(value));
+        }
+        catch {
+            return;
+        }
+    }
+}
+export class Cache {
+    #storage;
+    constructor(storage) {
+        this.#storage = storage;
+    }
+    static local() {
+        return new Cache(new LocalStorage());
+    }
+    static memory() {
+        return new Cache(new MemoryStorage());
+    }
+    scope(key, schema) {
+        return new Cached(this.#storage, key, schema);
+    }
+    persisted(model) {
+        const storage = this.#storage;
+        const keyOf = (key) => `${PREFIX}${model}.${key}`;
+        return {
+            read(key) {
+                try {
+                    const text = storage.get(keyOf(key));
+                    return text === undefined ? undefined : JSON.parse(text);
+                }
+                catch {
+                    return undefined;
+                }
+            },
+            write(key, value) {
+                try {
+                    storage.set(keyOf(key), JSON.stringify(value));
+                }
+                catch {
+                    return;
+                }
+            }
+        };
+    }
+    clear() {
+        try {
+            for (const key of this.#storage.keys()) {
+                if (key.startsWith(PREFIX))
+                    this.#storage.remove(key);
+            }
+        }
+        catch {
+            return;
+        }
+    }
+}
+class LocalStorage {
+    get(key) {
+        return localStorage.getItem(key) ?? undefined;
+    }
+    set(key, value) {
+        localStorage.setItem(key, value);
+    }
+    keys() {
+        return Array.from({ length: localStorage.length }, (_, index) => localStorage.key(index)).filter((key) => key !== null);
+    }
+    remove(key) {
+        localStorage.removeItem(key);
+    }
+}
+class MemoryStorage {
+    #entries = new Map();
+    get(key) {
+        return this.#entries.get(key);
+    }
+    set(key, value) {
+        this.#entries.set(key, value);
+    }
+    keys() {
+        return [...this.#entries.keys()];
+    }
+    remove(key) {
+        this.#entries.delete(key);
+    }
+}

package/dist/cli/app.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};