@happyvertical/smrt-planner 0.0.0-stage → 0.0.2

package/dist/planner/tab.svelte.js

@@ -0,0 +1,22 @@
+import { TAB_PARAM } from "./query.js";
+export const PLANNER_TABS = [
+    'cookbooks',
+    'recipes',
+    'features',
+    'layout',
+    'settings',
+    'export',
+];
+/** `fallback` (Recipes) unless the query names another known tab. */
+export function parseTab(search, fallback = 'recipes') {
+    const value = new URLSearchParams(search).get(TAB_PARAM);
+    return PLANNER_TABS.find((tab) => tab === value) ?? fallback;
+}
+/** The Planner page's active tab; the address bar mirrors it (`?tab=`). */
+class PlannerTabState {
+    active = $state('recipes');
+    fromSearch(search, fallback = 'recipes') {
+        this.active = parseTab(search, fallback);
+    }
+}
+export const plannerTab = new PlannerTabState();

package/dist/planner/types.d.ts

@@ -0,0 +1,41 @@
+import type { PlannerAssistant, PlannerInference } from './assistant.ts';
+import type { PlannerController, PlannerTabId } from './commands/index.ts';
+/** What `onready` hands a host once the planner is mounted. */
+export interface PlannerHandle {
+    controller: PlannerController;
+    /** Present when `inference` was given: a chat transport driven by the controller. */
+    assistant?: PlannerAssistant;
+}
+/** The `Planner` component's props. */
+export interface PlannerProps {
+    /**
+     * The commands to drive the planner with and the snapshot to read. Defaults
+     * to the app's own. A controller made with `createPlannerController` works
+     * too; the planner follows its `focus` tab.
+     */
+    controller?: PlannerController;
+    /**
+     * Where the planner's own pages are served from (`''`, `'/planner'`). Only
+     * links to planner pages use it; the component needs no router of its own.
+     */
+    basePath?: string;
+    /** A model for the planner's assistant; see `createPlannerAssistant`. */
+    inference?: PlannerInference;
+    /**
+     * `'own'` (the default) edits the menu layout on a headless controller built
+     * from the cookbook. `'shell'` edits the nearest smrt-svelte `AppShell`'s, as
+     * the static app does (it also holds panel and slot placements).
+     */
+    layout?: 'own' | 'shell';
+    /**
+     * `'self'` (the default) reads the saved cookbook from this browser on mount
+     * and saves changes. `'host'` leaves both to the host (the static app's
+     * layout does them).
+     */
+    persistence?: 'self' | 'host';
+    /** Show the theme preset and light/dark controls (they need a theme provider). */
+    themeControls?: boolean;
+    /** Tabs to show, in order; defaults to all. */
+    tabs?: readonly PlannerTabId[];
+    onready?: (handle: PlannerHandle) => void;
+}

package/dist/planner/types.js

@@ -0,0 +1 @@
+export {};

package/dist/recipes/cards.d.ts

@@ -0,0 +1,55 @@
+import type { Recipe } from './types.ts';
+/**
+ * One card on the Planner: a recipe, or a group of recipes (`group`) that
+ * share a card with a sub-switch each. Local to the planner; the card list is
+ * derived from the recipes, never declared.
+ */
+export interface PlannerCard {
+    /** The group id, or the recipe id for a recipe with no group. */
+    id: string;
+    label: string;
+    summary: string;
+    /** In declaration order; the first is what turning the card on adds. */
+    recipes: Recipe[];
+    /** More than one recipe: the card shows a sub-switch for each. */
+    hasSubSwitches: boolean;
+}
+/** Cards by label, each with its recipes in declaration order. */
+export declare function buildCards(recipes: readonly Recipe[]): PlannerCard[];
+/** The card's main switch is on while any of its recipes is. */
+export declare function cardIsOn(card: PlannerCard, selected: readonly string[]): boolean;
+/**
+ * The recipe ids after flipping the main switch: on adds the first
+ * sub-recipe, off removes every one. (Recipes other recipes need stay on:
+ * the caller's `remove`/`add` apply `requires`.)
+ */
+export declare function mainSwitchChange(card: PlannerCard, selected: readonly string[], on: boolean): {
+    add: string[];
+    remove: string[];
+};
+/** Turning a sub-switch on adds that recipe; off removes it. The main switch follows. */
+export declare function subSwitchChange(recipeId: string, on: boolean): {
+    add: string[];
+    remove: string[];
+};
+/** What keeps a card's switches on: the selected recipes that need them. */
+export interface CardLocks {
+    /** Recipes that keep the card on at all (main switch locked when non-empty). */
+    main: string[];
+    /**
+     * Recipes that keep one sub-recipe on, by sub-recipe id. Only sub-recipes
+     * that are themselves locked have an entry: the others change freely.
+     */
+    subs: Record<string, string[]>;
+}
+/**
+ * Which switches on a card are locked. The main switch locks while something
+ * needs any of the card's recipes; a sub-switch locks only when removing that
+ * one recipe would force it back on (it is the last alternative), so the
+ * others stay fully usable.
+ */
+export declare function cardLocks(card: PlannerCard, selected: readonly string[], recipes: ReadonlyMap<string, Recipe>): CardLocks;
+/** The note under a locked main switch, in words. */
+export declare function mainLockNote(card: PlannerCard, needers: string[]): string;
+/** The note under a locked sub-switch: it is the last one the needers can use. */
+export declare function subLockNote(card: PlannerCard, recipeLabel: string, needers: string[]): string;

