@happyvertical/smrt-planner 0.0.0-stage → 0.0.1

package/dist/kitchen/client.js

@@ -0,0 +1,109 @@
+/**
+ * Send to kitchen: the hand-off to `smrt kitchen`, the CLI that serves this
+ * app on localhost and turns the cookbook into a project. The CLI announces
+ * itself in `planner.config.json` with where to send, and in the address it
+ * opens with the one-time token, as a fragment (`fragment.ts`):
+ *
+ *   planner.config.json  { "kitchen": { "endpoint": "/api/kitchen/cookbook" } }
+ *   address              http://127.0.0.1:<port>/#kitchen=<token>
+ *
+ * The config never carries a token (any local process sending the right Host
+ * header could read it); a `token` in the file is ignored (and reported, see
+ * `tokenInConfig`). The page POSTs the
+ * cookbook to the endpoint with the token in `x-kitchen-token`. Wire contract,
+ * version 1:
+ *
+ * - `200 { ok: true, dir, mode, installed, added, nextSteps }`: the project
+ *   was written (`mode` is `new` or `update`).
+ * - `4xx/5xx { ok: false, errors: string[] }`: the cookbook was not applied;
+ *   the server keeps listening, so the visitor can fix it and send again.
+ */
+import { serializeCookbook } from "../cookbook/file.js";
+/** The header the CLI checks the one-time token in. */
+export const KITCHEN_TOKEN_HEADER = 'x-kitchen-token';
+const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+/** An http(s) URL, or a path on the page's own origin. */
+function usableEndpoint(value) {
+    if (typeof value !== 'string')
+        return false;
+    const text = value.trim();
+    if (text.startsWith('/') && !text.startsWith('//'))
+        return true;
+    try {
+        const url = new URL(text);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate the config's `kitchen` block. Anything unusable means no kitchen.
+ * Only the endpoint is read: a `token` here is ignored, never used.
+ */
+export function parseKitchenConfig(value) {
+    if (!isObject(value))
+        return undefined;
+    const { endpoint } = value;
+    if (!usableEndpoint(endpoint))
+        return undefined;
+    return {
+        endpoint: endpoint.trim(),
+        ...(Object.hasOwn(value, 'token') ? { tokenInConfig: true } : {}),
+    };
+}
+const strings = (value) => Array.isArray(value)
+    ? value.filter((x) => typeof x === 'string')
+    : [];
+/** POST the cookbook to the kitchen. Never throws; a failure is an outcome. */
+export async function sendToKitchen(config, cookbook, fetcher = fetch) {
+    let response;
+    try {
+        response = await fetcher(config.endpoint, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                accept: 'application/json',
+                [KITCHEN_TOKEN_HEADER]: config.token,
+            },
+            body: serializeCookbook(cookbook),
+        });
+    }
+    catch {
+        return {
+            ok: false,
+            errors: [
+                'The kitchen could not be reached. Is `smrt kitchen` still running?',
+            ],
+        };
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        body = undefined;
+    }
+    if (response.ok && isObject(body) && body.ok === true) {
+        return {
+            ok: true,
+            result: {
+                dir: typeof body.dir === 'string' ? body.dir : '',
+                mode: body.mode === 'update' ? 'update' : 'new',
+                installed: body.installed === true,
+                added: strings(body.added),
+                nextSteps: strings(body.nextSteps),
+            },
+        };
+    }
+    const errors = isObject(body) ? strings(body.errors) : [];
+    if (isObject(body) && typeof body.error === 'string') {
+        errors.push(body.error);
+    }
+    return {
+        ok: false,
+        errors: errors.length
+            ? errors
+            : [`The kitchen answered ${response.status}.`],
+    };
+}

package/dist/kitchen/fragment.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The kitchen token arrives in the address, never in a file the server serves.
+ * `smrt kitchen` opens `http://127.0.0.1:<port>/#kitchen=<token>`: a fragment is
+ * never sent to a server, so no endpoint (and no other local process sending
+ * the right `Host`) can read it from `planner.config.json`. The page reads the
+ * fragment once at startup, keeps the token in memory only, and removes the
+ * `kitchen` parameter from the address (`replaceState`) so it is not left in
+ * the history entry either.
+ */
+/** The fragment key the token is under. */
+export declare const KITCHEN_FRAGMENT_KEY = "kitchen";
+export interface KitchenFragment {
+    /** The token, when the fragment carried a usable one. */
+    token?: string;
+    /** True when the fragment had a `kitchen` parameter (usable or not) to strip. */
+    present: boolean;
+    /**
+     * The fragment without the `kitchen` parameter, as it belongs in the address:
+     * `''` or `#other=1`. Other parameters are kept.
+     */
+    hash: string;
+}
+/**
+ * Read `location.hash` (with or without the `#`). Never throws. Only the
+ * `kitchen` parameter is touched: every other part of the fragment is returned
+ * exactly as it was (no re-encoding), so an in-page anchor survives. The token
+ * is read raw (it must already be URL-safe), so a percent-encoded or `+`-spaced
+ * value is not a token; the parameter is removed all the same.
+ */
+export declare function readKitchenFragment(hash: string): KitchenFragment;

