@builder-builder/builder 0.0.26 → 0.0.28

package/dist/mappers/dependencies.js

@@ -0,0 +1,44 @@
+import { BuilderPathSchema, BuilderPathsSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../entities/index.js';
+import { check } from '../errors/index.js';
+export function dependencies(model) {
+    const entries = [...model.options, ...model.collections, ...model.components];
+    const names = new Set(entries.map((entry) => entry.name));
+    const ordered = [];
+    const visiting = new Set();
+    const visit = (name) => {
+        if (ordered.includes(name)) {
+            return true;
+        }
+        if (visiting.has(name)) {
+            return false;
+        }
+        const entry = entries.find((candidate) => candidate.name === name);
+        check.invariant(entry);
+        visiting.add(name);
+        const resolved = dependencyKeys(entry.payload, entry.paths)
+            .filter((dependency) => names.has(dependency))
+            .map((dependency) => visit(dependency))
+            .every(Boolean);
+        visiting.delete(name);
+        if (resolved) {
+            ordered.push(name);
+        }
+        return resolved;
+    };
+    names.forEach((name) => visit(name));
+    return ordered;
+}
+export function dependencyKeys(payload, paths = []) {
+    const conditionPaths = check.is(BuilderPathsSchema, paths) ? paths : [];
+    const keys = new Set(conditionPaths.map(([first]) => String(first)));
+    if (check.is(BuilderWhenMatchSchema, payload) && check.is(BuilderPathSchema, payload.matchPath)) {
+        const [firstMatchSegment] = payload.matchPath;
+        keys.add(String(firstMatchSegment));
+    }
+    else if (check.is(BuilderWhenUnlessSchema, payload) &&
+        check.is(BuilderPathSchema, payload.unlessPath)) {
+        const [firstUnlessSegment] = payload.unlessPath;
+        keys.add(String(firstUnlessSegment));
+    }
+    return Array.from(keys);
+}

package/dist/mappers/index.d.ts

@@ -1,9 +1,9 @@
 export type { BuilderOrder } from './order';
 export type { BuilderRenderCollection, BuilderRenderCollectionAddRemove, BuilderRenderCollections, BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderOptionUpdate, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } from './render/index';
-export type { BuilderOptionGraph } from './variants/index';
+export { dependencies, dependencyKeys } from './dependencies.js';
 export { createInstance } from './instance.js';
 export { order } from './order.js';
 export { price } from './price.js';
 export { ordinal, render } from './render/index.js';
 export { resolveCollection, resolveCollections, resolveComponent, resolveComponents, resolveOption, resolveOptions } from './resolve.js';
-export { createVariants, optionGraph, variantsFor } from './variants/index.js';
+export { createVariants } from './variants/index.js';

package/dist/mappers/index.js

@@ -1,6 +1,7 @@
+export { dependencies, dependencyKeys } from './dependencies.js';
 export { createInstance } from './instance.js';
 export { order } from './order.js';
 export { price } from './price.js';
 export { ordinal, render } from './render/index.js';
 export { resolveCollection, resolveCollections, resolveComponent, resolveComponents, resolveOption, resolveOptions } from './resolve.js';
-export { createVariants, optionGraph, variantsFor } from './variants/index.js';
+export { createVariants } from './variants/index.js';

package/dist/mappers/instance.js

@@ -1,6 +1,7 @@
 import { modelsMerge, optionValueSchema } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { BuilderInstanceSchema, BuilderInstancesSchema } from '../instance.js';
+import { dependencies } from './dependencies.js';
 import { resolveCollection, resolveOption } from './resolve.js';
 export function createInstance(entity, partial = {}, references = []) {
     const model = 'model' in entity ? entity.model : entity;
@@ -10,31 +11,35 @@ export function createInstance(entity, partial = {}, references = []) {
 }
 function buildInstance(model, partial, references) {
     const merged = modelsMerge(model);
+    const names = dependencies(merged);
     let instance = { ...partial };
-    merged.options.forEach((option) => {
-        const { name } = option;
-        const payload = resolveOption(option, model, instance, references);
-        if (payload == null) {
+    names.forEach((name) => {
+        const option = merged.options.find((entry) => entry.name === name);
+        if (option != null) {
+            const payload = resolveOption(option, model, instance, references);
+            if (payload == null) {
+                return;
+            }
+            if (check.is(optionValueSchema(payload), instance[name])) {
+                return;
+            }
+            instance = { ...instance, [name]: payload.defaultValue };
             return;
         }
-        if (check.is(optionValueSchema(payload), instance[name])) {
-            return;
-        }
-        instance = { ...instance, [name]: payload.defaultValue };
-    });
-    merged.collections.forEach((collection) => {
-        const { name } = collection;
-        const payload = resolveCollection(collection, model, instance, references);
-        if (payload == null) {
-            return;
+        const collection = merged.collections.find((entry) => entry.name === name);
+        if (collection != null) {
+            const payload = resolveCollection(collection, model, instance, references);
+            if (payload == null) {
+                return;
+            }
+            const existing = instance[name];
+            const existingItems = check.is(BuilderInstancesSchema, existing)
+                ? existing
+                : [];
+            const count = Math.min(Math.max(existingItems.length, payload.min), payload.max);
+            const items = Array.from({ length: count }, (_, index) => buildInstance(payload.model, existingItems[index] ?? {}, references));
+            instance = { ...instance, [name]: items };
         }
-        const existing = instance[name];
-        const existingItems = check.is(BuilderInstancesSchema, existing)
-            ? existing
-            : [];
-        const count = Math.max(existingItems.length, payload.min);
-        const items = Array.from({ length: count }, (_, index) => buildInstance(payload.model, existingItems[index] ?? {}, references));
-        instance = { ...instance, [name]: items };
     });
     return instance;
 }

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

@@ -16,8 +16,10 @@ export function price(pricingInput, order) {
         }
         switch (expression.kind) {
             case 'variantPrice':
+                check.invariant(variant);
                 return variantPrice(variant);
             case 'lookup':
+                check.invariant(variant);
                 return evaluateLookup(expression, variant);
             case 'variants':
                 return evaluateVariants(expression);
@@ -50,8 +52,8 @@ export function price(pricingInput, order) {
         return value;
     }
     function variantPrice(variant) {
-        const candidate = variant?.details?.price;
-        return check.is(NumberSchema, candidate) ? candidate : null;
+        const price = Object.values(variant.details ?? {}).find((detail) => detail.kind === 'price');
+        return check.is(NumberSchema, price?.value) ? price?.value : null;
     }
     function evaluateLookup(expression, variant) {
         const keys = resolveKey(expression.key, variant);
@@ -75,9 +77,9 @@ export function price(pricingInput, order) {
     function resolveKey(key, variant) {
         switch (key.kind) {
             case 'variantTags':
-                return variant?.tags ?? [];
+                return variant.tags ?? [];
             case 'option': {
-                const value = variant?.instance?.[key.name];
+                const value = variant.instance[key.name];
                 return value == null ? [] : [String(value)];
             }
         }

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

@@ -14,6 +14,7 @@ export type BuilderRenderOption = Readonly<{
     option: BuilderOptionConfigSerialised;
     displayName?: string;
     kind?: string;
+    placeholderLabel?: string;
     metadata?: BuilderRenderMetadata;
 }>;
 export type BuilderRenderOptions = ReadonlyArray<BuilderRenderOption>;

package/dist/mappers/render/option.js

@@ -20,6 +20,7 @@ export function renderOption(input, path, builder, model, instance, references)
         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/variants/index.d.ts

@@ -1,2 +1 @@
-export { BuilderOptionGraph } from './option-graph.js';
-export { createVariants, optionGraph, variantsFor } from './variants.js';
+export { createVariants } from './variants.js';

package/dist/mappers/variants/index.js

@@ -1,2 +1 @@
-export { BuilderOptionGraph } from './option-graph.js';
-export { createVariants, optionGraph, variantsFor } from './variants.js';
+export { createVariants } from './variants.js';

package/dist/mappers/variants/option-graph.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderModelValidated, BuilderOptionValidated, BuilderPaths } from '../../entities/index';
+import type { BuilderModelValidated, BuilderOptionValidated } from '../../entities/index';
 import type { BuilderInstances } from '../../instance';
 export type GraphKeys = ReadonlySet<string>;
 export type GraphPath = {
@@ -8,7 +8,6 @@ export type GraphPath = {
 };
 export type GraphPaths = ReadonlyArray<GraphPath>;
 export declare function crossProduct(left: BuilderInstances, right: BuilderInstances): BuilderInstances;
-export declare function dependencyKeys(payload: unknown, paths?: BuilderPaths): ReadonlyArray<string>;
 export declare class BuilderOptionGraph {
     #private;
     readonly paths: GraphPaths;

package/dist/mappers/variants/option-graph.js

@@ -1,5 +1,5 @@
-import { BuilderPathSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../../entities/index.js';
 import { check } from '../../errors/index.js';
+import { dependencyKeys } from '../dependencies.js';
 import { resolveOption } from '../resolve.js';
 export function crossProduct(left, right) {
     return left.flatMap((leftModel) => right.flatMap((rightModel) => {
@@ -11,20 +11,6 @@ export function crossProduct(left, right) {
         return [{ ...leftModel, ...rightModel }];
     }));
 }
-export function dependencyKeys(payload, paths = []) {
-    const keys = new Set(paths.map(([first]) => String(first)));
-    if (check.is(BuilderWhenMatchSchema, payload)) {
-        check.assert(BuilderPathSchema, payload.matchPath);
-        const [firstMatchSegment] = payload.matchPath;
-        keys.add(String(firstMatchSegment));
-    }
-    else if (check.is(BuilderWhenUnlessSchema, payload)) {
-        check.assert(BuilderPathSchema, payload.unlessPath);
-        const [firstUnlessSegment] = payload.unlessPath;
-        keys.add(String(firstUnlessSegment));
-    }
-    return Array.from(keys);
-}
 export class BuilderOptionGraph {
     paths;
     constructor(paths = []) {
@@ -86,10 +72,10 @@ export class BuilderOptionGraph {
         if (values.type === 'select') {
             return [...values.options];
         }
-        if (values.valueType === 'boolean') {
+        if (values.kind === 'boolean') {
             return values.isOptional ? [true, false, null] : [true, false];
         }
-        if (values.valueType === 'string') {
+        if (values.kind === 'string') {
             return values.isOptional ? [name, null] : [name];
         }
         return values.isOptional ? [1, null] : [1];

package/dist/mappers/variants/variants.d.ts

@@ -1,6 +1,3 @@
-import type { BuilderCollectionValidated, BuilderComponentValidated, BuilderModelValidated, BuilderValidated } from '../../entities/index';
-import type { BuilderVariants, BuilderInstances } from '../../instance';
-import { BuilderOptionGraph } from './option-graph.js';
-export declare function createVariants(entity: BuilderValidated | BuilderModelValidated): BuilderVariants;
-export declare function optionGraph(model: BuilderModelValidated): BuilderOptionGraph;
-export declare function variantsFor(entity: BuilderComponentValidated | BuilderCollectionValidated, options: BuilderOptionGraph): BuilderInstances;
+import type { BuilderModelValidated, BuilderReferences, BuilderValidated } from '../../entities/index';
+import type { BuilderVariants } from '../../instance';
+export declare function createVariants(entity: BuilderValidated | BuilderModelValidated, references?: BuilderReferences): BuilderVariants;

package/dist/mappers/variants/variants.js

@@ -1,34 +1,57 @@
 import { BuilderModelSerialisedSchema, BuilderSerialisedSchema, modelsMerge } from '../../entities/index.js';
 import { check } from '../../errors/index.js';
-import { resolveCollection } from '../resolve.js';
-import { BuilderOptionGraph, crossProduct, dependencyKeys } from './option-graph.js';
-export function createVariants(entity) {
+import { dependencies, dependencyKeys } from '../dependencies.js';
+import { resolveCollection, resolveComponent } from '../resolve.js';
+import { BuilderOptionGraph, crossProduct } from './option-graph.js';
+export function createVariants(entity, references = []) {
     const model = check.is(BuilderSerialisedSchema, entity) ? entity.model : entity;
-    return buildVariants(model);
+    return buildVariants(model, references);
 }
-function buildVariants(model) {
+function buildVariants(model, references) {
     const merged = modelsMerge(model);
     const options = optionGraph(merged);
     const nestedVariants = merged.collections.flatMap((entry) => variantsFor(entry, options).flatMap((instance) => {
-        const resolved = resolveCollection(entry, merged, instance);
+        const resolved = resolveCollection(entry, merged, instance, references);
         if (resolved == null) {
             return [];
         }
         check.assert(BuilderModelSerialisedSchema, resolved.model);
-        return [buildVariants(resolved.model)];
+        return [buildVariants(resolved.model, references)];
     }));
     return {
         ...nestedVariants.reduce((accumulated, component) => ({ ...accumulated, ...component }), {}),
         ...Object.fromEntries(merged.components.map((component) => [
             component.name,
-            variantsFor(component, options).map((instance) => ({ instance }))
+            componentVariants(component, merged, options, references)
         ]))
     };
 }
-export function optionGraph(model) {
-    return model.options.reduce((graph, option) => graph.add(option, model), new BuilderOptionGraph());
+function componentVariants(component, model, options, references) {
+    return variantsFor(component, options).map((instance) => {
+        const resolved = resolveComponent(component, model, instance, references);
+        const declarations = resolved?.details ?? [];
+        const details = Object.fromEntries(declarations.map((declaration) => {
+            const { name, kind } = declaration;
+            return [name, { kind, value: null }];
+        }));
+        if (Object.keys(details).length === 0) {
+            return { instance };
+        }
+        return { instance, details };
+    });
+}
+function optionGraph(model) {
+    const names = dependencies(model);
+    let graph = new BuilderOptionGraph();
+    names.forEach((name) => {
+        const option = model.options.find((entry) => entry.name === name);
+        if (option != null) {
+            graph = graph.add(option, model);
+        }
+    });
+    return graph;
 }
-export function variantsFor(entity, options) {
+function variantsFor(entity, options) {
     const keys = new Set(dependencyKeys(entity.payload, entity.paths));
     const graphPaths = Array.from(keys)
         .map((key) => options.get(key))

package/dist/primitive.d.ts

@@ -4,7 +4,10 @@ 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 UrlSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, 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)[]>]>;
 export type BuilderPrimitives = v.InferOutput<typeof BuilderPrimitivesSchema>;
+export declare const BuilderPrimitivesNonEmptySchema: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>], v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, v.ReadonlyAction<[string | number | boolean | null, ...(string | number | boolean | null)[]]>]>;
+export type BuilderPrimitivesNonEmpty = v.InferOutput<typeof BuilderPrimitivesNonEmptySchema>;

package/dist/primitive.js

@@ -4,5 +4,7 @@ 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 UrlSchema = v.pipe(StringSchema, v.url());
 export const BuilderPrimitiveSchema = v.nullable(v.union([StringSchema, BooleanSchema, NumberSchema]));
 export const BuilderPrimitivesSchema = v.pipe(v.array(BuilderPrimitiveSchema), v.readonly());
+export const BuilderPrimitivesNonEmptySchema = v.pipe(v.tupleWithRest([BuilderPrimitiveSchema], BuilderPrimitiveSchema), v.readonly());

package/dist/public.d.ts

@@ -1,15 +1,15 @@
 export type { BB, BBOptions, BuilderEntityValidators } from './bb';
-export type { Builder, BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentConfig, BuilderComponentConfigSerialised, BuilderComponentField, BuilderComponentFields, BuilderComponentFieldSerialised, BuilderComponentFieldsSerialised, BuilderComponentFieldValueType, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderEnableConfig, BuilderEntityKind, BuilderEntitySerialised, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderInstanceOf, BuilderInstanceValidated, BuilderMatchConfig, BuilderMatchSelectMap, BuilderModel, BuilderModels, BuilderModelSerialised, BuilderModelValidated, BuilderOption, BuilderOptionConfig, BuilderOptionConfigSerialised, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderPath, BuilderPaths, BuilderPricing, BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce, BuilderPricingSerialised, BuilderReference, BuilderReferences, BuilderSelectConfig, BuilderSelectConfigLabels, BuilderSelectConfigSerialised, BuilderSelectConfigValues, BuilderSerialised, BuilderTags, BuilderToggleConfig, BuilderToggleConfigSerialised, BuilderToggleValueType, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIInput, BuilderUIInputMetadata, BuilderUIInputMetadataSerialised, BuilderUIInputs, BuilderUIInputSerialised, BuilderUIInputsSerialised, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIs, BuilderUISerialised, BuilderUIsSerialised, BuilderUIValidated, BuilderUnlessConfig, BuilderValidated, BuilderVariantsValidated, BuilderWhen, BuilderWhenConfig, BuilderWhenSerialised } from './entities/index';
+export type { Builder, BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentConfig, BuilderComponentConfigSerialised, BuilderComponentDetail, BuilderComponentDetailKind, BuilderComponentDetails, BuilderComponentDetailSerialised, BuilderComponentDetailsSerialised, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderEnableConfig, BuilderEntityKind, BuilderEntitySerialised, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderInstanceOf, BuilderInstanceValidated, BuilderMatchConfig, BuilderMatchSelectMap, BuilderModel, BuilderModels, BuilderModelSerialised, BuilderModelValidated, BuilderOption, BuilderOptionConfig, BuilderOptionConfigSerialised, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderPath, BuilderPaths, BuilderPricing, BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce, BuilderPricingSerialised, BuilderReference, BuilderReferences, BuilderSelectConfig, BuilderSelectConfigLabels, BuilderSelectConfigSerialised, BuilderSelectConfigValues, BuilderSerialised, BuilderTags, BuilderToggleConfig, BuilderToggleConfigSerialised, BuilderToggleKind, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIInput, BuilderUIInputMetadata, BuilderUIInputMetadataSerialised, BuilderUIInputs, BuilderUIInputSerialised, BuilderUIInputsSerialised, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIs, BuilderUISerialised, BuilderUIsSerialised, BuilderUIValidated, BuilderUnlessConfig, BuilderValidated, BuilderVariantsValidated, BuilderWhen, BuilderWhenConfig, BuilderWhenSerialised } from './entities/index';
 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 { BuilderIssue, BuilderIssueLocation, BuilderIssues } from './errors/index';
+export type { BuilderIssueKind } from './errors/index.js';
+export type { BuilderComponentVariant, BuilderComponentVariants, BuilderInstance, BuilderInstanceInput, BuilderInstances, BuilderVariantDetail, BuilderVariants } from './instance';
 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';
 export { bb } from './bb.js';
-export { builder, detailBoolean, detailNumber, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { builder, detailBoolean, detailImage, detailNumber, detailPrice, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
 export { BuilderException } from './errors/index.js';
 export { ordinal } from './mappers/index.js';
 export { parameter, ref } from './references.js';
@@ -17,12 +17,12 @@ import { collectionConfig, collectionExpectation, componentConfig, componentExpe
 export declare const collection: typeof collectionConfig & {
     enable: <const Values extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>(values: Values) => import("./public").BuilderEnableConfig<Values>;
     match: <const MatchPayload extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./public").BuilderUnlessConfig<Values, UnlessPath>;
+    unless: <const Values extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitivesNonEmpty, values: Values) => import("./public").BuilderUnlessConfig<Values, UnlessPath>;
 };
 export declare const component: typeof componentConfig & {
     enable: <const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>>(payload?: Payload) => import("./public").BuilderEnableConfig<Payload>;
     match: <const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderComponentConfig>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<Payload, MatchPath, SelectMap>;
-    unless: <const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>, const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, payload?: Payload) => import("./public").BuilderUnlessConfig<Payload, UnlessPath>;
+    unless: <const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>, const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitivesNonEmpty, payload?: Payload) => import("./public").BuilderUnlessConfig<Payload, UnlessPath>;
 };
 export declare const has: {
     collection: typeof collectionExpectation;
@@ -32,6 +32,6 @@ export declare const has: {
 export declare const option: {
     enable: <const Values extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("./public").BuilderEnableConfig<Values>;
     match: <const MatchPayload extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./public").BuilderUnlessConfig<Values, UnlessPath>;
+    unless: <const Values extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitivesNonEmpty, values: Values) => import("./public").BuilderUnlessConfig<Values, UnlessPath>;
 };
 export declare const ui: typeof uis;

package/dist/public.js

@@ -1,5 +1,5 @@
 export { bb } from './bb.js';
-export { builder, detailBoolean, detailNumber, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { builder, detailBoolean, detailImage, detailNumber, detailPrice, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
 export { BuilderException } from './errors/index.js';
 export { ordinal } from './mappers/index.js';
 export { parameter, ref } from './references.js';

package/dist/validate/builder.d.ts

@@ -1,4 +1,4 @@
 import type { BuilderReferences, BuilderValidated, ValidationResult } from '../entities/index';
-import { BuilderErrorsScope } from '../errors/index.js';
+import { BuilderIssuesScope } from '../errors/index.js';
 export type BuilderValidationResult = ValidationResult<BuilderValidated>;
-export declare function validateBuilder(input: unknown, references?: BuilderReferences, errors?: BuilderErrorsScope): BuilderValidationResult;
+export declare function validateBuilder(input: unknown, references?: BuilderReferences, issues?: BuilderIssuesScope): BuilderValidationResult;

package/dist/validate/builder.js

@@ -1,30 +1,30 @@
 import { builder, BuilderSerialisedSchema, modelsMerge, serialise } from '../entities/index.js';
-import { BuilderErrorsScope, check } from '../errors/index.js';
+import { BuilderIssuesScope, check } from '../errors/index.js';
 import { validate } from './brand.js';
 import { checkModelExpectations, validateModelStructure } from './model.js';
 import { checkPricingExpectations, validatePricingStructure } from './pricing.js';
 import { resolver } from './resolve.js';
 import { checkUIExpectations, validateUIStructure } from './ui.js';
 const EMPTY_BUILDER = validate(serialise.builder(builder()));
-export function validateBuilder(input, references = [], errors = new BuilderErrorsScope(input)) {
+export function validateBuilder(input, references = [], issues = new BuilderIssuesScope(input)) {
     if (!check.is(BuilderSerialisedSchema, input)) {
-        errors.entityInvalid('builder');
-        return [EMPTY_BUILDER, errors.errors];
+        issues.entityInvalid('builder');
+        return [EMPTY_BUILDER, issues.errors, issues.warnings];
     }
-    const resolve = resolver(errors, references, input.bindings);
-    const validatedModel = errors.scope('model', () => validateModelStructure(input.model, resolve, errors));
+    const resolve = resolver(issues, references, input.bindings);
+    const validatedModel = issues.scope('model', () => validateModelStructure(input.model, resolve, issues));
     const mergedModel = modelsMerge(validatedModel);
-    errors.scope('model', () => {
-        checkModelExpectations(mergedModel, validatedModel, errors);
+    issues.scope('model', () => {
+        checkModelExpectations(mergedModel, validatedModel, issues);
     });
-    const validatedUI = errors.scope('ui', () => {
-        const validated = validateUIStructure(input.ui, resolve, errors);
-        checkUIExpectations(mergedModel, validated, errors);
+    const validatedUI = issues.scope('ui', () => {
+        const validated = validateUIStructure(input.ui, resolve, issues);
+        checkUIExpectations(mergedModel, validated, issues);
         return validated;
     });
-    const validatedPricing = errors.scope('pricing', () => {
-        const validated = validatePricingStructure(input.pricing, resolve, errors);
-        checkPricingExpectations(mergedModel, validated, errors);
+    const validatedPricing = issues.scope('pricing', () => {
+        const validated = validatePricingStructure(input.pricing, resolve, issues);
+        checkPricingExpectations(mergedModel, validated, issues);
         return validated;
     });
     const data = validate({
@@ -33,5 +33,5 @@ export function validateBuilder(input, references = [], errors = new BuilderErro
         ui: validate(validatedUI),
         pricing: validate(validatedPricing)
     });
-    return [data, errors.errors];
+    return [data, issues.errors, issues.warnings];
 }

package/dist/validate/expectations.d.ts

@@ -1,3 +1,3 @@
 import type { BuilderExpectationsSerialised, BuilderModelSerialised } from '../entities/index';
-import type { BuilderErrorsScope } from '../errors/index';
-export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, errors: BuilderErrorsScope): void;
+import type { BuilderIssuesScope } from '../errors/index';
+export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, issues: BuilderIssuesScope): void;

package/dist/validate/expectations.js

@@ -1,10 +1,10 @@
-export function checkExpectations(model, expectations, errors) {
+export function checkExpectations(model, expectations, issues) {
     expectations.forEach(({ kind, name }, index) => {
-        errors.scope(index, () => {
+        issues.scope(index, () => {
             if (model[`${kind}s`].some((entry) => entry.name === name)) {
                 return;
             }
-            errors.modelUnmetExpectation();
+            issues.modelUnmetExpectation();
         });
     });
 }

package/dist/validate/instance.d.ts

@@ -1,5 +1,5 @@
 import type { BuilderInstanceValidated, BuilderModelValidated, ValidationResult } from '../entities/index';
 import type { BuilderInstance } from '../instance';
-import { BuilderErrorsScope } from '../errors/index.js';
+import { BuilderIssuesScope } from '../errors/index.js';
 export type BuilderInstanceValidationResult = ValidationResult<BuilderInstanceValidated>;
-export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance, errors?: BuilderErrorsScope): BuilderInstanceValidationResult;
+export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance, issues?: BuilderIssuesScope): BuilderInstanceValidationResult;

package/dist/validate/instance.js

@@ -1,15 +1,16 @@
-import { optionValueSchema } from '../entities/index.js';
-import { BuilderErrorsScope, check } from '../errors/index.js';
+import { modelsMerge, optionValueSchema } from '../entities/index.js';
+import { BuilderIssuesScope, check } from '../errors/index.js';
 import { BuilderInstancesSchema } from '../instance.js';
 import { resolveCollection, resolveOption } from '../mappers/index.js';
 import { validate } from './brand.js';
-export function validateInstance(model, instance, errors = new BuilderErrorsScope(instance)) {
-    errors.scope('instance', () => {
+export function validateInstance(model, instance, issues = new BuilderIssuesScope(instance)) {
+    issues.scope('instance', () => {
         checkInstance(model, instance);
     });
-    return [validate(instance), errors.errors];
+    return [validate(instance), issues.errors, issues.warnings];
     function checkInstance(scopeModel, scopeInstance) {
-        scopeModel.options.forEach((option) => {
+        const merged = modelsMerge(scopeModel);
+        merged.options.forEach((option) => {
             const { name } = option;
             const payload = resolveOption(option, scopeModel, scopeInstance);
             if (!payload) {
@@ -17,12 +18,12 @@ export function validateInstance(model, instance, errors = new BuilderErrorsScop
             }
             const value = scopeInstance[name];
             if (!check.is(optionValueSchema(payload), value)) {
-                errors.scope(name, () => {
-                    errors.instanceInvalidOption();
+                issues.scope(name, () => {
+                    issues.instanceInvalidOption();
                 });
             }
         });
-        scopeModel.collections.forEach((collection) => {
+        merged.collections.forEach((collection) => {
             const { name } = collection;
             const payload = resolveCollection(collection, scopeModel, scopeInstance);
             if (!payload) {
@@ -30,18 +31,35 @@ export function validateInstance(model, instance, errors = new BuilderErrorsScop
             }
             const existing = scopeInstance[name];
             if (!check.is(BuilderInstancesSchema, existing)) {
-                errors.scope(name, () => {
-                    errors.instanceInvalidCollection();
+                issues.scope(name, () => {
+                    issues.instanceInvalidCollection();
                 });
                 return;
             }
-            errors.scope(name, () => {
+            issues.scope(name, () => {
+                if (existing.length < payload.min) {
+                    issues.instanceInvalidCollectionMin();
+                }
+                else if (existing.length > payload.max) {
+                    issues.instanceInvalidCollectionMax();
+                }
                 existing.forEach((itemInstance, index) => {
-                    errors.scope(index, () => {
+                    issues.scope(index, () => {
                         checkInstance(payload.model, itemInstance);
                     });
                 });
             });
         });
+        const declaredNames = new Set([
+            ...merged.options.map((option) => option.name),
+            ...merged.collections.map((collection) => collection.name)
+        ]);
+        Object.keys(scopeInstance).forEach((key) => {
+            if (!declaredNames.has(key)) {
+                issues.scope(key, () => {
+                    issues.instanceUnexpectedKey();
+                });
+            }
+        });
     }
 }