@happyvertical/smrt-planner 0.0.0-stage → 0.0.1

package/dist/fields/renderer.js

@@ -0,0 +1,43 @@
+import { isMoneyField } from "../data/fakes.js";
+import { isFractionRate } from "../data/format.js";
+import { ADDRESS_FIELDS } from "../upstream/widgets.js";
+/** A field that references another model, by manifest type or `related`. */
+export function isRelation(field) {
+    return ((field.type === 'foreignKey' || field.type === 'crossPackageRef') &&
+        typeof field.related === 'string');
+}
+/**
+ * @param modelId the qualified name of the model that owns the field, which
+ *   the address hint is keyed by (see `upstream/widgets.ts`).
+ */
+export function chooseRenderer(field, modelId) {
+    if (field.type === 'boolean')
+        return 'boolean';
+    if (isRelation(field))
+        return 'relation';
+    if (field.enum && field.enum.length > 0)
+        return 'enum';
+    if (field.ui?.widget)
+        return field.ui.widget;
+    if (field.type === 'json' &&
+        modelId !== undefined &&
+        (ADDRESS_FIELDS[modelId] ?? []).includes(field.name)) {
+        return 'address';
+    }
+    if (isMoneyField(field))
+        return 'money';
+    if (isFractionRate(field))
+        return 'percent';
+    switch (field.type) {
+        case 'datetime':
+            return 'datetime';
+        case 'integer':
+            return 'integer';
+        case 'decimal':
+            return 'decimal';
+        case 'json':
+            return 'json';
+        default:
+            return 'text';
+    }
+}

package/dist/forms/active.d.ts

@@ -0,0 +1,16 @@
+import type { FieldMapForm, Recipe, RecipeForm, RecipeFormExtension, VariantGridForm } from '../recipes/types.ts';
+/** A form of an added recipe, with the extensions of the other added recipes. */
+export interface ActiveForm<F extends RecipeForm = RecipeForm> {
+    recipeId: string;
+    form: F;
+    extensions: RecipeFormExtension[];
+}
+export declare function isFieldMap(active: ActiveForm): active is ActiveForm<FieldMapForm>;
+export declare function isVariantGrid(active: ActiveForm): active is ActiveForm<VariantGridForm>;
+/**
+ * The forms offered for a model by the recipes in `ids`, in the order the
+ * recipes are declared, each with the `extends` of every added recipe.
+ */
+export declare function activeForms(ids: readonly string[], recipes: readonly Recipe[], modelId: string): ActiveForm[];
+/** Does any extension of the form bring in a row of this model? */
+export declare function extendsWith(active: ActiveForm, modelId: string): boolean;

package/dist/forms/active.js

@@ -0,0 +1,24 @@
+export function isFieldMap(active) {
+    return active.form.kind === 'field-map';
+}
+export function isVariantGrid(active) {
+    return active.form.kind === 'variant-grid';
+}
+/**
+ * The forms offered for a model by the recipes in `ids`, in the order the
+ * recipes are declared, each with the `extends` of every added recipe.
+ */
+export function activeForms(ids, recipes, modelId) {
+    const added = recipes.filter((recipe) => ids.includes(recipe.id));
+    return added.flatMap((recipe) => (recipe.forms ?? [])
+        .filter((form) => form.model === modelId)
+        .map((form) => ({
+        recipeId: recipe.id,
+        form,
+        extensions: added.flatMap((other) => (other.extends ?? []).filter((ext) => ext.form === form.id)),
+    })));
+}
+/** Does any extension of the form bring in a row of this model? */
+export function extendsWith(active, modelId) {
+    return active.extensions.some((ext) => (ext.records ?? []).some((record) => record.model === modelId));
+}

package/dist/forms/fieldMap.d.ts

