@builder-builder/builder 0.0.25 → 0.0.27

package/dist/mappers/order.js

@@ -1,9 +1,11 @@
+import { modelsMerge } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { BuilderInstancesSchema } from '../instance.js';
 import { resolveCollection, resolveComponent } from './resolve.js';
 export function order(model, instance, variants, references = []) {
     const result = {};
-    model.components.forEach((component) => {
+    const merged = modelsMerge(model);
+    merged.components.forEach((component) => {
         if (resolveComponent(component, model, instance, references) == null) {
             return;
         }
@@ -11,7 +13,7 @@ export function order(model, instance, variants, references = []) {
         result[component.name] =
             componentVariants.find((variant) => Object.entries(variant.instance).every(([key, value]) => instance[key] === value)) ?? null;
     });
-    model.collections.forEach((collection) => {
+    merged.collections.forEach((collection) => {
         const { name } = collection;
         const payload = resolveCollection(collection, model, instance, references);
         if (payload == null) {

package/dist/mappers/price.js

@@ -1,8 +1,7 @@
-import * as v from 'valibot';
 import { BuilderPricingExpressionSchema } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { BuilderComponentVariantSchema } from '../instance.js';
-const NumberSchema = v.number();
+import { NumberSchema } from '../primitive.js';
 export function price(pricingInput, order) {
     const { rates, formula } = pricingInput;
     if (formula == null) {

package/dist/mappers/render/collection.d.ts

@@ -0,0 +1,9 @@
+import type { BuilderPath, BuilderReferences, BuilderValidated } from '../../entities/index';
+import type { BuilderInstance } from '../../instance';
+export type BuilderRenderCollectionAddRemove = (instance: BuilderInstance) => BuilderInstance;
+export type BuilderRenderCollection = Readonly<{
+    add?: BuilderRenderCollectionAddRemove;
+    remove?: BuilderRenderCollectionAddRemove;
+}>;
+export type BuilderRenderCollections = Readonly<Record<string, BuilderRenderCollection>>;
+export declare function renderCollection(itemsPath: BuilderPath, index: number, min: number, max: number, length: number, builder: BuilderValidated, references: BuilderReferences): BuilderRenderCollection;

package/dist/mappers/render/collection.js

@@ -0,0 +1,27 @@
+import { createInstance } from '../instance.js';
+import { readPath, writePath } from './paths.js';
+export function renderCollection(itemsPath, index, min, max, length, builder, references) {
+    let handlers = {};
+    if (length < max) {
+        handlers = {
+            ...handlers,
+            add: (updateInstance) => {
+                const current = (readPath(updateInstance, itemsPath) ?? []);
+                const clone = current[index] ?? {};
+                const next = [...current.slice(0, index + 1), clone, ...current.slice(index + 1)];
+                return createInstance(builder, writePath(updateInstance, itemsPath, next), references);
+            }
+        };
+    }
+    if (length > min) {
+        handlers = {
+            ...handlers,
+            remove: (updateInstance) => {
+                const current = (readPath(updateInstance, itemsPath) ?? []);
+                const next = [...current.slice(0, index), ...current.slice(index + 1)];
+                return createInstance(builder, writePath(updateInstance, itemsPath, next), references);
+            }
+        };
+    }
+    return handlers;
+}

package/dist/mappers/render/compose.d.ts

@@ -0,0 +1,5 @@
+import type { BuilderReferences } from '../../entities/index';
+import type { BuilderRenderMetadata } from './option';
+export declare function composeLabel(label: unknown, labels: ReadonlyArray<string>, references: BuilderReferences): string;
+export declare function composeString(value: unknown, references: BuilderReferences): string;
+export declare function composeMetadata(value: unknown, references: BuilderReferences): BuilderRenderMetadata;

package/dist/mappers/render/compose.js

@@ -0,0 +1,15 @@
+import { resolveReference } from '../resolve.js';
+import { StringSchema } from '../../primitive.js';
+import { BuilderRenderMetadataSchema } from './option.js';
+export function composeLabel(label, labels, references) {
+    return [...labels, composeString(label, references)]
+        .filter((segment) => segment !== '')
+        .join(', ');
+}
+export function composeString(value, references) {
+    return resolveReference(value, references, StringSchema);
+}
+export function composeMetadata(value, references) {
+    const resolved = resolveReference(value, references, BuilderRenderMetadataSchema);
+    return Object.fromEntries(Object.entries(resolved).map(([key, entry]) => [key, resolveReference(entry, references)]));
+}

package/dist/mappers/render/description.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderDescriptionItem, BuilderModelValidated, BuilderReferences, BuilderUIDescribeValidated } from '../../entities/index';
+import type { BuilderInstance } from '../../instance';
+export declare function renderDescription(describe: BuilderUIDescribeValidated, label: string, model: BuilderModelValidated, instance: BuilderInstance, references: BuilderReferences): BuilderDescriptionItem | null;

package/dist/mappers/render/description.js

@@ -0,0 +1,17 @@
+import { check } from '../../errors/index.js';
+import { BuilderPrimitiveSchema } from '../../primitive.js';
+import { resolvePath } from '../resolve.js';
+export function renderDescription(describe, label, model, instance, references) {
+    const values = describe.inputs.flatMap((input) => {
+        const found = resolvePath(model, instance, input.path, references);
+        if (found?.value == null) {
+            return [];
+        }
+        check.assert(BuilderPrimitiveSchema, found.value);
+        return [found.value];
+    });
+    if (values.length === 0) {
+        return null;
+    }
+    return [label, values.join(' ')];
+}

package/dist/mappers/render/index.d.ts

@@ -1,4 +1,6 @@
-export type { BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderUpdate } from './pages';
+export type { BuilderRenderCollection, BuilderRenderCollectionAddRemove, BuilderRenderCollections } from './collection';
+export type { BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptionUpdate, BuilderRenderOptions } from './option';
+export type { BuilderRenderPage, BuilderRenderPages } from './page';
 export type { BuilderRenderResult } from './render';
 export { render } from './render.js';
 export { ordinal } from './ordinal.js';

package/dist/mappers/render/option.d.ts

@@ -0,0 +1,21 @@
+import type { BuilderModelValidated, BuilderOptionConfigSerialised, BuilderPath, BuilderReferences, BuilderUIInputValidated, BuilderValidated } from '../../entities/index';
+import type { BuilderInstance } from '../../instance';
+import type { BuilderPrimitive } from '../../primitive';
+import * as v from 'valibot';
+export type BuilderRenderOptionUpdate = (instance: BuilderInstance, primitive: BuilderPrimitive) => BuilderInstance;
+export declare const BuilderRenderMetadataSchema: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.UnknownSchema, undefined>, v.ReadonlyAction<{
+    [x: string]: unknown;
+}>]>;
+export type BuilderRenderMetadata = v.InferOutput<typeof BuilderRenderMetadataSchema>;
+export type BuilderRenderOption = Readonly<{
+    name: string;
+    value: BuilderPrimitive;
+    update: BuilderRenderOptionUpdate;
+    option: BuilderOptionConfigSerialised;
+    displayName?: string;
+    kind?: string;
+    placeholderLabel?: string;
+    metadata?: BuilderRenderMetadata;
+}>;
+export type BuilderRenderOptions = ReadonlyArray<BuilderRenderOption>;
+export declare function renderOption(input: BuilderUIInputValidated, path: BuilderPath, builder: BuilderValidated, model: BuilderModelValidated, instance: BuilderInstance, references: BuilderReferences): BuilderRenderOption | null;

package/dist/mappers/render/option.js

@@ -0,0 +1,26 @@
+import * as v from 'valibot';
+import { check } from '../../errors/index.js';
+import { BuilderPrimitiveSchema, NameSchema } from '../../primitive.js';
+import { createInstance } from '../instance.js';
+import { resolvePath } from '../resolve.js';
+import { composeMetadata, composeString } from './compose.js';
+import { writePath } from './paths.js';
+export const BuilderRenderMetadataSchema = v.pipe(v.record(NameSchema, v.unknown()), v.readonly());
+export function renderOption(input, path, builder, model, instance, references) {
+    const found = resolvePath(model, instance, input.path, references);
+    if (found == null) {
+        return null;
+    }
+    const fullPath = [...path, ...input.path];
+    check.assert(BuilderPrimitiveSchema, found.value);
+    return {
+        name: found.name,
+        option: found.payload,
+        value: found.value,
+        update: (updateInstance, updateValue) => createInstance(builder, writePath(updateInstance, fullPath, updateValue), references),
+        displayName: input.displayName && composeString(input.displayName, references),
+        kind: input.kind && composeString(input.kind, references),
+        placeholderLabel: input.placeholderLabel && composeString(input.placeholderLabel, references),
+        metadata: input.metadata && composeMetadata(input.metadata, references)
+    };
+}

package/dist/mappers/render/page.d.ts

@@ -0,0 +1,11 @@
+import type { BuilderModelValidated, BuilderPath, BuilderReferences, BuilderUIPageValidated, BuilderValidated } from '../../entities/index';
+import type { BuilderInstance } from '../../instance';
+import type { BuilderRenderCollections } from './collection';
+import type { BuilderRenderOptions } from './option';
+export type BuilderRenderPage = Readonly<{
+    label: string;
+    options: BuilderRenderOptions;
+    collections: BuilderRenderCollections;
+}>;
+export type BuilderRenderPages = ReadonlyArray<BuilderRenderPage>;
+export declare function renderPage(page: BuilderUIPageValidated, label: string, path: BuilderPath, collections: BuilderRenderCollections, builder: BuilderValidated, model: BuilderModelValidated, instance: BuilderInstance, references: BuilderReferences): BuilderRenderPage | null;

package/dist/mappers/render/page.js

@@ -0,0 +1,11 @@
+import { renderOption } from './option.js';
+export function renderPage(page, label, path, collections, builder, model, instance, references) {
+    const options = page.inputs.flatMap((input) => {
+        const option = renderOption(input, path, builder, model, instance, references);
+        return option == null ? [] : [option];
+    });
+    if (options.length === 0) {
+        return null;
+    }
+    return { label, options, collections };
+}

package/dist/mappers/render/paths.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderPath } from '../../entities/index';
+export declare function readPath(container: unknown, path: BuilderPath): unknown;
+export declare function writePath(container: unknown, path: BuilderPath, value: unknown): unknown;

package/dist/mappers/render/paths.js

@@ -0,0 +1,21 @@
+import { check } from '../../errors/index.js';
+import { NumberSchema } from '../../primitive.js';
+export function readPath(container, path) {
+    return path.reduce((current, segment) => current == null ? undefined : current[segment], container);
+}
+export function writePath(container, path, value) {
+    if (path.length === 0) {
+        return value;
+    }
+    const [head, ...tail] = path;
+    if (check.is(NumberSchema, head)) {
+        const next = Array.isArray(container) ? [...container] : [];
+        next[head] = writePath(next[head], tail, value);
+        return next;
+    }
+    const next = container != null && !Array.isArray(container)
+        ? { ...container }
+        : {};
+    next[head] = writePath(next[head], tail, value);
+    return next;
+}

package/dist/mappers/render/render.d.ts

@@ -1,5 +1,5 @@
 import type { BuilderDescription, BuilderInstanceValidated, BuilderReferences, BuilderValidated } from '../../entities/index';
-import type { BuilderRenderPages } from './pages';
+import type { BuilderRenderPages } from './page';
 export type BuilderRenderResult = Readonly<{
     layout: BuilderRenderPages;
     description: BuilderDescription;

package/dist/mappers/render/render.js

@@ -1,120 +1,55 @@
-import * as v from 'valibot';
 import { check } from '../../errors/index.js';
 import { BuilderInstancesSchema } from '../../instance.js';
-import { BuilderPrimitiveSchema } from '../../primitive.js';
-import { createInstance } from '../instance.js';
-import { resolveCollection, resolvePath, resolveReference } from '../resolve.js';
+import { resolveCollection } from '../resolve.js';
+import { renderCollection } from './collection.js';
+import { composeLabel, composeString } from './compose.js';
+import { renderDescription } from './description.js';
 import { ordinal } from './ordinal.js';
-import { BuilderRenderMetadataSchema } from './pages.js';
+import { renderPage } from './page.js';
 export function render(builder, instance, references = []) {
     const layout = [];
     const description = [];
-    walkTree(builder.ui);
+    renderUITree(builder.ui);
     return { layout, description };
-    function walkTree(ui) {
-        ui.uis.forEach((nested) => walkTree(nested));
-        walkItems(ui.items, builder.model, [], [], instance);
+    function renderUITree(ui) {
+        ui.uis.forEach(renderUITree);
+        renderUIItems(ui.items, builder.model, instance, [], [], {});
     }
-    function walkItems(items, model, collectionPath, labelContext, currentInstance) {
+    function renderUIItems(items, model, instance, labels, path, collections) {
         items.forEach((item) => {
             if (item.type === 'page') {
-                emitPage(item, model, collectionPath, labelContext, currentInstance);
+                const page = renderPage(item, composeLabel(item.label, labels, references), path, collections, builder, model, instance, references);
+                if (page != null) {
+                    layout.push(page);
+                }
                 return;
             }
             if (item.type === 'describe') {
-                emitDescribe(item, model, labelContext, currentInstance);
+                const descriptionItem = renderDescription(item, composeLabel(item.label, labels, references), model, instance, references);
+                if (descriptionItem != null) {
+                    description.push(descriptionItem);
+                }
                 return;
             }
-            const collection = findCollection(model, currentInstance, item.name);
+            const definition = model.collections.find((candidate) => candidate.name === item.name);
+            if (definition == null) {
+                return;
+            }
+            const collection = resolveCollection(definition, model, instance, references);
             if (collection == null) {
                 return;
             }
-            const itemInstances = currentInstance[item.name];
-            check.assert(BuilderInstancesSchema, itemInstances);
-            const mergedItemModel = collection.model;
-            itemInstances.forEach((itemInstance, index) => {
-                walkItems(item.items, mergedItemModel, [...collectionPath, item.name, index], [...labelContext, `${ordinal(index)} ${composeLabel(item.label)}`], itemInstance);
+            const instances = instance[item.name];
+            check.assert(BuilderInstancesSchema, instances);
+            const itemsPath = [...path, item.name];
+            const { min, max } = collection;
+            const { length } = instances;
+            instances.forEach((itemInstance, index) => {
+                renderUIItems(item.items, collection.model, itemInstance, [...labels, `${ordinal(index)} ${composeString(item.label, references)}`], [...itemsPath, index], {
+                    ...collections,
+                    [item.name]: renderCollection(itemsPath, index, min, max, length, builder, references)
+                });
             });
         });
     }
-    function emitPage(page, model, collectionPath, labelContext, currentInstance) {
-        const options = page.inputs.flatMap((input) => {
-            const { path } = input;
-            const found = resolvePath(model, currentInstance, path, references);
-            if (found == null) {
-                return [];
-            }
-            const fullPath = [...collectionPath, ...path];
-            check.assert(BuilderPrimitiveSchema, found.value);
-            return [
-                {
-                    name: found.name,
-                    option: found.payload,
-                    value: found.value,
-                    update: (updateInstance, updateValue) => createInstance(builder, setPath(updateInstance, fullPath, updateValue), references),
-                    displayName: input.displayName && composeString(input.displayName),
-                    kind: input.kind && composeString(input.kind),
-                    metadata: input.metadata && composeMetadata(input.metadata)
-                }
-            ];
-        });
-        if (options.length === 0) {
-            return;
-        }
-        layout.push({ label: composeLabel(page.label, labelContext), options });
-    }
-    function emitDescribe(describe, model, labelContext, currentInstance) {
-        const composedLabel = composeLabel(describe.label, labelContext);
-        const values = describe.inputs.flatMap((input) => {
-            const { path } = input;
-            const found = resolvePath(model, currentInstance, path, references);
-            if (found?.value == null) {
-                return [];
-            }
-            check.assert(BuilderPrimitiveSchema, found.value);
-            return [found.value];
-        });
-        if (values.length === 0) {
-            return;
-        }
-        description.push([composedLabel, values.join(' ')]);
-    }
-    function composeLabel(label, labelContext = []) {
-        const resolved = resolveReference(label, references);
-        check.assert(v.string(), resolved);
-        if (labelContext.length === 0) {
-            return resolved;
-        }
-        if (resolved === '') {
-            return labelContext.join(', ');
-        }
-        return `${labelContext.join(', ')}, ${resolved}`;
-    }
-    function composeString(value) {
-        const resolved = resolveReference(value, references);
-        check.assert(v.string(), resolved);
-        return resolved;
-    }
-    function composeMetadata(value) {
-        const resolved = resolveReference(value, references);
-        check.assert(BuilderRenderMetadataSchema, resolved);
-        return Object.fromEntries(Object.entries(resolved).map(([key, entry]) => [key, resolveReference(entry, references)]));
-    }
-    function findCollection(model, instance, collectionName) {
-        const entry = model.collections.find((candidate) => candidate.name === collectionName);
-        return entry == null ? null : resolveCollection(entry, model, instance, references);
-    }
-}
-function setPath(container, path, value) {
-    const [head, ...tail] = path;
-    if (typeof head === 'number') {
-        const arrayContainer = container ? [...container] : [];
-        arrayContainer[head] = tail.length === 0 ? value : setPath(arrayContainer[head], tail, value);
-        return arrayContainer;
-    }
-    const objectContainer = container ? container : {};
-    return {
-        ...objectContainer,
-        [head]: tail.length === 0 ? value : setPath(objectContainer[head], tail, value)
-    };
 }

package/dist/mappers/resolve.d.ts

@@ -1,12 +1,13 @@
 import type { BuilderCollectionConfigsSerialised, BuilderCollectionConfigValidated, BuilderCollectionSerialised, BuilderCollectionValidated, BuilderComponentConfigsSerialised, BuilderComponentConfigValidated, BuilderComponentSerialised, BuilderComponentValidated, BuilderModelValidated, BuilderOptionConfigsSerialised, BuilderOptionConfigValidated, BuilderOptionSerialised, BuilderOptionValidated, BuilderPath, BuilderReferences } from '../entities/index';
 import type { BuilderInstance } from '../instance';
+import * as v from 'valibot';
 export declare function resolveOption(option: BuilderOptionValidated, model: BuilderModelValidated, instance: unknown, references?: BuilderReferences): BuilderOptionConfigValidated | null;
 export declare function resolveOptions(option: BuilderOptionSerialised, references?: BuilderReferences): BuilderOptionConfigsSerialised;
 export declare function resolveComponent(component: BuilderComponentValidated, model: BuilderModelValidated, instance: unknown, references?: BuilderReferences): BuilderComponentConfigValidated | null;
 export declare function resolveComponents(component: BuilderComponentSerialised, references?: BuilderReferences): BuilderComponentConfigsSerialised;
 export declare function resolveCollection(collection: BuilderCollectionValidated, model: BuilderModelValidated, instance: unknown, references?: BuilderReferences): BuilderCollectionConfigValidated | null;
 export declare function resolveCollections(collection: BuilderCollectionSerialised, references?: BuilderReferences): BuilderCollectionConfigsSerialised;
-export declare function resolveReference(value: unknown, references: BuilderReferences): unknown;
+export declare function resolveReference<Schema extends v.GenericSchema = v.GenericSchema<unknown>>(value: unknown, references: BuilderReferences, schema?: Schema): v.InferOutput<Schema>;
 export type ResolvedPath = {
     readonly name: string;
     readonly payload: BuilderOptionConfigValidated;

package/dist/mappers/resolve.js

@@ -1,38 +1,40 @@
 import * as v from 'valibot';
-import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderPathsSchema, BuilderWhenSerialisedSchema, modelsMerge, whenBranches } from '../entities/index.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderPathsSchema, modelsMerge, whenBranches } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { BuilderInstanceSchema, BuilderInstancesSchema } from '../instance.js';
-import { BuilderPrimitiveSchema } from '../primitive.js';
-import { BuilderRefSerialisedSchema } from '../references.js';
+import { BuilderPrimitiveSchema, NameSchema, NumberSchema } from '../primitive.js';
+import { BuilderRefSerialisedSchema, paramable } from '../references.js';
 export function resolveOption(option, model, instance, references = []) {
-    return resolveEntryInstance(option, BuilderOptionConfigSerialisedSchema, model, instance, references);
+    return resolveEntryInstance(option, BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema, model, instance, references);
 }
 export function resolveOptions(option, references = []) {
-    return resolveEntryExhaustive(option, BuilderOptionConfigSerialisedSchema, references);
+    return resolveEntryExhaustive(option, BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema, references);
 }
 export function resolveComponent(component, model, instance, references = []) {
-    return resolveEntryInstance(component, BuilderComponentConfigSerialisedSchema, model, instance, references);
+    return resolveEntryInstance(component, BuilderComponentConfigSerialisedSchema, BuilderComponentWhenSerialisedSchema, model, instance, references);
 }
 export function resolveComponents(component, references = []) {
-    return resolveEntryExhaustive(component, BuilderComponentConfigSerialisedSchema, references);
+    return resolveEntryExhaustive(component, BuilderComponentConfigSerialisedSchema, BuilderComponentWhenSerialisedSchema, references);
 }
 export function resolveCollection(collection, model, instance, references = []) {
-    return resolveEntryInstance(collection, BuilderCollectionConfigSerialisedSchema, model, instance, references);
+    return resolveEntryInstance(collection, BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema, model, instance, references);
 }
 export function resolveCollections(collection, references = []) {
-    return resolveEntryExhaustive(collection, BuilderCollectionConfigSerialisedSchema, references);
+    return resolveEntryExhaustive(collection, BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema, references);
 }
-export function resolveReference(value, references) {
-    if (!check.is(BuilderRefSerialisedSchema, value)) {
-        return value;
+export function resolveReference(value, references, schema = v.unknown()) {
+    let resolved = value;
+    if (check.is(BuilderRefSerialisedSchema, value)) {
+        const found = references.find((entry) => entry.id === value.id);
+        check.invariant(found);
+        resolved = found.serialised;
     }
-    const found = references.find((entry) => entry.id === value.id);
-    check.invariant(found);
-    return found.serialised;
+    check.assert(schema, resolved);
+    return resolved;
 }
 export function resolvePath(model, instance, path, references = []) {
     const optionName = path.at(-1);
-    check.assert(v.string(), optionName);
+    check.assert(NameSchema, optionName);
     const descended = resolveItems(model, instance, path.slice(0, -1), references);
     if (descended == null) {
         return null;
@@ -53,8 +55,8 @@ export function resolveItems(model, instance, pairs, references = []) {
         return [model, instance];
     }
     const [name, index, ...rest] = pairs;
-    check.assert(v.string(), name);
-    check.assert(v.number(), index);
+    check.assert(NameSchema, name);
+    check.assert(NumberSchema, index);
     const merged = modelsMerge(model);
     const collection = merged.collections.find((entry) => entry.name === name);
     check.invariant(collection);
@@ -70,12 +72,11 @@ export function resolveItems(model, instance, pairs, references = []) {
     }
     return resolveItems(resolved.model, item, rest, references);
 }
-function resolveEntryInstance(entry, schema, model, instance, references) {
-    const payload = resolveReference(entry.payload, references);
+function resolveEntryInstance(entry, schema, whenSchema, model, instance, references) {
+    const payload = resolveReference(entry.payload, references, paramable(v.union([schema, whenSchema])));
     if (check.is(schema, payload)) {
         return payload;
     }
-    check.assert(BuilderWhenSerialisedSchema, payload);
     check.assert(BuilderPathsSchema, entry.paths);
     const config = payload;
     if (!entry.paths.every((path) => Boolean(resolvePath(model, instance, path, references)?.value))) {
@@ -103,6 +104,6 @@ function resolveEntryInstance(entry, schema, model, instance, references) {
         }
     }
 }
-function resolveEntryExhaustive(entry, schema, references) {
-    return whenBranches(resolveReference(entry.payload, references), schema);
+function resolveEntryExhaustive(entry, schema, whenSchema, references) {
+    return whenBranches(resolveReference(entry.payload, references, paramable(v.union([schema, whenSchema]))), schema);
 }

package/dist/primitive.d.ts

@@ -1,4 +1,9 @@
 import * as v from 'valibot';
+export declare const StringSchema: v.StringSchema<undefined>;
+export declare const NumberSchema: v.NumberSchema<undefined>;
+export declare const BooleanSchema: v.BooleanSchema<undefined>;
+export declare const NameSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+export declare const IdSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 export declare const BuilderPrimitiveSchema: v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
 export type BuilderPrimitive = v.InferOutput<typeof BuilderPrimitiveSchema>;
 export declare const BuilderPrimitivesSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, v.ReadonlyAction<(string | number | boolean | null)[]>]>;

package/dist/primitive.js

@@ -1,3 +1,8 @@
 import * as v from 'valibot';
-export const BuilderPrimitiveSchema = v.nullable(v.union([v.string(), v.boolean(), v.number()]));
+export const StringSchema = v.string();
+export const NumberSchema = v.number();
+export const BooleanSchema = v.boolean();
+export const NameSchema = v.pipe(StringSchema, v.minLength(1));
+export const IdSchema = v.pipe(StringSchema, v.minLength(1));
+export const BuilderPrimitiveSchema = v.nullable(v.union([StringSchema, BooleanSchema, NumberSchema]));
 export const BuilderPrimitivesSchema = v.pipe(v.array(BuilderPrimitiveSchema), v.readonly());

package/dist/public.d.ts

@@ -4,7 +4,7 @@ export type { BuilderEnvironment } from './environment';
 export type { BuilderError, BuilderErrorLocation, BuilderErrors } from './errors/index';
 export type { BuilderErrorKind } from './errors/index.js';
 export type { BuilderComponentVariant, BuilderComponentVariants, BuilderInstance, BuilderInstanceInput, BuilderInstances, BuilderVariants } from './instance';
-export type { BuilderOrder, BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './mappers/index';
+export type { BuilderOrder, BuilderRenderCollection, BuilderRenderCollectionAddRemove, BuilderRenderCollections, BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderOptionUpdate, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } from './mappers/index';
 export type { BuilderPrimitive, BuilderPrimitives } from './primitive';
 export type { BuilderParameter, BuilderParameterSerialised, BuilderRef, Paramable, ParamableSerialised } from './references';
 export type { BuilderInstanceValidationResult, BuilderModelValidationResult, BuilderPricingValidationResult, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions, BuilderVariantsValidationResult } from './validate/index';

package/dist/references.d.ts

@@ -9,8 +9,8 @@ export declare class BuilderParameter<const Name extends string = string> {
 export declare const BuilderParameterSchema: v.InstanceSchema<typeof BuilderParameter, undefined>;
 export declare const BuilderParameterSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"parameter", undefined>;
-    readonly id: v.StringSchema<undefined>;
-    readonly name: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "parameter";
     id: string;
@@ -25,7 +25,7 @@ export declare class BuilderRef {
 export declare const BuilderRefSchema: v.InstanceSchema<typeof BuilderRef, undefined>;
 export declare const BuilderRefSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"ref", undefined>;
-    readonly id: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "ref";
     id: string;
@@ -35,15 +35,15 @@ export declare function parameter<const Name extends string>(name: Name): Builde
 export declare function ref(id: string): BuilderRef;
 export declare function paramable<Schema extends v.GenericSchema>(paramable: Schema): v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"parameter", undefined>;
-    readonly id: v.StringSchema<undefined>;
-    readonly name: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "parameter";
     id: string;
     name: string;
 }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"ref", undefined>;
-    readonly id: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "ref";
     id: string;

package/dist/references.js

@@ -1,5 +1,6 @@
 import * as v from 'valibot';
 import { check } from './errors/index.js';
+import { IdSchema, NameSchema } from './primitive.js';
 export class BuilderParameter {
     id;
     name;
@@ -9,7 +10,7 @@ export class BuilderParameter {
     }
 }
 export const BuilderParameterSchema = v.instance(BuilderParameter);
-export const BuilderParameterSerialisedSchema = v.pipe(v.object({ type: v.literal('parameter'), id: v.string(), name: v.string() }), v.readonly());
+export const BuilderParameterSerialisedSchema = v.pipe(v.object({ type: v.literal('parameter'), id: IdSchema, name: NameSchema }), v.readonly());
 export class BuilderRef {
     type = 'ref';
     id;
@@ -18,7 +19,7 @@ export class BuilderRef {
     }
 }
 export const BuilderRefSchema = v.instance(BuilderRef);
-export const BuilderRefSerialisedSchema = v.pipe(v.object({ type: v.literal('ref'), id: v.string() }), v.readonly());
+export const BuilderRefSerialisedSchema = v.pipe(v.object({ type: v.literal('ref'), id: IdSchema }), v.readonly());
 export function parameter(name) {
     return new BuilderParameter(name);
 }