@happyvertical/smrt-planner 0.0.0-stage → 0.0.2

package/dist/features/catalogue.d.ts

@@ -0,0 +1,96 @@
+import type { CatalogPackage } from '../catalog/types.ts';
+import type { Recipe, RecipeSurface } from '../recipes/types.ts';
+import { type DemoBadge } from './demo.ts';
+/**
+ * The Features catalogue: every recipe the catalog carries, presented as a
+ * feature (what it is, where it runs, what it needs, what you get) and
+ * browsable by the recipe's `group`. Pure and data-driven: a recipe a smrt
+ * release adds shows up with no change here.
+ */
+/** Browse facet. A recipe without a `group` falls under its package. */
+export interface FeatureGroup {
+    id: string;
+    label: string;
+    summary?: string;
+}
+/** What a recipe adds that is not a model: one line each. */
+export interface FeatureGets {
+    /** `menu` for a list-and-form entry, else the surface kind. */
+    kind: 'menu' | RecipeSurface['kind'] | 'data';
+    /** The kind in words, e.g. "Shell widget". */
+    kindLabel: string;
+    /** The thing's name, e.g. "Assistant". */
+    label: string;
+    /** Where it lands, e.g. "header, right side" or "/analytics/summary". */
+    where?: string;
+}
+/** A provider need with the secret NAMES (never values). */
+export interface FeatureProvider {
+    id: string;
+    kind: string;
+    kindLabel: string;
+    required: boolean;
+    options: string[];
+    /** Options that run in a browser with none of the secrets. */
+    browserOptions: string[];
+    secrets: string[];
+}
+export interface FeatureCard {
+    recipe: Recipe;
+    id: string;
+    label: string;
+    /** The one-line help. */
+    summary: string;
+    group: FeatureGroup;
+    packageId: string;
+    /** Browser-demo label including what the recipe requires; absent if unreported. */
+    demo: DemoBadge | undefined;
+    /** The recipe's own mode when it differs from the effective one. */
+    ownMode: DemoBadge['mode'] | undefined;
+    /** What the package's own browser capability says, when reported. */
+    packageNote: string | undefined;
+    providers: FeatureProvider[];
+    gets: FeatureGets[];
+    /** Ids of recipes it requires. */
+    requires: string[];
+    runtime: Recipe['runtime'];
+}
+/** An option id in words (`webllm` -> "WebLLM", `mock` -> "Mock"). */
+export declare function optionLabel(option: string): string;
+/** `a, b or c` / `a and b`: option ids as a readable list. */
+export declare function optionList(options: readonly string[], joiner?: 'and' | 'or'): string;
+/** One surface as a line of "what you get". */
+export declare function describeSurface(surface: RecipeSurface): FeatureGets;
+/**
+ * What adding the recipe gives: its menu entries (a list and form each), then
+ * its surfaces. A recipe with neither stores records only.
+ */
+export declare function featureGets(recipe: Recipe): FeatureGets[];
+/**
+ * The browse group of a recipe: its declared `group`, else its package (so a
+ * feature that declares no group is still found next to its siblings).
+ */
+export declare function groupOf(recipe: Recipe, packageId: string): FeatureGroup;
+/**
+ * One card per recipe, in the recipes' order. `packages` says which package
+ * declared each recipe (a recipe the catalog does not place falls back to the
+ * package of its first model).
+ */
+export declare function buildFeatureCards(recipes: readonly Recipe[], packages: readonly CatalogPackage[]): FeatureCard[];
+/** Groups present in `cards`, by label. */
+export declare function featureGroups(cards: readonly FeatureCard[]): FeatureGroup[];
+/** Cards matching every search term, and the group when one is chosen. */
+export declare function filterFeatureCards(cards: readonly FeatureCard[], query: string, groupId?: string | null): FeatureCard[];
+/** Cards by group, groups by label, cards in their given order. */
+export declare function cardsByGroup(cards: readonly FeatureCard[]): {
+    group: FeatureGroup;
+    cards: FeatureCard[];
+}[];
+/**
+ * The recipes switching `id` on would add besides itself, i.e. its
+ * `requires` (transitively) and the first alternative of an unmet
+ * `requiresAny`; the same resolution the Recipes tab applies.
+ */
+export declare function alsoAdds(id: string, selected: readonly string[], recipes: ReadonlyMap<string, Recipe>): string[];
+/** The secrets a card needs by name, deduplicated across its providers. */
+export declare function secretNames(card: FeatureCard): string[];