package/dist/recipes/cards.js

@@ -0,0 +1,80 @@
+import { removalBlockers } from "./resolve.js";
+/** Cards by label, each with its recipes in declaration order. */
+export function buildCards(recipes) {
+    const cards = new Map();
+    for (const recipe of recipes) {
+        const id = recipe.group?.id ?? recipe.id;
+        const existing = cards.get(id);
+        if (existing) {
+            existing.recipes.push(recipe);
+            existing.hasSubSwitches = true;
+        }
+        else {
+            cards.set(id, {
+                id,
+                label: recipe.group?.label ?? recipe.label,
+                summary: recipe.group?.summary ?? recipe.summary,
+                recipes: [recipe],
+                hasSubSwitches: false,
+            });
+        }
+    }
+    return [...cards.values()].sort((a, b) => a.label.localeCompare(b.label));
+}
+/** The card's main switch is on while any of its recipes is. */
+export function cardIsOn(card, selected) {
+    return card.recipes.some((recipe) => selected.includes(recipe.id));
+}
+/**
+ * The recipe ids after flipping the main switch: on adds the first
+ * sub-recipe, off removes every one. (Recipes other recipes need stay on:
+ * the caller's `remove`/`add` apply `requires`.)
+ */
+export function mainSwitchChange(card, selected, on) {
+    if (on) {
+        const first = card.recipes[0];
+        return {
+            add: first && !cardIsOn(card, selected) ? [first.id] : [],
+            remove: [],
+        };
+    }
+    return { add: [], remove: card.recipes.map((r) => r.id) };
+}
+/** Turning a sub-switch on adds that recipe; off removes it. The main switch follows. */
+export function subSwitchChange(recipeId, on) {
+    return on ? { add: [recipeId], remove: [] } : { add: [], remove: [recipeId] };
+}
+/**
+ * Which switches on a card are locked. The main switch locks while something
+ * needs any of the card's recipes; a sub-switch locks only when removing that
+ * one recipe would force it back on (it is the last alternative), so the
+ * others stay fully usable.
+ */
+export function cardLocks(card, selected, recipes) {
+    const on = card.recipes.filter((r) => selected.includes(r.id));
+    const subs = {};
+    if (card.hasSubSwitches) {
+        for (const recipe of on) {
+            const blockers = removalBlockers([recipe.id], selected, recipes);
+            if (blockers.length)
+                subs[recipe.id] = blockers;
+        }
+    }
+    return {
+        main: on.length
+            ? removalBlockers(card.recipes.map((r) => r.id), selected, recipes)
+            : [],
+        subs,
+    };
+}
+/** The note under a locked main switch, in words. */
+export function mainLockNote(card, needers) {
+    const by = needers.join(', ');
+    return card.hasSubSwitches
+        ? `${card.label} stays on while ${by} needs at least one ${card.label} recipe.`
+        : `${card.label} stays on while ${by} needs it.`;
+}
+/** The note under a locked sub-switch: it is the last one the needers can use. */
+export function subLockNote(card, recipeLabel, needers) {
+    return `${recipeLabel} is the last ${card.label} recipe on, and ${needers.join(', ')} needs one.`;
+}

package/dist/recipes/features.d.ts

@@ -0,0 +1,53 @@
+import type { Catalog } from '../catalog/types.ts';
+import type { Recipe, RecipeNavSection } from './types.ts';
+/**
+ * Features: exposed catalog models no recipe covers, which a visitor can add
+ * one at a time (the Planner's Features tab). They sit in the cookbook's
+ * `features` and in one suggested nav section, after the recipes' sections.
+ */
+export declare const FEATURE_SECTION: RecipeNavSection;
+/** Icon of a feature entry: they are loose records, so one generic glyph. */
+export declare const FEATURE_ENTRY_ICON = "fileText";
+export interface FeatureEntry {
+    /** `@scope/pkg:Class` qualified name, as stored in the cookbook. */
+    id: string;
+    name: string;
+    /** Humanized model name, e.g. `Purchase Order`. */
+    label: string;
+    /** Catalog package id, for `/m/<package>/<model>/` and `/packages/<id>/`. */
+    packageId: string;
+    /** The model's description, else a field count (see `featureSummary`). */
+    description: string;
+    /** `description` is the model's own, not the field-count fallback. */
+    described: boolean;
+    /** Link tables, child records and tiny lookups; hidden unless "Show all". */
+    plumbing: boolean;
+    fieldNames: string[];
+    /** Humanized names of the child models that come along (line items). */
+    includes: string[];
+}
+/** Every exposed model that no recipe lists in `models`, by package then name. */
+export declare function featureEntries(catalog: Catalog, recipes: readonly Recipe[]): FeatureEntry[];
+/** The row's second line: the description, else "Package · N fields". */
+export declare function featureSummary(entry: FeatureEntry): string;
+/** Entries to list: features only, or everything when `showAll`. */
+export declare function visibleFeatures(entries: readonly FeatureEntry[], showAll: boolean): FeatureEntry[];
+/** Packages that have at least one of the entries, in catalog order. */
+export declare function featurePackages(entries: readonly FeatureEntry[]): string[];
+/**
+ * Entries matching every search term (model name, description, package, field
+ * names; case-insensitive) and, when given, one package.
+ */
+export declare function filterFeatures(entries: readonly FeatureEntry[], query: string, packageId?: string | null): FeatureEntry[];
+export interface FeatureNavItem {
+    /** Stable layout id: `item:<package>:<Model>`. */
+    id: string;
+    packageId: string;
+    modelName: string;
+    label: string;
+    /** Shell icon name. */
+    icon: string;
+    description: string;
+}
+/** Nav items for the added feature models; unknown or internal ones are dropped. */
+export declare function featureNavItems(features: readonly string[]): FeatureNavItem[];