package/dist/kitchen/fragment.js

@@ -0,0 +1,49 @@
+/**
+ * The kitchen token arrives in the address, never in a file the server serves.
+ * `smrt kitchen` opens `http://127.0.0.1:<port>/#kitchen=<token>`: a fragment is
+ * never sent to a server, so no endpoint (and no other local process sending
+ * the right `Host`) can read it from `planner.config.json`. The page reads the
+ * fragment once at startup, keeps the token in memory only, and removes the
+ * `kitchen` parameter from the address (`replaceState`) so it is not left in
+ * the history entry either.
+ */
+/** The fragment key the token is under. */
+export const KITCHEN_FRAGMENT_KEY = 'kitchen';
+/** URL-safe characters only (RFC 3986 unreserved): what `base64url` and hex produce. */
+const TOKEN = /^[A-Za-z0-9._~-]{1,256}$/;
+/**
+ * Read `location.hash` (with or without the `#`). Never throws. Only the
+ * `kitchen` parameter is touched: every other part of the fragment is returned
+ * exactly as it was (no re-encoding), so an in-page anchor survives. The token
+ * is read raw (it must already be URL-safe), so a percent-encoded or `+`-spaced
+ * value is not a token; the parameter is removed all the same.
+ */
+export function readKitchenFragment(hash) {
+    const text = hash.startsWith('#') ? hash.slice(1) : hash;
+    if (!text)
+        return { present: false, hash: '' };
+    let token;
+    let present = false;
+    const kept = [];
+    for (const part of text.split('&')) {
+        const equals = part.indexOf('=');
+        const key = equals < 0 ? part : part.slice(0, equals);
+        if (key !== KITCHEN_FRAGMENT_KEY) {
+            kept.push(part);
+            continue;
+        }
+        // The first `kitchen` wins; all of them are removed.
+        if (!present && equals >= 0) {
+            const value = part.slice(equals + 1);
+            if (TOKEN.test(value))
+                token = value;
+        }
+        present = true;
+    }
+    const rest = kept.filter((part) => part !== '').join('&');
+    return {
+        ...(token ? { token } : {}),
+        present,
+        hash: rest ? `#${rest}` : '',
+    };
+}

package/dist/kitchen/state.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { Cookbook } from '../cookbook/types.ts';
+import { type KitchenConfig, type KitchenEndpoint, type KitchenOutcome } from './client.ts';
+export type KitchenStatus = 'idle' | 'sending' | 'sent' | 'failed';
+/** Whether a kitchen is listening, and the state of the current send. */
+export declare class KitchenState {
+    /** Where the kitchen listens, from `planner.config.json`. */
+    endpoint: string | undefined;
+    /** An older CLI still puts its token in the config: never used, and sending is off. */
+    tokenInConfig: boolean;
+    /** The one-time token, from the address's fragment. Memory only. */
+    private token;
+    status: KitchenStatus;
+    outcome: KitchenOutcome | undefined;
+    /** A kitchen is listening and this page holds its token: sending is possible. */
+    get config(): KitchenConfig | undefined;
+    /**
+     * A kitchen is listening but this page was opened without its token (the
+     * address had no `#kitchen=` fragment, or the page was reloaded after the
+     * fragment was removed): the person needs the address `smrt kitchen` printed.
+     */
+    get needsLink(): boolean;
+    configure(config: KitchenEndpoint | undefined, token?: string): void;
+    send(cookbook: Cookbook, fetcher?: typeof fetch): Promise<void>;
+}
+/** The app's one kitchen state, set from `planner.config.json`. */
+export declare const kitchenState: KitchenState;

package/dist/kitchen/state.svelte.js