package/dist/features/catalogue.js

@@ -0,0 +1,225 @@
+import { humanize } from "../data/format.js";
+import { withRequirements } from "../recipes/resolve.js";
+import { browserNote, demoBadge, effectiveDemo, } from "./demo.js";
+const SLOT_WORDS = {
+    'header.start': 'header, left side',
+    'header.center': 'header, middle',
+    'header.end': 'header, right side',
+    'footer.start': 'footer, left side',
+    'footer.center': 'footer, middle',
+    'footer.end': 'footer, right side',
+    'leftSidebar.header': 'left sidebar, top',
+    'leftSidebar.footer': 'left sidebar, bottom',
+    'rightSidebar.header': 'right sidebar, top',
+    'rightSidebar.footer': 'right sidebar, bottom',
+};
+const PROVIDER_KIND_WORDS = {
+    llm: 'Language model',
+    email: 'Email',
+    oauth: 'Sign-in (OAuth)',
+    storage: 'File storage',
+    sms: 'Text messages',
+    payments: 'Payments',
+};
+const OPTION_WORDS = {
+    openai: 'OpenAI',
+    anthropic: 'Anthropic',
+    gemini: 'Gemini',
+    webllm: 'WebLLM',
+    bitgpu: 'BitGPU',
+    smtp: 'SMTP',
+    imap: 'IMAP',
+    s3: 'S3',
+    github: 'GitHub',
+};
+/** An option id in words (`webllm` -> "WebLLM", `mock` -> "Mock"). */
+export function optionLabel(option) {
+    return OPTION_WORDS[option] ?? humanize(option);
+}
+/** `a, b or c` / `a and b`: option ids as a readable list. */
+export function optionList(options, joiner = 'or') {
+    const labels = options.map(optionLabel);
+    if (labels.length <= 1)
+        return labels.join('');
+    if (labels.length === 2)
+        return `${labels[0]} ${joiner} ${labels[1]}`;
+    return `${labels.slice(0, -1).join(', ')} ${joiner} ${labels[labels.length - 1]}`;
+}
+/** One surface as a line of "what you get". */
+export function describeSurface(surface) {
+    switch (surface.kind) {
+        case 'shell-widget':
+            return {
+                kind: surface.kind,
+                kindLabel: 'Shell widget',
+                label: surface.label,
+                where: SLOT_WORDS[surface.slot] ?? humanize(surface.slot),
+            };
+        case 'route':
+            return {
+                kind: surface.kind,
+                kindLabel: 'Page',
+                label: surface.label,
+                where: surface.path,
+            };
+        case 'settings-panel':
+            return {
+                kind: surface.kind,
+                kindLabel: 'Settings panel',
+                label: surface.label,
+            };
+        case 'playground':
+            return {
+                kind: surface.kind,
+                kindLabel: 'Playground',
+                label: surface.label ?? 'Try it',
+            };
+        case 'widget':
+            return {
+                kind: surface.kind,
+                kindLabel: 'Overview widget',
+                label: surface.label,
+            };
+    }
+}
+function describeProvider(provider) {
+    return {
+        id: provider.id,
+        kind: provider.kind,
+        kindLabel: PROVIDER_KIND_WORDS[provider.kind] ?? humanize(provider.kind),
+        required: provider.required,
+        options: provider.options,
+        browserOptions: provider.browserOptions ?? [],
+        secrets: provider.secrets ?? [],
+    };
+}
+/**
+ * What adding the recipe gives: its menu entries (a list and form each), then
+ * its surfaces. A recipe with neither stores records only.
+ */
+export function featureGets(recipe) {
+    const menu = recipe.nav.map((entry) => ({
+        kind: 'menu',
+        kindLabel: 'List and form',
+        label: entry.label,
+    }));
+    const surfaces = (recipe.surfaces ?? []).map(describeSurface);
+    const gets = [...menu, ...surfaces];
+    if (gets.length > 0)
+        return gets;
+    return [
+        {
+            kind: 'data',
+            kindLabel: 'Records only',
+            label: `${recipe.models.length} ${recipe.models.length === 1 ? 'model' : 'models'}, no screens of their own`,
+        },
+    ];
+}
+/**
+ * The browse group of a recipe: its declared `group`, else its package (so a
+ * feature that declares no group is still found next to its siblings).
+ */
+export function groupOf(recipe, packageId) {
+    if (recipe.group) {
+        return {
+            id: `group:${recipe.group.id}`,
+            label: recipe.group.label,
+            ...(recipe.group.summary ? { summary: recipe.group.summary } : {}),
+        };
+    }
+    return { id: `package:${packageId}`, label: humanize(packageId) };
+}
+/**
+ * One card per recipe, in the recipes' order. `packages` says which package
+ * declared each recipe (a recipe the catalog does not place falls back to the
+ * package of its first model).
+ */
+export function buildFeatureCards(recipes, packages) {
+    const declaredBy = new Map();
+    for (const pkg of packages) {
+        for (const recipe of pkg.recipes ?? [])
+            declaredBy.set(recipe.id, pkg);
+    }
+    const owner = (recipe) => declaredBy.get(recipe.id) ??
+        packages.find((pkg) => pkg.models.some((m) => m.id === recipe.models[0]));
+    return recipes.map((recipe) => {
+        const pkg = owner(recipe);
+        const packageId = pkg?.id ?? recipe.id.split('.')[0];
+        const effective = effectiveDemo(recipe);
+        const badge = demoBadge(effective);
+        return {
+            recipe,
+            id: recipe.id,
+            label: recipe.label,
+            summary: recipe.summary,
+            group: groupOf(recipe, packageId),
+            packageId,
+            demo: badge,
+            ownMode: recipe.demo && effective && recipe.demo.mode !== effective.mode
+                ? recipe.demo.mode
+                : undefined,
+            packageNote: browserNote(pkg?.browser),
+            providers: (recipe.providers ?? []).map(describeProvider),
+            gets: featureGets(recipe),
+            requires: recipe.requires,
+            runtime: recipe.runtime,
+        };
+    });
+}
+/** Groups present in `cards`, by label. */
+export function featureGroups(cards) {
+    const groups = new Map();
+    for (const card of cards) {
+        const existing = groups.get(card.group.id);
+        if (!existing)
+            groups.set(card.group.id, card.group);
+        else if (!existing.summary && card.group.summary) {
+            groups.set(card.group.id, { ...existing, summary: card.group.summary });
+        }
+    }
+    return [...groups.values()].sort((a, b) => a.label.localeCompare(b.label));
+}
+/** Cards matching every search term, and the group when one is chosen. */
+export function filterFeatureCards(cards, query, groupId) {
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    return cards.filter((card) => {
+        if (groupId && card.group.id !== groupId)
+            return false;
+        if (terms.length === 0)
+            return true;
+        const haystack = [
+            card.label,
+            card.summary,
+            card.id,
+            card.group.label,
+            card.packageId,
+            ...card.recipe.synonyms,
+            ...card.gets.flatMap((g) => [g.kindLabel, g.label, g.where ?? '']),
+            ...card.providers.flatMap((p) => [p.kindLabel, ...p.options]),
+            card.demo?.label ?? '',
+        ]
+            .join(' ')
+            .toLowerCase();
+        return terms.every((term) => haystack.includes(term));
+    });
+}
+/** Cards by group, groups by label, cards in their given order. */
+export function cardsByGroup(cards) {
+    return featureGroups(cards).map((group) => ({
+        group,
+        cards: cards.filter((card) => card.group.id === group.id),
+    }));
+}
+/**
+ * The recipes switching `id` on would add besides itself, i.e. its
+ * `requires` (transitively) and the first alternative of an unmet
+ * `requiresAny`; the same resolution the Recipes tab applies.
+ */
+export function alsoAdds(id, selected, recipes) {
+    const before = new Set(withRequirements(selected, recipes));
+    return withRequirements([...selected, id], recipes).filter((other) => other !== id && !before.has(other));
+}
+/** The secrets a card needs by name, deduplicated across its providers. */
+export function secretNames(card) {
+    return [...new Set(card.providers.flatMap((p) => p.secrets))];
+}