@@ -0,0 +1,44 @@
+import type { CatalogField } from '../catalog/types.ts';
+import { type DataSource, type ModelRecord, type RecordWrite } from '../data/source.ts';
+import type { FieldMapForm, RecipeFormField, RecipeFormRecord } from '../recipes/types.ts';
+import type { ActiveForm } from './active.ts';
+import { type ModelLookup } from './shared.ts';
+/** The records and inputs of a field-map form once extensions are merged in. */
+export declare function fieldMapParts(active: ActiveForm<FieldMapForm>): {
+    records: RecipeFormRecord[];
+    fields: RecipeFormField[];
+};
+/** Each input with the catalog field it maps onto, for rendering. */
+export declare function fieldMapInputs(active: ActiveForm<FieldMapForm>, models: ModelLookup): {
+    field: RecipeFormField;
+    catalogField: CatalogField;
+    modelId: string;
+}[];
+/** Input values for a new row. */
+export declare function blankFieldMap(active: ActiveForm<FieldMapForm>, models: ModelLookup): Record<string, unknown>;
+/**
+ * The record the form edits by id: the one of the form's own `model` (a
+ * Customer form's Customer, though its Profile is written first), else the
+ * first.
+ */
+export declare function primaryIndex(active: ActiveForm<FieldMapForm>): number;
+/** The rows an existing primary row's records point at, by alias. */
+export declare function findFieldMapRows(source: DataSource, active: ActiveForm<FieldMapForm>, models: ModelLookup, id: string): Promise<Record<string, ModelRecord | undefined>>;
+/**
+ * Load an existing row's input values, following the records' matches, with
+ * the rows found (hand them back to {@link planFieldMapSave}).
+ */
+export declare function loadFieldMapState(source: DataSource, active: ActiveForm<FieldMapForm>, models: ModelLookup, id: string): Promise<{
+    values: Record<string, unknown>;
+    rows: Record<string, ModelRecord | undefined>;
+}>;
+/** Load an existing row's input values. */
+export declare function loadFieldMap(source: DataSource, active: ActiveForm<FieldMapForm>, models: ModelLookup, id: string): Promise<Record<string, unknown>>;
+/**
+ * The related writes that save a field-map form: each record in order, found
+ * or created by its `match` and written with the inputs mapped to it. When
+ * editing (`id`), the primary record is updated by `id` and every record
+ * `rows` already holds (see {@link findFieldMapRows}) by its own id; the rest
+ * are found or created as on a new row. Pure; `apply` runs it.
+ */
+export declare function planFieldMapSave(active: ActiveForm<FieldMapForm>, models: ModelLookup, values: Readonly<Record<string, unknown>>, id?: string, rows?: Readonly<Record<string, ModelRecord | undefined>>, preset?: Readonly<Record<string, unknown>>): RecordWrite[];

package/dist/forms/fieldMap.js