package/dist/recipes/features.js

@@ -0,0 +1,97 @@
+import { exposedModels, getModelByQualifiedName } from "../catalog/index.js";
+import { humanize } from "../data/format.js";
+import { childModels, isPlumbing } from "./plumbing.js";
+import { entryDescription, navItemId } from "./sections.js";
+/**
+ * Features: exposed catalog models no recipe covers, which a visitor can add
+ * one at a time (the Planner's Features tab). They sit in the cookbook's
+ * `features` and in one suggested nav section, after the recipes' sections.
+ */
+export const FEATURE_SECTION = {
+    id: 'more',
+    label: 'More',
+    icon: 'layers',
+    description: 'Extra records you added one at a time.',
+};
+/** Icon of a feature entry: they are loose records, so one generic glyph. */
+export const FEATURE_ENTRY_ICON = 'fileText';
+/** One line for a row: the model's description, else how many fields it has. */
+function describeModel(model) {
+    const description = model.description?.trim();
+    if (description)
+        return description.split(/(?<=[.!?])\s/)[0] ?? description;
+    const count = model.fields.filter((f) => !f.system).length;
+    return `${count} ${count === 1 ? 'field' : 'fields'}`;
+}
+/** Every exposed model that no recipe lists in `models`, by package then name. */
+export function featureEntries(catalog, recipes) {
+    const covered = new Set(recipes.flatMap((recipe) => recipe.models));
+    return catalog.packages.flatMap((pkg) => exposedModels(pkg)
+        .filter((model) => !covered.has(model.id))
+        .map((model) => ({
+        id: model.id,
+        name: model.name,
+        label: humanize(model.name),
+        packageId: pkg.id,
+        description: describeModel(model),
+        described: Boolean(model.description?.trim()),
+        plumbing: isPlumbing(model),
+        fieldNames: model.fields.map((f) => f.name),
+        includes: childModels(catalog, model.id).map((c) => humanize(c.name)),
+    })));
+}
+/** The row's second line: the description, else "Package · N fields". */
+export function featureSummary(entry) {
+    return entry.described
+        ? entry.description
+        : `${humanize(entry.packageId)} · ${entry.description}`;
+}
+/** Entries to list: features only, or everything when `showAll`. */
+export function visibleFeatures(entries, showAll) {
+    return showAll ? [...entries] : entries.filter((e) => !e.plumbing);
+}
+/** Packages that have at least one of the entries, in catalog order. */
+export function featurePackages(entries) {
+    return [...new Set(entries.map((e) => e.packageId))];
+}
+/**
+ * Entries matching every search term (model name, description, package, field
+ * names; case-insensitive) and, when given, one package.
+ */
+export function filterFeatures(entries, query, packageId) {
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    return entries.filter((entry) => {
+        if (packageId && entry.packageId !== packageId)
+            return false;
+        if (!terms.length)
+            return true;
+        const haystack = [
+            entry.name,
+            entry.label,
+            entry.description,
+            entry.packageId,
+            ...entry.fieldNames,
+        ]
+            .join(' ')
+            .toLowerCase();
+        return terms.every((term) => haystack.includes(term));
+    });
+}
+/** Nav items for the added feature models; unknown or internal ones are dropped. */
+export function featureNavItems(features) {
+    return features.flatMap((qualified) => {
+        const found = getModelByQualifiedName(qualified);
+        if (!found?.model.exposed)
+            return [];
+        return [
+            {
+                id: navItemId(found.pkg.id, found.model.name),
+                packageId: found.pkg.id,
+                modelName: found.model.name,
+                label: humanize(found.model.name),
+                icon: FEATURE_ENTRY_ICON,
+                description: entryDescription(undefined, found.model),
+            },
+        ];
+    });
+}