package/dist/features/demo.d.ts

@@ -0,0 +1,36 @@
+import type { PackageBrowserCapability, Recipe, RecipeDemo, RecipeDemoMode } from '../recipes/types.ts';
+/**
+ * How the Features catalogue labels a feature by how far it runs in this
+ * browser-only demo (smrt#3709). The mode and its reasons come from the
+ * manifest as emitted; nothing here decides, softens or upgrades one. What a
+ * feature requires is already folded in by the catalog generator (smrt-core's
+ * `effectiveRecipeDemo`, stored as the recipe's `effectiveDemo`).
+ */
+export declare const DEMO_MODE_LABEL: Readonly<Record<RecipeDemoMode, string>>;
+/** What each mode means for a visitor, in one line. */
+export declare const DEMO_MODE_MEANING: Readonly<Record<RecipeDemoMode, string>>;
+/** Badge variant (smrt-ui) per mode; the word always accompanies the colour. */
+export declare const DEMO_MODE_VARIANT: Readonly<Record<RecipeDemoMode, 'success' | 'info' | 'warning' | 'default'>>;
+export interface DemoBadge {
+    mode: RecipeDemoMode;
+    label: string;
+    meaning: string;
+    variant: 'success' | 'info' | 'warning' | 'default';
+    /** Plain sentences from the manifest saying why, plus what folds in. */
+    reasons: string[];
+    /** Ids of providers a demo fakes. */
+    mocked: string[];
+}
+/**
+ * The recipe's demo mode including what it requires: the generator's
+ * `effectiveDemo` when that differs from the recipe's own, else its `demo`.
+ * Undefined when the manifest reports no `demo` for it.
+ */
+export declare function effectiveDemo(recipe: Pick<Recipe, 'demo' | 'effectiveDemo'>): RecipeDemo | undefined;
+/** The label data for a demo, or undefined when the manifest gave none. */
+export declare function demoBadge(demo: RecipeDemo | undefined): DemoBadge | undefined;
+/**
+ * The package's own browser capability in a sentence, shown on expand as
+ * context for the label. Undefined when the manifest reports none.
+ */
+export declare function browserNote(capability: PackageBrowserCapability | undefined): string | undefined;