@@ -0,0 +1,134 @@
+import { isRecordRef, } from "../data/source.js";
+import { contextFrom, findRows, mappedValues, parseTarget, scalar, startingValue, targetField, targetModelId, toWriteValues, } from "./shared.js";
+/** The records and inputs of a field-map form once extensions are merged in. */
+export function fieldMapParts(active) {
+    return {
+        records: [
+            ...active.form.records,
+            ...active.extensions.flatMap((ext) => ext.records ?? []),
+        ],
+        fields: [
+            ...active.form.fields,
+            ...active.extensions.flatMap((ext) => ext.fields ?? []),
+        ],
+    };
+}
+/** Each input with the catalog field it maps onto, for rendering. */
+export function fieldMapInputs(active, models) {
+    const { records, fields } = fieldMapParts(active);
+    return fields.map((field) => ({
+        field,
+        catalogField: targetField(field, records, models),
+        modelId: targetModelId(field, records),
+    }));
+}
+/** Input values for a new row. */
+export function blankFieldMap(active, models) {
+    return Object.fromEntries(fieldMapInputs(active, models).map(({ field, catalogField }) => [
+        field.id,
+        startingValue(field, catalogField),
+    ]));
+}
+/**
+ * The record the form edits by id: the one of the form's own `model` (a
+ * Customer form's Customer, though its Profile is written first), else the
+ * first.
+ */
+export function primaryIndex(active) {
+    const { records } = fieldMapParts(active);
+    const found = records.findIndex((r) => r.model === active.form.model);
+    return found < 0 ? 0 : found;
+}
+/** The rows an existing primary row's records point at, by alias. */
+export async function findFieldMapRows(source, active, models, id) {
+    const { records } = fieldMapParts(active);
+    const primary = records[primaryIndex(active)];
+    if (!primary)
+        return {};
+    const row = await source.get(models(primary.model), id);
+    return findRows(source, records, { [primary.as]: row }, models);
+}
+/**
+ * Load an existing row's input values, following the records' matches, with
+ * the rows found (hand them back to {@link planFieldMapSave}).
+ */
+export async function loadFieldMapState(source, active, models, id) {
+    const { fields } = fieldMapParts(active);
+    const rows = await findFieldMapRows(source, active, models, id);
+    const blank = blankFieldMap(active, models);
+    const values = Object.fromEntries(fields.map((field) => {
+        const { alias, field: name } = parseTarget(field.to);
+        const value = rows[alias]?.[name];
+        return [field.id, value === undefined ? blank[field.id] : value];
+    }));
+    return { values, rows };
+}
+/** Load an existing row's input values. */
+export async function loadFieldMap(source, active, models, id) {
+    return (await loadFieldMapState(source, active, models, id)).values;
+}
+/**
+ * The related writes that save a field-map form: each record in order, found
+ * or created by its `match` and written with the inputs mapped to it. When
+ * editing (`id`), the primary record is updated by `id` and every record
+ * `rows` already holds (see {@link findFieldMapRows}) by its own id; the rest
+ * are found or created as on a new row. Pure; `apply` runs it.
+ */
+export function planFieldMapSave(active, models, values, id, rows = {}, preset = {}) {
+    const { records, fields } = fieldMapParts(active);
+    const context = contextFrom(fields, values);
+    const primary = primaryIndex(active);
+    const written = new Set();
+    return records.map((record, index) => {
+        const mapped = mappedValues(fields, record.as, values);
+        // A page that lists a slice of rows (Ingredients) stamps new primary rows.
+        const createValues = {
+            ...toWriteValues(record.values, context),
+            ...(index === primary
+                ? Object.fromEntries(Object.entries(preset).map(([key, v]) => [key, scalar(v)]))
+                : {}),
+        };
+        const model = models(record.model);
+        const existing = id !== undefined ? rows[record.as] : undefined;
+        try {
+            if (index === primary && id !== undefined) {
+                // Editing also (re)links a record created in this save, e.g. a
+                // Customer's Profile.
+                const links = Object.fromEntries(Object.entries(createValues).filter(([, v]) => isRecordRef(v)));
+                return {
+                    op: 'save',
+                    as: record.as,
+                    model,
+                    id,
+                    values: { ...mapped, ...links },
+                };
+            }
+            if (existing) {
+                return {
+                    op: 'save',
+                    as: record.as,
+                    model,
+                    id: existing.id,
+                    values: mapped,
+                };
+            }
+            // A match naming a record that is written later only locates the row
+            // being edited; a new row has nothing to find.
+            const match = record.match ? toWriteValues(record.match, context) : {};
+            const later = Object.values(match).some((v) => isRecordRef(v) && !written.has(v.ref));
+            const usable = later ? {} : match;
+            const hasMatch = Object.keys(usable).length > 0;
+            return {
+                op: 'save',
+                as: record.as,
+                model,
+                ...(hasMatch ? { match: usable } : {}),
+                onCreate: createValues,
+                values: mapped,
+            };
+        }
+        finally {
+            written.add(record.as);
+        }
+    });
+}

package/dist/forms/shared.d.ts