@@ -0,0 +1,45 @@
+import { sendToKitchen, } from "./client.js";
+/** Whether a kitchen is listening, and the state of the current send. */
+export class KitchenState {
+    /** Where the kitchen listens, from `planner.config.json`. */
+    endpoint = $state(undefined);
+    /** An older CLI still puts its token in the config: never used, and sending is off. */
+    tokenInConfig = $state(false);
+    /** The one-time token, from the address's fragment. Memory only. */
+    token = $state(undefined);
+    status = $state('idle');
+    outcome = $state(undefined);
+    /** A kitchen is listening and this page holds its token: sending is possible. */
+    get config() {
+        return this.endpoint && this.token && !this.tokenInConfig
+            ? { endpoint: this.endpoint, token: this.token }
+            : undefined;
+    }
+    /**
+     * A kitchen is listening but this page was opened without its token (the
+     * address had no `#kitchen=` fragment, or the page was reloaded after the
+     * fragment was removed): the person needs the address `smrt kitchen` printed.
+     */
+    get needsLink() {
+        return !!this.endpoint && !this.token && !this.tokenInConfig;
+    }
+    configure(config, token) {
+        this.endpoint = config?.endpoint;
+        this.tokenInConfig = config?.tokenInConfig === true;
+        this.token = config ? token : undefined;
+        this.status = 'idle';
+        this.outcome = undefined;
+    }
+    async send(cookbook, fetcher) {
+        const config = this.config;
+        if (!config || this.status === 'sending')
+            return;
+        this.status = 'sending';
+        this.outcome = undefined;
+        const outcome = await sendToKitchen(config, cookbook, fetcher);
+        this.outcome = outcome;
+        this.status = outcome.ok ? 'sent' : 'failed';
+    }
+}
+/** The app's one kitchen state, set from `planner.config.json`. */
+export const kitchenState = new KitchenState();

package/dist/library/apply.d.ts

@@ -0,0 +1,17 @@
+import type { CookbookStore } from '../cookbook/store.svelte.ts';
+import type { Cookbook, CookbookResult } from '../cookbook/types.ts';
+import type { AppSettings } from '../settings/app-settings.ts';
+import type { LibraryCookbook } from './types.ts';
+export { isCookbookEmpty } from './document.ts';
+/** Applying replaces the current recipes and menu, so it asks first unless empty. */
+export declare function needsConfirm(store: Pick<CookbookStore, 'snapshot'>): boolean;
+/**
+ * Replace the cookbook with the cookbook's: recipes, features, options,
+ * exposure and layout. Goes through the same strict check an import does, and
+ * applies nothing on failure. Also switches the sample-data pack to the
+ * cookbook's; rows already generated are regenerated by the caller resetting
+ * the data source (records are not part of a cookbook).
+ */
+export declare function applyLibraryCookbook(cookbook: LibraryCookbook, store: Pick<CookbookStore, 'replace'> & Partial<Pick<CookbookStore, 'theme'>>, settings?: AppSettings): CookbookResult;
+/** Does the current cookbook still hold everything the cookbook added? */
+export declare function holdsCookbook(cookbook: LibraryCookbook, current: Pick<Cookbook, 'recipes' | 'features'>): boolean;

package/dist/library/apply.js

@@ -0,0 +1,32 @@
+import { parseCookbook } from "../cookbook/validate.js";
+import { setSamplePack } from "../data/packs.js";
+import { isCookbookEmpty, resolveLibraryCookbook } from "./document.js";
+export { isCookbookEmpty } from "./document.js";
+/** Applying replaces the current recipes and menu, so it asks first unless empty. */
+export function needsConfirm(store) {
+    return !isCookbookEmpty(store.snapshot());
+}
+/**
+ * Replace the cookbook with the cookbook's: recipes, features, options,
+ * exposure and layout. Goes through the same strict check an import does, and
+ * applies nothing on failure. Also switches the sample-data pack to the
+ * cookbook's; rows already generated are regenerated by the caller resetting
+ * the data source (records are not part of a cookbook).
+ */
+export function applyLibraryCookbook(cookbook, store, settings) {
+    const result = resolveLibraryCookbook(cookbook, parseCookbook, settings);
+    if (result.ok) {
+        // A cookbook without a theme leaves the visitor's own look alone.
+        const keep = result.cookbook.theme ? undefined : store.theme;
+        store.replace(result.cookbook);
+        if (keep)
+            store.theme = keep;
+        setSamplePack(cookbook.id);
+    }
+    return result;
+}
+/** Does the current cookbook still hold everything the cookbook added? */
+export function holdsCookbook(cookbook, current) {
+    return (cookbook.document.recipes.every((id) => current.recipes.includes(id)) &&
+        cookbook.document.features.every((id) => current.features.includes(id)));
+}

package/dist/library/document.d.ts

@@ -0,0 +1,12 @@
+import type { Cookbook, CookbookResult } from '../cookbook/types.ts';
+import { type AppSettings } from '../settings/app-settings.ts';
+import type { LibraryCookbook } from './types.ts';
+/** Nothing built yet: no recipes, features, saved options, narrowing, layout or theme. */
+export declare function isCookbookEmpty(cookbook: Cookbook): boolean;
+/**
+ * The document a library cookbook sets up, through the given strict check
+ * (`parseCookbook` in the browser). `settings` are the visitor's edits of the
+ * cookbook's starting values; the cookbook's own data is never changed
+ * (writeSettings returns a copy).
+ */
+export declare function resolveLibraryCookbook(cookbook: LibraryCookbook, parse: (input: unknown) => CookbookResult, settings?: AppSettings): CookbookResult;