package/dist/features/demo.js

@@ -0,0 +1,66 @@
+/**
+ * How the Features catalogue labels a feature by how far it runs in this
+ * browser-only demo (smrt#3709). The mode and its reasons come from the
+ * manifest as emitted; nothing here decides, softens or upgrades one. What a
+ * feature requires is already folded in by the catalog generator (smrt-core's
+ * `effectiveRecipeDemo`, stored as the recipe's `effectiveDemo`).
+ */
+export const DEMO_MODE_LABEL = {
+    live: 'Live',
+    mock: 'Mock',
+    sample: 'Sample',
+    server: 'Server',
+};
+/** What each mode means for a visitor, in one line. */
+export const DEMO_MODE_MEANING = {
+    live: 'Runs for real in your browser.',
+    mock: 'Runs in your browser, but a provider is faked.',
+    sample: 'Shows sample data only; it cannot reach what it needs.',
+    server: 'Needs a server, which this browser-only demo does not have.',
+};
+/** Badge variant (smrt-ui) per mode; the word always accompanies the colour. */
+export const DEMO_MODE_VARIANT = {
+    live: 'success',
+    mock: 'info',
+    sample: 'warning',
+    server: 'default',
+};
+/**
+ * The recipe's demo mode including what it requires: the generator's
+ * `effectiveDemo` when that differs from the recipe's own, else its `demo`.
+ * Undefined when the manifest reports no `demo` for it.
+ */
+export function effectiveDemo(recipe) {
+    return recipe.effectiveDemo ?? recipe.demo;
+}
+/** The label data for a demo, or undefined when the manifest gave none. */
+export function demoBadge(demo) {
+    if (!demo)
+        return undefined;
+    return {
+        mode: demo.mode,
+        label: DEMO_MODE_LABEL[demo.mode],
+        meaning: DEMO_MODE_MEANING[demo.mode],
+        variant: DEMO_MODE_VARIANT[demo.mode],
+        reasons: demo.reasons,
+        mocked: demo.mocked ?? [],
+    };
+}
+/**
+ * The package's own browser capability in a sentence, shown on expand as
+ * context for the label. Undefined when the manifest reports none.
+ */
+export function browserNote(capability) {
+    if (!capability)
+        return undefined;
+    if (capability.status === 'browser-safe') {
+        return 'Its package builds for a browser.';
+    }
+    const parts = ['Its package does not build for a browser yet'];
+    if (capability.reason)
+        parts.push(`(${capability.reason})`);
+    if (capability.issues?.length) {
+        parts.push(`and is tracked in ${capability.issues.join(', ')}`);
+    }
+    return `${parts.join(' ')}.`;
+}