@@ -0,0 +1,41 @@
+import type { CatalogField, CatalogModel } from '../catalog/types.ts';
+import type { DataSource, ModelRecord, WriteValue } from '../data/source.ts';
+import type { RecipeFormField, RecipeFormRecord, RecipeFormValue } from '../recipes/types.ts';
+/** A catalog model by qualified name; a form naming a missing one is a bug. */
+export type ModelLookup = (qualified: string) => CatalogModel;
+export declare const catalogModels: ModelLookup;
+/** What a template reads: `alias.field` to the value the form holds. */
+export type TemplateContext = Readonly<Record<string, unknown>>;
+/** `Blue Tee` to `BLUE-TEE`: upper-case letters and digits, joined by dashes. */
+export declare function slug(value: unknown): string;
+/** Fill `{alias.field}` and `{alias.field|slug}` in a string from the context. */
+export declare function fillTemplate(text: string, context: TemplateContext): string;
+/** A recipe value as a write value: templates filled, `{ref}` kept. */
+export declare function toWriteValue(value: RecipeFormValue, context: TemplateContext, renameRef?: (alias: string) => string): WriteValue;
+export declare function toWriteValues(values: Record<string, RecipeFormValue> | undefined, context: TemplateContext, renameRef?: (alias: string) => string): Record<string, WriteValue>;
+/**
+ * An input's value as a write value: scalars and plain JSON objects (an
+ * Address) as they are, anything else null.
+ */
+export declare function scalar(value: unknown): WriteValue;
+/** The inputs mapped to one record, as that record's field values. */
+export declare function mappedValues(fields: readonly RecipeFormField[], alias: string, values: Readonly<Record<string, unknown>>): Record<string, WriteValue>;
+/** `product.price` to `{ alias: 'product', field: 'price' }`. */
+export declare function parseTarget(to: string): {
+    alias: string;
+    field: string;
+};
+/** The catalog field a form field maps onto. */
+export declare function targetField(field: RecipeFormField, records: readonly RecipeFormRecord[], models: ModelLookup): CatalogField;
+/** The qualified model a form field's record is of. */
+export declare function targetModelId(field: RecipeFormField, records: readonly RecipeFormRecord[]): string;
+/** The starting value of a field on a new row. */
+export declare function startingValue(field: RecipeFormField, catalogField: CatalogField): unknown;
+/** Context values (`alias.field`) from the form's field values. */
+export declare function contextFrom(fields: readonly RecipeFormField[], values: Readonly<Record<string, unknown>>): Record<string, unknown>;
+/**
+ * Rows a form's records currently point at: walk them in order, finding each
+ * by its (literal or `{ref}`) `match`. `seeded` rows (the one being edited)
+ * are taken as given. A record whose match cannot be resolved has no row.
+ */
+export declare function findRows(source: DataSource, records: readonly RecipeFormRecord[], seeded: Record<string, ModelRecord | undefined>, models: ModelLookup): Promise<Record<string, ModelRecord | undefined>>;

package/dist/forms/shared.js