package/dist/library/document.js

@@ -0,0 +1,27 @@
+import { isShellLayoutEmpty } from '@happyvertical/smrt-svelte/workspace/layout';
+import { writeSettings } from "../settings/app-settings.js";
+/*
+ * The parts of applying a library cookbook that need no browser and no
+ * validator import: `apply.ts` (the browser store) and the headless planner
+ * both build on them.
+ */
+/** Nothing built yet: no recipes, features, saved options, narrowing, layout or theme. */
+export function isCookbookEmpty(cookbook) {
+    return (cookbook.recipes.length === 0 &&
+        cookbook.features.length === 0 &&
+        cookbook.policies.length === 0 &&
+        Object.keys(cookbook.exposure ?? {}).length === 0 &&
+        cookbook.theme === undefined &&
+        isShellLayoutEmpty(cookbook.layout));
+}
+/**
+ * The document a library cookbook sets up, through the given strict check
+ * (`parseCookbook` in the browser). `settings` are the visitor's edits of the
+ * cookbook's starting values; the cookbook's own data is never changed
+ * (writeSettings returns a copy).
+ */
+export function resolveLibraryCookbook(cookbook, parse, settings) {
+    return parse(settings
+        ? writeSettings(structuredClone(cookbook.document), settings)
+        : cookbook.document);
+}

package/dist/library/icons.d.ts

@@ -0,0 +1,6 @@
+/**
+ * LibraryCookbook icons as Tabler-style stroke paths (24x24 viewBox, `currentColor`,
+ * stroke width 2, round caps). The planner has no icon library; these few are
+ * inline so the cookbook data names an icon instead of carrying markup.
+ */
+export declare const COOKBOOK_ICONS: Record<string, readonly string[]>;

package/dist/library/icons.js

@@ -0,0 +1,26 @@
+/**
+ * LibraryCookbook icons as Tabler-style stroke paths (24x24 viewBox, `currentColor`,
+ * stroke width 2, round caps). The planner has no icon library; these few are
+ * inline so the cookbook data names an icon instead of carrying markup.
+ */
+export const COOKBOOK_ICONS = {
+    bread: [
+        'M7 3h10a4 4 0 0 1 2.4 7.2L20 19a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2l.6-8.8A4 4 0 0 1 7 3z',
+        'M9 13l1 3',
+        'M14 13l1 3',
+    ],
+    car: [
+        'M5 17a2 2 0 1 0 4 0a2 2 0 1 0-4 0',
+        'M15 17a2 2 0 1 0 4 0a2 2 0 1 0-4 0',
+        'M5 17h-2v-6l2-5h9l4 5h1a2 2 0 0 1 2 2v4h-2m-4 0h-6m-6-6h15m-6 0v-5',
+    ],
+    flame: [
+        'M12 12c2-2.96 0-7-1-8 0 3.038-1.773 4.741-3 6-1.226 1.26-2 3.24-2 5a6 6 0 1 0 12 0c0-1.532-1.056-3.94-2-5-1.786 3-2.791 3-4 2z',
+    ],
+    yoga: [
+        'M11 4a1 1 0 1 0 2 0a1 1 0 1 0-2 0',
+        'M4 20h4l1.5-3',
+        'M17 20l-1-5h-5l1-7',
+        'M4 10l4-1l4-1l4 1.5l4 1.5',
+    ],
+};

package/dist/library/index.d.ts

@@ -0,0 +1,8 @@
+import type { LibraryCookbook } from './types.ts';
+export { COOKBOOK_ICONS } from './icons.ts';
+export type * from './types.ts';
+/** The curated cookbooks, in the order the tab shows them. */
+export declare const libraryCookbooks: readonly LibraryCookbook[];
+export declare function getLibraryCookbook(id: string): LibraryCookbook | undefined;
+/** Recipe labels for the preview's chips, in the cookbook's (sorted) order. */
+export declare function libraryRecipeLabels(cookbook: LibraryCookbook): string[];

package/dist/library/index.js

@@ -0,0 +1,12 @@
+import { recipesById } from "../recipes/index.js";
+import raw from './library.json' with { type: 'json' };
+export { COOKBOOK_ICONS } from "./icons.js";
+/** The curated cookbooks, in the order the tab shows them. */
+export const libraryCookbooks = raw.cookbooks;
+export function getLibraryCookbook(id) {
+    return libraryCookbooks.find((cookbook) => cookbook.id === id);
+}
+/** Recipe labels for the preview's chips, in the cookbook's (sorted) order. */
+export function libraryRecipeLabels(cookbook) {
+    return cookbook.document.recipes.map((id) => recipesById.get(id)?.label ?? id);
+}