package/dist/features/palette.d.ts

@@ -0,0 +1,39 @@
+import type { PaletteProvider } from '@happyvertical/smrt-svelte/command-palette';
+import type { Recipe } from '../recipes/types.ts';
+/** The Planner page's tabs, as the palette offers them. */
+export declare const PLANNER_TAB_COMMANDS: readonly [{
+    readonly id: "cookbooks";
+    readonly title: "Open Cookbooks";
+}, {
+    readonly id: "recipes";
+    readonly title: "Open Recipes";
+}, {
+    readonly id: "features";
+    readonly title: "Browse features";
+}, {
+    readonly id: "layout";
+    readonly title: "Open Layout";
+}, {
+    readonly id: "settings";
+    readonly title: "Open Settings";
+}, {
+    readonly id: "export";
+    readonly title: "Open Export";
+}];
+export interface PlannerPaletteOptions {
+    recipes: readonly Recipe[];
+    /** Whether the recipe is already in the cookbook. */
+    isOn: (id: string) => boolean;
+    /** Add the recipe, with what it requires. */
+    add: (id: string) => void;
+    /** In-app path of a Planner tab, with the app query. */
+    href: (tab: string) => string;
+}
+/**
+ * The planner's own providers: its tabs, and "Add <feature>" for every recipe
+ * not yet on (the palette's items are re-read each time it opens, so a recipe
+ * added elsewhere drops out). Choosing one adds it and lands on the Features
+ * tab, where the card shows it on. The subtitle carries the same demo label
+ * the card does, so a server-only feature is not offered as if it were live.
+ */
+export declare function plannerProviders(options: PlannerPaletteOptions): PaletteProvider[];

package/dist/features/palette.js