@@ -0,0 +1,138 @@
+import { getModelByQualifiedName } from "../catalog/index.js";
+export const catalogModels = (qualified) => {
+    const found = getModelByQualifiedName(qualified);
+    if (!found)
+        throw new Error(`The catalog has no model ${qualified}`);
+    return found.model;
+};
+/** `Blue Tee` to `BLUE-TEE`: upper-case letters and digits, joined by dashes. */
+export function slug(value) {
+    return String(value ?? '')
+        .toUpperCase()
+        .replace(/[^A-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+const PLACEHOLDER = /\{([A-Za-z_][\w]*\.[A-Za-z_][\w]*)(?:\|(slug))?\}/g;
+/** Fill `{alias.field}` and `{alias.field|slug}` in a string from the context. */
+export function fillTemplate(text, context) {
+    return text.replace(PLACEHOLDER, (_, key, filter) => {
+        const value = context[key];
+        const plain = value === null || value === undefined ? '' : String(value);
+        return filter === 'slug' ? slug(plain) : plain;
+    });
+}
+/** A recipe value as a write value: templates filled, `{ref}` kept. */
+export function toWriteValue(value, context, renameRef = (alias) => alias) {
+    if (typeof value === 'string')
+        return fillTemplate(value, context);
+    if (value !== null && typeof value === 'object') {
+        return {
+            ref: renameRef(value.ref),
+            ...(value.field ? { field: value.field } : {}),
+        };
+    }
+    return value;
+}
+export function toWriteValues(values, context, renameRef) {
+    return Object.fromEntries(Object.entries(values ?? {}).map(([key, value]) => [
+        key,
+        toWriteValue(value, context, renameRef),
+    ]));
+}
+/**
+ * An input's value as a write value: scalars and plain JSON objects (an
+ * Address) as they are, anything else null.
+ */
+export function scalar(value) {
+    if (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+/** The inputs mapped to one record, as that record's field values. */
+export function mappedValues(fields, alias, values) {
+    return Object.fromEntries(fields.flatMap((field) => {
+        const target = parseTarget(field.to);
+        return target.alias === alias
+            ? [[target.field, scalar(values[field.id])]]
+            : [];
+    }));
+}
+/** `product.price` to `{ alias: 'product', field: 'price' }`. */
+export function parseTarget(to) {
+    const dot = to.indexOf('.');
+    if (dot < 1 || dot === to.length - 1) {
+        throw new Error(`A form field maps to "alias.field", got "${to}"`);
+    }
+    return { alias: to.slice(0, dot), field: to.slice(dot + 1) };
+}
+/** The catalog field a form field maps onto. */
+export function targetField(field, records, models) {
+    const { alias, field: name } = parseTarget(field.to);
+    const record = records.find((r) => r.as === alias);
+    if (!record)
+        throw new Error(`Form field ${field.id} maps to unknown ${alias}`);
+    const found = models(record.model).fields.find((f) => f.name === name);
+    if (!found) {
+        throw new Error(`${record.model} has no field ${name} (form field ${field.id})`);
+    }
+    return found;
+}
+/** The qualified model a form field's record is of. */
+export function targetModelId(field, records) {
+    const { alias } = parseTarget(field.to);
+    const record = records.find((r) => r.as === alias);
+    if (!record)
+        throw new Error(`Form field ${field.id} maps to unknown ${alias}`);
+    return record.model;
+}
+/** The starting value of a field on a new row. */
+export function startingValue(field, catalogField) {
+    if (field.default !== undefined)
+        return field.default;
+    if (catalogField.default !== undefined)
+        return catalogField.default;
+    return catalogField.type === 'text' ? '' : null;
+}
+/** Context values (`alias.field`) from the form's field values. */
+export function contextFrom(fields, values) {
+    return Object.fromEntries(fields.map((f) => [f.to, values[f.id]]));
+}
+const sameValue = (a, b) => a === b;
+/**
+ * Rows a form's records currently point at: walk them in order, finding each
+ * by its (literal or `{ref}`) `match`. `seeded` rows (the one being edited)
+ * are taken as given. A record whose match cannot be resolved has no row.
+ */
+export async function findRows(source, records, seeded, models) {
+    const rows = { ...seeded };
+    for (const record of records) {
+        if (record.as in rows)
+            continue;
+        if (!record.match) {
+            rows[record.as] = undefined;
+            continue;
+        }
+        const wanted = {};
+        let resolvable = true;
+        for (const [key, value] of Object.entries(record.match)) {
+            if (value !== null && typeof value === 'object') {
+                const target = rows[value.ref];
+                if (!target)
+                    resolvable = false;
+                wanted[key] = value.field ? target?.[value.field] : target?.id;
+            }
+            else {
+                wanted[key] = value;
+            }
+        }
+        rows[record.as] = resolvable
+            ? (await source.list(models(record.model))).find((row) => Object.entries(wanted).every(([k, v]) => sameValue(row[k], v)))
+            : undefined;
+    }
+    return rows;
+}

package/dist/forms/stock.d.ts

@@ -0,0 +1,28 @@
+import type { MemoryDataSourceOptions, ModelRecord, RecordWrite } from '../data/source.ts';
+import type { ModelLookup } from './shared.ts';
+export declare const PRODUCT = "@happyvertical/smrt-products:Product";
+export declare const VARIANT = "@happyvertical/smrt-products:ProductVariant";
+export declare const SKU = "@happyvertical/smrt-products:Sku";
+export declare const STOCK_LEVEL = "@happyvertical/smrt-inventory:StockLevel";
+export declare const PROFILE_TYPE = "@happyvertical/smrt-profiles:ProfileType";
+export declare const LOCATION = "@happyvertical/smrt-inventory:InventoryLocation";
+/**
+ * Models the product forms write as children of a product. The demo data
+ * source starts them empty, so no sample row points at a product that is not
+ * there.
+ */
+export declare const SAVED_BY_FORMS: string[];
+/**
+ * Sample locations (the active pack's), one SKU per sample product and a stock level for each SKU
+ * at the main location and (for about two in three) at the second, with a
+ * reorder point. The rows point at one another, so they are built together;
+ * a form still adds its own on top. Variants stay empty.
+ */
+export declare function stockSamples(models: ModelLookup): NonNullable<MemoryDataSourceOptions['samples']>;
+/**
+ * Units on hand per product: each product's Skus' stock levels summed. A
+ * product with no stock row has no entry, so the list can show a dash.
+ */
+export declare function stockByProduct(skus: readonly ModelRecord[], levels: readonly ModelRecord[]): Map<string, number>;
+/** Deletes for a product and everything the forms saved under it. */
+export declare function planProductDelete(productId: string, skus: readonly ModelRecord[], models: ModelLookup): RecordWrite[];

package/dist/forms/stock.js

@@ -0,0 +1,104 @@
+import { fakeId, hashString } from "../data/fakes.js";
+import { getSamplePack } from "../data/packs.js";
+export const PRODUCT = '@happyvertical/smrt-products:Product';
+export const VARIANT = '@happyvertical/smrt-products:ProductVariant';
+export const SKU = '@happyvertical/smrt-products:Sku';
+export const STOCK_LEVEL = '@happyvertical/smrt-inventory:StockLevel';
+export const PROFILE_TYPE = '@happyvertical/smrt-profiles:ProfileType';
+export const LOCATION = '@happyvertical/smrt-inventory:InventoryLocation';
+/**
+ * Models the product forms write as children of a product. The demo data
+ * source starts them empty, so no sample row points at a product that is not
+ * there.
+ */
+export const SAVED_BY_FORMS = [VARIANT, SKU, STOCK_LEVEL, LOCATION];
+/**
+ * Sample locations (the active pack's), one SKU per sample product and a stock level for each SKU
+ * at the main location and (for about two in three) at the second, with a
+ * reorder point. The rows point at one another, so they are built together;
+ * a form still adds its own on top. Variants stay empty.
+ */
+export function stockSamples(models) {
+    return {
+        [LOCATION]: {
+            from: [],
+            make: () => (getSamplePack().locations ?? []).map((l, i) => ({
+                id: fakeId(`${LOCATION}:sample:${i}`),
+                ...l,
+                placeId: '',
+                active: true,
+            })),
+        },
+        [SKU]: {
+            from: [models(PRODUCT)],
+            make: ([products]) => (products ?? []).map((p, i) => ({
+                id: fakeId(`${SKU}:sample:${p.id}`),
+                productId: p.id,
+                code: `SKU-${String(i + 1).padStart(3, '0')}`,
+                barcode: '',
+                name: String(p.name ?? ''),
+                attributes: '',
+                parentSkuId: '',
+                active: true,
+            })),
+        },
+        [STOCK_LEVEL]: {
+            from: [models(SKU), models(LOCATION)],
+            make: ([skus, locations]) => {
+                const pack = getSamplePack();
+                const placed = new Map(pack.products.map((p) => [p.name, p.at]));
+                return (skus ?? []).flatMap((sku) => (locations ?? []).flatMap((location, j) => {
+                    const h = hashString(`${sku.id}:${location.id}`);
+                    // A pack may say where a product is counted; otherwise it is
+                    // at the first location and, for two in three, the second.
+                    const home = placed.get(String(sku.name));
+                    if (home !== undefined) {
+                        if (home !== j)
+                            return [];
+                    }
+                    else if (j > 0 && h % 3 === 0)
+                        return [];
+                    const reorderPoint = 10 + (h % 4) * 5;
+                    return [
+                        {
+                            id: fakeId(`${STOCK_LEVEL}:sample:${sku.id}:${location.id}`),
+                            skuId: sku.id,
+                            locationId: location.id,
+                            state: 'available',
+                            // Some rows sit at or under the reorder point.
+                            qty: h % 5 === 0 ? reorderPoint - 3 : reorderPoint + (h % 40),
+                            reorderPoint,
+                            reorderQuantity: reorderPoint * 3,
+                        },
+                    ];
+                }));
+            },
+        },
+    };
+}
+/**
+ * Units on hand per product: each product's Skus' stock levels summed. A
+ * product with no stock row has no entry, so the list can show a dash.
+ */
+export function stockByProduct(skus, levels) {
+    const productOf = new Map(skus.map((sku) => [sku.id, sku.productId]));
+    const totals = new Map();
+    for (const level of levels) {
+        const productId = productOf.get(String(level.skuId));
+        if (typeof productId !== 'string')
+            continue;
+        totals.set(productId, (totals.get(productId) ?? 0) + Number(level.qty ?? 0));
+    }
+    return totals;
+}
+/** Deletes for a product and everything the forms saved under it. */
+export function planProductDelete(productId, skus, models) {
+    return [
+        ...skus.flatMap((sku) => [
+            { op: 'delete', model: models(STOCK_LEVEL), match: { skuId: sku.id } },
+            { op: 'delete', model: models(SKU), id: sku.id },
+        ]),
+        { op: 'delete', model: models(VARIANT), match: { productId } },
+        { op: 'delete', model: models(PRODUCT), id: productId },
+    ];
+}

package/dist/forms/variantGrid.d.ts

@@ -0,0 +1,83 @@
+import type { CatalogField } from '../catalog/types.ts';
+import type { DataSource, ModelRecord, RecordWrite } from '../data/source.ts';
+import type { RecipeFormField, RecipeFormRecord, VariantGridForm } from '../recipes/types.ts';
+import type { ActiveForm } from './active.ts';
+import { type ModelLookup } from './shared.ts';
+/** One size x color (or whatever the axes are) combination. */
+export interface GridCombo {
+    /** Stable key: the values in axis order, as JSON. */
+    key: string;
+    /** `{ size: 'M', color: 'navy' }`: what `Sku.attributes` pins. */
+    attributes: Record<string, string>;
+    /** The values in axis order, for labels. */
+    values: string[];
+}
+/** What a variant-grid form holds while it is open. */
+export interface GridState {
+    /** Product inputs by form field id. */
+    values: Record<string, unknown>;
+    /** Values on offer per axis name, in the order shown. */
+    axes: Record<string, string[]>;
+    /** Per-cell extension inputs: cell key, then form field id. */
+    cells: Record<string, Record<string, unknown>>;
+}
+/** The rows a saved product already has, so a save can update and prune. */
+export interface ExistingGrid {
+    productId: string;
+    variants: ModelRecord[];
+    skus: ModelRecord[];
+}
+/**
+ * Split pasted lists on commas, trim, drop blanks and repeats
+ * (case-insensitively), keep the order.
+ */
+export declare function cleanValues(values: readonly string[]): string[];
+/**
+ * Every combination of the axes' values, rows in axis order. An axis with no
+ * values is left out, so a product with only sizes still gets a cell per size;
+ * no values anywhere means no cells.
+ */
+export declare function combinations(axes: readonly {
+    name: string;
+    values: readonly string[];
+}[]): GridCombo[];
+/** The grid's combinations for its current state. */
+export declare function gridCombos(form: VariantGridForm, state: Pick<GridState, 'axes'>): GridCombo[];
+/** Product inputs plus the per-cell inputs the extensions add. */
+export declare function gridParts(active: ActiveForm<VariantGridForm>): {
+    productFields: RecipeFormField[];
+    cellFields: RecipeFormField[];
+    cellRecords: RecipeFormRecord[];
+};
+/** Product inputs with the catalog field they map onto, for rendering. */
+export declare function gridProductInputs(active: ActiveForm<VariantGridForm>, models: ModelLookup): {
+    field: RecipeFormField;
+    catalogField: CatalogField;
+}[];
+/** Cell inputs with the catalog field they map onto. */
+export declare function gridCellInputs(active: ActiveForm<VariantGridForm>, models: ModelLookup): {
+    field: RecipeFormField;
+    catalogField: CatalogField;
+}[];
+/** An empty grid: starting values for the product inputs and every axis. */
+export declare function blankGrid(active: ActiveForm<VariantGridForm>, models: ModelLookup): GridState;
+/** The starting inputs of one cell. */
+export declare function blankCell(active: ActiveForm<VariantGridForm>, models: ModelLookup): Record<string, unknown>;
+/** Parse a JSON-string field (`allowedValues`, `attributes`), leniently. */
+export declare function parseJson(value: unknown): unknown;
+/** Load an existing product into a grid: its axes, then a cell per Sku. */
+export declare function loadGrid(source: DataSource, active: ActiveForm<VariantGridForm>, models: ModelLookup, productId: string): Promise<{
+    state: GridState;
+    existing: ExistingGrid;
+} | undefined>;
+/** The Sku code of a new cell: product, then each value, upper-cased. */
+export declare function skuCode(productName: unknown, combo: GridCombo): string;
+/**
+ * The related writes that save a variant grid: the product, one
+ * `ProductVariant` per axis that has values (and a delete for one that no
+ * longer does), a `Sku` per combination with its `attributes` pinned (Skus of
+ * combinations that went away are deleted with the rows the extensions keep
+ * under them), then each extension's rows per cell. Pure; `apply` runs it
+ * all or nothing.
+ */
+export declare function planGridSave(active: ActiveForm<VariantGridForm>, models: ModelLookup, state: GridState, existing?: ExistingGrid): RecordWrite[];