@@ -0,0 +1,53 @@
+import { demoBadge, effectiveDemo } from "./demo.js";
+/** The Planner page's tabs, as the palette offers them. */
+export const PLANNER_TAB_COMMANDS = [
+    { id: 'cookbooks', title: 'Open Cookbooks' },
+    { id: 'recipes', title: 'Open Recipes' },
+    { id: 'features', title: 'Browse features' },
+    { id: 'layout', title: 'Open Layout' },
+    { id: 'settings', title: 'Open Settings' },
+    { id: 'export', title: 'Open Export' },
+];
+/**
+ * The planner's own providers: its tabs, and "Add <feature>" for every recipe
+ * not yet on (the palette's items are re-read each time it opens, so a recipe
+ * added elsewhere drops out). Choosing one adds it and lands on the Features
+ * tab, where the card shows it on. The subtitle carries the same demo label
+ * the card does, so a server-only feature is not offered as if it were live.
+ */
+export function plannerProviders(options) {
+    return [
+        {
+            id: 'planner-tabs',
+            label: 'Planner',
+            order: 20,
+            items: () => PLANNER_TAB_COMMANDS.map((tab) => ({
+                id: tab.id,
+                title: tab.title,
+                kind: 'navigation',
+                href: options.href(tab.id),
+            })),
+        },
+        {
+            id: 'planner-features',
+            label: 'Add a feature',
+            order: 30,
+            items: () => options.recipes
+                .filter((recipe) => !options.isOn(recipe.id))
+                .map((recipe) => {
+                const label = demoBadge(effectiveDemo(recipe))?.label;
+                return {
+                    id: recipe.id,
+                    title: `Add ${recipe.label}`,
+                    subtitle: label ? `${label}: ${recipe.summary}` : recipe.summary,
+                    keywords: recipe.synonyms,
+                    kind: 'command',
+                    run: ({ navigate }) => {
+                        options.add(recipe.id);
+                        return navigate(options.href('features'));
+                    },
+                };
+            }),
+        },
+    ];
+}

package/dist/fields/address.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Conversions between the Address JSON commerce stores (`PartyAddressData`:
+ * `street1`, `street2`, `city`, `state`, `postalCode`, `country`) and the
+ * `AddressValue` smrt-svelte `AddressInput` edits (`street`, `province`, ...).
+ * `AddressInput` prefixes its US subdivisions with `US-` to keep them apart
+ * from country codes; the stored `state` is the bare code.
+ */
+import type { PartyAddressData } from '../upstream/partyTypes.ts';
+/** What `AddressInput` edits. */
+export interface AddressFormValue {
+    street?: string;
+    city?: string;
+    province?: string;
+    postalCode?: string;
+    country?: string;
+}
+/** A stored address (any JSON) as the input's value. */
+export declare function toAddressInput(stored: unknown): AddressFormValue;
+/**
+ * The input's value as the stored address. Keeps what the input does not
+ * edit (`street2`, anything else already stored) and drops emptied parts.
+ */
+export declare function fromAddressInput(edited: AddressFormValue, previous: unknown): PartyAddressData;

package/dist/fields/address.js

@@ -0,0 +1,39 @@
+const text = (value) => typeof value === 'string' && value !== '' ? value : undefined;
+/** A stored address (any JSON) as the input's value. */
+export function toAddressInput(stored) {
+    const a = stored !== null && typeof stored === 'object' && !Array.isArray(stored)
+        ? stored
+        : {};
+    const country = text(a.country);
+    const state = text(a.state);
+    return {
+        ...(text(a.street1) ? { street: a.street1 } : {}),
+        ...(text(a.city) ? { city: a.city } : {}),
+        ...(state ? { province: country === 'US' ? `US-${state}` : state } : {}),
+        ...(text(a.postalCode) ? { postalCode: a.postalCode } : {}),
+        ...(country ? { country } : {}),
+    };
+}
+/**
+ * The input's value as the stored address. Keeps what the input does not
+ * edit (`street2`, anything else already stored) and drops emptied parts.
+ */
+export function fromAddressInput(edited, previous) {
+    const kept = previous !== null &&
+        typeof previous === 'object' &&
+        !Array.isArray(previous)
+        ? { ...previous }
+        : {};
+    for (const key of ['street1', 'city', 'state', 'postalCode', 'country']) {
+        delete kept[key];
+    }
+    const state = text(edited.province);
+    return {
+        ...kept,
+        ...(text(edited.street) ? { street1: edited.street } : {}),
+        ...(text(edited.city) ? { city: edited.city } : {}),
+        ...(state ? { state: state.replace(/^US-/, '') } : {}),
+        ...(text(edited.postalCode) ? { postalCode: edited.postalCode } : {}),
+        ...(text(edited.country) ? { country: edited.country } : {}),
+    };
+}

package/dist/fields/invalid.d.ts

@@ -0,0 +1,2 @@
+/** Moves focus to the first control of a form whose field is marked invalid. */
+export declare function focusFirstInvalid(form: EventTarget | null): void;

package/dist/fields/invalid.js

@@ -0,0 +1,8 @@
+/** Moves focus to the first control of a form whose field is marked invalid. */
+export function focusFirstInvalid(form) {
+    if (!(form instanceof HTMLElement))
+        return;
+    form
+        .querySelector('[data-invalid] :is(input, select, textarea, button):not([type="hidden"])')
+        ?.focus();
+}

package/dist/fields/modal.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A Svelte attachment for a `<dialog>` that holds a `<form>`: it moves the
+ * element to `document.body`, so the form is not nested inside another
+ * `<form>` (whose submit would bubble to the outer one), then opens it as a
+ * modal (focus is trapped and Escape closes it).
+ */
+export declare function modalInBody(node: HTMLDialogElement): () => void;

package/dist/fields/modal.js

@@ -0,0 +1,14 @@
+/**
+ * A Svelte attachment for a `<dialog>` that holds a `<form>`: it moves the
+ * element to `document.body`, so the form is not nested inside another
+ * `<form>` (whose submit would bubble to the outer one), then opens it as a
+ * modal (focus is trapped and Escape closes it).
+ */
+export function modalInBody(node) {
+    document.body.appendChild(node);
+    node.showModal();
+    return () => {
+        node.close();
+        node.remove();
+    };
+}

package/dist/fields/percent.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Rates such as tax and discount are stored as fractions (0.05 is 5%) but
+ * typed as percentages (5): people think in percent, the model keeps fractions.
+ */
+/** A stored fraction as the percentage a person types: `0.0825` -> `8.25`. */
+export declare function fractionToPercent(fraction: unknown): number | null;
+/** A typed percentage as the stored fraction: `8.25` -> `0.0825`. */
+export declare function percentToFraction(percent: number | null): number | null;

package/dist/fields/percent.js

@@ -0,0 +1,16 @@
+/**
+ * Rates such as tax and discount are stored as fractions (0.05 is 5%) but
+ * typed as percentages (5): people think in percent, the model keeps fractions.
+ */
+/** A stored fraction as the percentage a person types: `0.0825` -> `8.25`. */
+export function fractionToPercent(fraction) {
+    if (typeof fraction !== 'number' || !Number.isFinite(fraction))
+        return null;
+    return Number((fraction * 100).toFixed(4));
+}
+/** A typed percentage as the stored fraction: `8.25` -> `0.0825`. */
+export function percentToFraction(percent) {
+    if (percent === null || !Number.isFinite(percent))
+        return null;
+    return Number((percent / 100).toFixed(6));
+}

package/dist/fields/renderer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Which input a field gets. Pure so the choice is testable without rendering:
+ * `FieldInput.svelte` switches on the result and owns nothing else about it.
+ *
+ * Order matters: a field that references another model is a relation however
+ * it is typed; a declared enum beats a widget hint; a hint beats the plain
+ * type; money is an integer field whose name says so (`isMoneyField`).
+ */
+import type { CatalogField } from '../catalog/types.ts';
+export type FieldRenderer = 'boolean' | 'relation' | 'enum' | 'textarea' | 'currency' | 'email' | 'url' | 'phone' | 'address' | 'money' | 'datetime' | 'percent' | 'integer' | 'decimal' | 'json' | 'text';
+/** A field that references another model, by manifest type or `related`. */
+export declare function isRelation(field: CatalogField): boolean;
+/**
+ * @param modelId the qualified name of the model that owns the field, which
+ *   the address hint is keyed by (see `upstream/widgets.ts`).
+ */
+export declare function chooseRenderer(field: CatalogField, modelId?: string): FieldRenderer;