@builder-builder/builder 0.0.9 → 0.0.11

package/dist/index.js

@@ -1,6 +1,8 @@
-import { builders, collectionConfig, collectionExpectation, collectionWhen, componentDetails, componentExpectation, componentWhen, detailExpectation, optionExpectation, optionWhen, uis } from './entities/index.js';
-import { createInstance, createModels } from './mappers/index.js';
-export const builder = builders;
+export { bb } from './bb.js';
+export { Builder, builder, detailBoolean, detailNumber, detailString, model, parameter, ref, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { BuilderException } from './exception.js';
+export { ordinal } from './mappers/index.js';
+import { collectionConfig, collectionExpectation, collectionWhen, componentDetails, componentExpectation, componentWhen, optionExpectation, optionWhen, uis } from './entities/index.js';
 export const collection = Object.assign(collectionConfig, {
     ...collectionWhen
 });
@@ -10,14 +12,7 @@ export const component = Object.assign(componentDetails, {
 export const has = {
     collection: collectionExpectation,
     component: componentExpectation,
-    detail: detailExpectation,
     option: optionExpectation
 };
-export const instance = createInstance;
-export const models = createModels;
 export const option = optionWhen;
 export const ui = uis;
-export { BuilderException } from './exception.js';
-export { BuilderSerialisedSchema } from './entities/builder/index.js';
-export { deserialise, parameter, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
-export { order, ordinal, render } from './mappers/index.js';

package/dist/instance.d.ts

@@ -0,0 +1,56 @@
+import * as v from 'valibot';
+import { type BuilderPrimitive } from './primitive.js';
+export type BuilderInstance = {
+    readonly [key: string]: BuilderPrimitive | BuilderInstances;
+};
+export declare const BuilderInstanceSchema: v.GenericSchema<BuilderInstance>;
+export declare const BuilderInstancesSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<BuilderInstance>, undefined>, v.ReadonlyAction<BuilderInstance[]>]>;
+export type BuilderInstances = v.InferOutput<typeof BuilderInstancesSchema>;
+export type BuilderInstanceInput = Readonly<Record<string, unknown>>;
+export declare const BuilderVariantSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly instance: v.GenericSchema<BuilderInstance>;
+    readonly details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
+}, undefined>, v.ReadonlyAction<{
+    instance: BuilderInstance;
+    details?: {
+        [x: string]: string | number | boolean | null;
+    } | undefined;
+}>]>;
+export type BuilderVariant = v.InferOutput<typeof BuilderVariantSchema>;
+export declare const BuilderVariantsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly instance: v.GenericSchema<BuilderInstance>;
+    readonly details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
+}, undefined>, v.ReadonlyAction<{
+    instance: BuilderInstance;
+    details?: {
+        [x: string]: string | number | boolean | null;
+    } | undefined;
+}>]>, undefined>, v.ReadonlyAction<Readonly<{
+    instance: BuilderInstance;
+    details?: {
+        [x: string]: string | number | boolean | null;
+    } | undefined;
+}>[]>]>;
+export type BuilderVariants = v.InferOutput<typeof BuilderVariantsSchema>;
+export declare const BuilderComponentVariantsSchema: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly instance: v.GenericSchema<BuilderInstance>;
+    readonly details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
+}, undefined>, v.ReadonlyAction<{
+    instance: BuilderInstance;
+    details?: {
+        [x: string]: string | number | boolean | null;
+    } | undefined;
+}>]>, undefined>, v.ReadonlyAction<Readonly<{
+    instance: BuilderInstance;
+    details?: {
+        [x: string]: string | number | boolean | null;
+    } | undefined;
+}>[]>]>, undefined>, v.ReadonlyAction<{
+    readonly [x: string]: readonly Readonly<{
+        instance: BuilderInstance;
+        details?: {
+            [x: string]: string | number | boolean | null;
+        } | undefined;
+    }>[];
+}>]>;
+export type BuilderComponentVariants = v.InferOutput<typeof BuilderComponentVariantsSchema>;

package/dist/instance.js

@@ -0,0 +1,10 @@
+import * as v from 'valibot';
+import { BuilderPrimitiveSchema } from './primitive.js';
+export const BuilderInstanceSchema = v.pipe(v.record(v.string(), v.union([BuilderPrimitiveSchema, v.lazy(() => BuilderInstancesSchema)])), v.readonly());
+export const BuilderInstancesSchema = v.pipe(v.array(BuilderInstanceSchema), v.readonly());
+export const BuilderVariantSchema = v.pipe(v.object({
+    instance: BuilderInstanceSchema,
+    details: v.optional(v.record(v.string(), BuilderPrimitiveSchema))
+}), v.readonly());
+export const BuilderVariantsSchema = v.pipe(v.array(BuilderVariantSchema), v.readonly());
+export const BuilderComponentVariantsSchema = v.pipe(v.record(v.string(), BuilderVariantsSchema), v.readonly());

package/dist/mappers/index.d.ts

@@ -1,7 +1,9 @@
-export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail } from './assert/index';
-export type { BuilderOrder } from './order/index';
+export type { BuilderComponentVariantsValidationResult, BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated, BuilderInstanceValidationResult, BuilderModelValidationResult, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions } from '../validate/index';
+export type { BuilderOrder } from './order';
 export type { BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './render/index';
-export { createInstance } from './instance/index.js';
-export { createModels } from './models/index.js';
-export { order } from './order/index.js';
+export { assertValidated, validateBuilder, validateInstance, validateModel, validateUI, validateVariants } from '../validate/index.js';
+export { createInstance } from './instance.js';
+export { createVariants } from './variants/index.js';
+export { order } from './order.js';
 export { ordinal, render } from './render/index.js';
+export { resolveCollection, resolveComponent, resolveOption } from './resolve.js';

package/dist/mappers/index.js

@@ -1,4 +1,6 @@
-export { createInstance } from './instance/index.js';
-export { createModels } from './models/index.js';
-export { order } from './order/index.js';
+export { assertValidated, validateBuilder, validateInstance, validateModel, validateUI, validateVariants } from '../validate/index.js';
+export { createInstance } from './instance.js';
+export { createVariants } from './variants/index.js';
+export { order } from './order.js';
 export { ordinal, render } from './render/index.js';
+export { resolveCollection, resolveComponent, resolveOption } from './resolve.js';

package/dist/mappers/instance.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderModelValidated, BuilderRefEntities, BuilderValidated } from '../entities/index';
+import type { BuilderInstance, BuilderInstanceInput } from '../instance';
+export declare function createInstance(entity: BuilderValidated | BuilderModelValidated, partial?: BuilderInstanceInput, refs?: BuilderRefEntities): BuilderInstance;

package/dist/mappers/instance.js

@@ -0,0 +1,35 @@
+import { check } from '../check.js';
+import { optionValueSchema } from '../entities/index.js';
+import { resolveCollection, resolveOption } from './resolve.js';
+export function createInstance(entity, partial = {}, refs = []) {
+    const model = 'model' in entity ? entity.model : entity;
+    return buildInstance(model, partial, refs);
+}
+function buildInstance(model, partial, refs) {
+    let instance = { ...partial };
+    model.options.forEach((option) => {
+        const { name } = option;
+        const payload = resolveOption(option, instance, refs);
+        if (payload == null) {
+            return;
+        }
+        const existing = instance[name];
+        if (check.is(optionValueSchema(payload), existing)) {
+            return;
+        }
+        instance = { ...instance, [name]: payload.defaultValue };
+    });
+    model.collections.forEach((collection) => {
+        const { name } = collection;
+        const payload = resolveCollection(collection, instance, refs);
+        if (payload == null) {
+            return;
+        }
+        const existing = instance[name];
+        const existingItems = Array.isArray(existing) ? existing : [];
+        const count = Math.max(existingItems.length, payload.min);
+        const items = Array.from({ length: count }, (_, index) => buildInstance(payload.model, existingItems[index] ?? {}, refs));
+        instance = { ...instance, [name]: items };
+    });
+    return instance;
+}

package/dist/mappers/order.d.ts

@@ -0,0 +1,6 @@
+import type { BuilderComponentVariantsValidated, BuilderInstanceValidated, BuilderModelValidated, BuilderRefEntities } from '../entities/index';
+import type { BuilderVariant } from '../instance';
+export interface BuilderOrder {
+    readonly [key: string]: BuilderVariant | BuilderOrder | ReadonlyArray<BuilderOrder> | null;
+}
+export declare function order(model: BuilderModelValidated, instance: BuilderInstanceValidated, variants: BuilderComponentVariantsValidated, refs?: BuilderRefEntities): BuilderOrder;

package/dist/mappers/order.js

@@ -0,0 +1,22 @@
+import { resolveCollection, resolveComponent } from './resolve.js';
+export function order(model, instance, variants, refs = []) {
+    const result = {};
+    model.components.forEach((component) => {
+        if (resolveComponent(component, instance, refs) == null) {
+            return;
+        }
+        const componentVariants = variants[component.name] ?? [];
+        result[component.name] =
+            componentVariants.find((variant) => Object.entries(variant.instance).every(([key, value]) => instance[key] === value)) ?? null;
+    });
+    model.collections.forEach((collection) => {
+        const { name } = collection;
+        const payload = resolveCollection(collection, instance, refs);
+        if (payload == null) {
+            return;
+        }
+        const itemInstances = instance[name];
+        result[name] = itemInstances.map((itemInstance) => order(payload.model, itemInstance, variants, refs));
+    });
+    return result;
+}

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

@@ -1,11 +1,11 @@
-import type { BuilderOptionValues } from '../../entities/index';
+import type { BuilderOptionValuesSerialised } from '../../entities/index';
 import type { BuilderPrimitive } from '../../primitive';
-import type { BuilderModel } from '../../model';
-export type BuilderRenderUpdate = (model: BuilderModel, primitive: BuilderPrimitive) => BuilderModel;
+import type { BuilderInstance } from '../../instance';
+export type BuilderRenderUpdate = (model: BuilderInstance, primitive: BuilderPrimitive) => BuilderInstance;
 export type BuilderRenderOption = Readonly<{
     value: BuilderPrimitive;
     update: BuilderRenderUpdate;
-    option: BuilderOptionValues;
+    option: BuilderOptionValuesSerialised;
 }>;
 export type BuilderRenderOptions = ReadonlyArray<BuilderRenderOption>;
 export type BuilderRenderPage = Readonly<{

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

@@ -1,8 +1,7 @@
-import type { BuilderDescription, BuilderUIGeneric } from '../../entities/index';
-import type { BuilderModel } from '../../model';
+import type { BuilderDescription, BuilderInstanceValidated, BuilderRefEntities, BuilderValidated } from '../../entities/index';
 import type { BuilderRenderPages } from './pages';
 export type BuilderRenderResult = Readonly<{
     layout: BuilderRenderPages;
     description: BuilderDescription;
 }>;
-export declare function render(ui: BuilderUIGeneric, rootModel: BuilderModel): BuilderRenderResult;
+export declare function render(builder: BuilderValidated, instance: BuilderInstanceValidated, refs?: BuilderRefEntities): BuilderRenderResult;

package/dist/mappers/render/render.js

@@ -1,112 +1,117 @@
 import * as v from 'valibot';
-import { assertModel, assertUI } from '../assert/index.js';
 import { check } from '../../check.js';
+import { BuilderInstancesSchema } from '../../instance.js';
 import { readPath } from '../../paths.js';
-import { resolveCollection, resolveOption } from '../resolve.js';
+import { resolveCollection, resolveOption, resolveRef } from '../resolve.js';
 import { ordinal } from './ordinal.js';
-export function render(ui, rootModel) {
-    assertUI(ui);
-    const rootBuilder = ui.builder;
-    assertModel(rootBuilder, rootModel);
+export function render(builder, instance, refs = []) {
     const layout = [];
     const description = [];
-    walk(rootBuilder, rootModel, [], [], ui.items);
+    walkTree(builder.ui);
     return { layout, description };
-    function walk(builder, model, collectionPath, labelContext, items) {
-        function composeLabel(label) {
-            if (labelContext.length === 0) {
-                return label.label;
-            }
-            return `${labelContext.join(', ')}, ${label.label}`;
-        }
+    function walkTree(ui) {
+        ui.uis.forEach((nested) => walkTree(nested));
+        walkItems(ui.items, builder.model, [], [], instance);
+    }
+    function walkItems(items, model, collectionPath, labelContext, currentInstance) {
         items.forEach((item) => {
-            if (item.type === 'pages') {
-                const collection = findCollection(builder, model, item.name);
-                if (!collection) {
-                    return;
-                }
-                const models = model[collection.name];
-                models.forEach((collectionModel, itemIndex) => {
-                    const labelSegment = `${ordinal(itemIndex)} ${item.label.label}`;
-                    walk(collection.payload.builder, collectionModel, [...collectionPath, item.name, itemIndex], [...labelContext, labelSegment], item.items);
-                });
-                return;
-            }
             if (item.type === 'page') {
-                const options = item.paths.flatMap((path) => {
-                    const option = findResolvedOption(builder, model, path);
-                    if (!option) {
-                        return [];
-                    }
-                    const fullPath = [...collectionPath, ...path];
-                    return [
-                        {
-                            option: option.payload,
-                            value: readPath(model, fullPath),
-                            update: (updateModel, updateValue) => setPath(updateModel, fullPath, updateValue)
-                        }
-                    ];
-                });
-                if (options.length === 0) {
-                    return;
-                }
-                layout.push({ label: composeLabel(item.label), options });
+                emitPage(item, model, collectionPath, labelContext, currentInstance);
                 return;
             }
             if (item.type === 'describe') {
-                const composedLabel = composeLabel(item.label);
-                const values = item.paths.flatMap((path) => {
-                    const option = findResolvedOption(builder, model, path);
-                    if (!option) {
-                        return [];
-                    }
-                    const fullPath = [...collectionPath, ...path];
-                    const value = readPath(model, fullPath);
-                    if (value == null) {
-                        return [];
-                    }
-                    return [value];
-                });
-                if (values.length === 0) {
-                    return;
+                emitDescribe(item, model, labelContext, currentInstance);
+                return;
+            }
+            const collection = findCollection(model, currentInstance, item.name);
+            if (collection == null) {
+                return;
+            }
+            const itemInstances = currentInstance[item.name];
+            check.assert(BuilderInstancesSchema, itemInstances, 'Collection field is not an array! ❌');
+            itemInstances.forEach((itemInstance, index) => {
+                walkItems(item.items, collection.model, [...collectionPath, item.name, index], [...labelContext, `${ordinal(index)} ${composeLabel(item.label)}`], itemInstance);
+            });
+        });
+    }
+    function emitPage(page, model, collectionPath, labelContext, currentInstance) {
+        const options = page.paths.flatMap((path) => {
+            const option = findOption(model, currentInstance, path);
+            if (option == null) {
+                return [];
+            }
+            const fullPath = [...collectionPath, ...path];
+            return [
+                {
+                    option,
+                    value: readPath(currentInstance, path),
+                    update: (updateInstance, updateValue) => setPath(updateInstance, fullPath, updateValue)
                 }
-                description.push([composedLabel, values.join(' ')]);
+            ];
+        });
+        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.paths.flatMap((path) => {
+            const option = findOption(model, currentInstance, path);
+            if (option == null) {
+                return [];
+            }
+            const value = readPath(currentInstance, path);
+            if (value == null) {
+                return [];
             }
+            return [value];
         });
+        if (values.length === 0) {
+            return;
+        }
+        description.push([composedLabel, values.join(' ')]);
+    }
+    function composeLabel(label, labelContext = []) {
+        const resolved = resolveRef(label, refs);
+        check.assert(v.string(), resolved, 'Label did not resolve to a string! ❌');
+        if (labelContext.length === 0) {
+            return resolved;
+        }
+        return `${labelContext.join(', ')}, ${resolved}`;
     }
-    function findResolvedOption(builder, model, path) {
+    function findOption(model, instance, path) {
         const optionName = path.at(-1);
         check.assert(v.string(), optionName);
         const collectionPairs = path.slice(0, -1);
-        const resolved = descendPairs(builder, model, collectionPairs);
-        if (!resolved) {
+        const descended = descendPairs(model, instance, collectionPairs);
+        if (!descended) {
             return null;
         }
-        return (resolved.builder.options
-            .map((entry) => resolveOption(entry, resolved.model))
-            .find((entry) => entry?.name === optionName) ?? null);
+        const [scopeModel, scopeInstance] = descended;
+        const entry = scopeModel.options.find((option) => option.name === optionName);
+        return entry == null ? null : resolveOption(entry, scopeInstance, refs);
     }
-    function descendPairs(currentBuilder, currentModel, remaining) {
+    function descendPairs(model, instance, remaining) {
         if (remaining.length === 0) {
-            return { builder: currentBuilder, model: currentModel };
+            return [model, instance];
         }
-        const [collectionName, modelIndex, ...rest] = remaining;
+        const [collectionName, instanceIndex, ...rest] = remaining;
         check.assert(v.string(), collectionName);
-        check.assert(v.number(), modelIndex);
-        const collection = findCollection(currentBuilder, currentModel, collectionName);
+        check.assert(v.number(), instanceIndex);
+        const collection = findCollection(model, instance, collectionName);
         if (!collection) {
             return null;
         }
-        const nextModel = currentModel[collection.name].at(modelIndex);
-        if (!nextModel) {
+        const nextInstance = instance[collectionName].at(instanceIndex);
+        if (!nextInstance) {
             return null;
         }
-        return descendPairs(collection.payload.builder, nextModel, rest);
+        return descendPairs(collection.model, nextInstance, rest);
     }
-    function findCollection(builder, model, collectionName) {
-        return (builder.collections
-            .map((entry) => resolveCollection(entry, model))
-            .find((collection) => collection?.name === collectionName) ?? null);
+    function findCollection(model, instance, collectionName) {
+        const entry = model.collections.find((candidate) => candidate.name === collectionName);
+        return entry == null ? null : resolveCollection(entry, instance, refs);
     }
 }
 function setPath(container, path, value) {

package/dist/mappers/resolve.d.ts

@@ -1,9 +1,5 @@
-import type { BuilderCollectionConfig, BuilderCollectionValidated, BuilderComponentDetails, BuilderComponentValidated, BuilderExpectations, BuilderOptionValidated, BuilderOptionValues, BuilderValidated } from '../entities/index';
-import type { BuilderPaths } from '../paths';
-import { BuilderCollection, BuilderComponent, BuilderOption } from '../entities/index.js';
-export type BuilderOptionResolved = BuilderOption<string, BuilderOptionValues, BuilderPaths>;
-export type BuilderComponentResolved = BuilderComponent<string, BuilderComponentDetails<BuilderExpectations>, BuilderPaths>;
-export type BuilderCollectionResolved = BuilderCollection<string, BuilderCollectionConfig<BuilderValidated, number, number>, BuilderPaths>;
-export declare function resolveOption(option: BuilderOptionValidated, model: unknown): BuilderOptionResolved | null;
-export declare function resolveComponent(component: BuilderComponentValidated, model: unknown): BuilderComponentResolved | null;
-export declare function resolveCollection(collection: BuilderCollectionValidated, model: unknown): BuilderCollectionResolved | null;
+import type { BuilderCollectionConfigValidated, BuilderCollectionValidated, BuilderComponentDetailsSerialised, BuilderComponentValidated, BuilderOptionValidated, BuilderOptionValuesSerialised, BuilderRefEntities } from '../entities/index';
+export declare function resolveOption(option: BuilderOptionValidated, model: unknown, refs?: BuilderRefEntities): BuilderOptionValuesSerialised | null;
+export declare function resolveComponent(component: BuilderComponentValidated, model: unknown, refs?: BuilderRefEntities): BuilderComponentDetailsSerialised | null;
+export declare function resolveCollection(collection: BuilderCollectionValidated, model: unknown, refs?: BuilderRefEntities): BuilderCollectionConfigValidated | null;
+export declare function resolveRef(value: unknown, refs: BuilderRefEntities): unknown;

package/dist/mappers/resolve.js

@@ -1,41 +1,33 @@
 import { check } from '../check.js';
-import { BuilderCollection, BuilderCollectionConfigSchema, BuilderComponent, BuilderComponentDetailsSchema, BuilderOption, BuilderOptionValuesSchema } from '../entities/index.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderComponentDetailsSerialisedSchema, BuilderOptionValuesSerialisedSchema } from '../entities/index.js';
 import { BuilderPathsSchema, readPath } from '../paths.js';
-export function resolveOption(option, model) {
-    if (check.is(BuilderOptionValuesSchema, option.payload)) {
-        return new BuilderOption(option.name, option.payload);
-    }
-    check.assert(BuilderPathsSchema, option.gatePaths);
-    const result = resolveWhen(option.gatePaths, option.payload, model);
-    if (!result) {
-        return null;
-    }
-    return new BuilderOption(option.name, result);
+import { BuilderRefSerialisedSchema } from '../references.js';
+export function resolveOption(option, model, refs = []) {
+    return resolveEntry(option, BuilderOptionValuesSerialisedSchema, model, refs);
 }
-export function resolveComponent(component, model) {
-    if (check.is(BuilderComponentDetailsSchema, component.payload)) {
-        return new BuilderComponent(component.name, component.payload);
-    }
-    check.assert(BuilderPathsSchema, component.gatePaths);
-    const result = resolveWhen(component.gatePaths, component.payload, model);
-    if (!result) {
-        return null;
-    }
-    return new BuilderComponent(component.name, result);
+export function resolveComponent(component, model, refs = []) {
+    return resolveEntry(component, BuilderComponentDetailsSerialisedSchema, model, refs);
+}
+export function resolveCollection(collection, model, refs = []) {
+    return resolveEntry(collection, BuilderCollectionConfigSerialisedSchema, model, refs);
 }
-export function resolveCollection(collection, model) {
-    if (check.is(BuilderCollectionConfigSchema, collection.payload)) {
-        return new BuilderCollection(collection.name, collection.payload);
+export function resolveRef(value, refs) {
+    if (!check.is(BuilderRefSerialisedSchema, value)) {
+        return value;
     }
-    check.assert(BuilderPathsSchema, collection.gatePaths);
-    const result = resolveWhen(collection.gatePaths, collection.payload, model);
-    if (!result) {
-        return null;
+    const found = refs.find((entry) => entry.id === value.id);
+    return found?.serialised ?? value;
+}
+function resolveEntry(entry, schema, model, refs = []) {
+    const payload = resolveRef(entry.payload, refs);
+    if (check.is(schema, payload)) {
+        return payload;
     }
-    return new BuilderCollection(collection.name, result);
+    check.assert(BuilderPathsSchema, entry.paths);
+    return pickWhenBranch(payload, entry.paths, model);
 }
-function resolveWhen(gatePaths, config, model) {
-    if (!gatePaths.every((path) => !!readPath(model, path))) {
+function pickWhenBranch(config, gates, instance) {
+    if (!gates.every((path) => readPath(instance, path) != null)) {
         return null;
     }
     switch (config.type) {
@@ -44,10 +36,10 @@ function resolveWhen(gatePaths, config, model) {
         }
         case 'match': {
             const selectMap = config.selectMap;
-            return selectMap[`${readPath(model, config.matchPath)}`];
+            return selectMap[`${readPath(instance, config.matchPath)}`] ?? null;
         }
         case 'unless': {
-            const value = readPath(model, config.unlessPath);
+            const value = readPath(instance, config.unlessPath);
             if (config.disabledValues.includes(value)) {
                 return null;
             }

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

@@ -0,0 +1 @@
+export { createVariants } from './variants.js';

package/dist/mappers/variants/index.js

@@ -0,0 +1 @@
+export { createVariants } from './variants.js';

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

@@ -0,0 +1,19 @@
+import type { BuilderOptionValidated, BuilderWhen } from '../../entities/index';
+import type { BuilderInstances } from '../../instance';
+import type { BuilderPaths } from '../../paths';
+export type GraphKeys = ReadonlySet<string>;
+export type GraphPath = {
+    name: string;
+    keys: GraphKeys;
+    instances: BuilderInstances;
+};
+export type GraphPaths = ReadonlyArray<GraphPath>;
+export declare function crossProduct(left: BuilderInstances, right: BuilderInstances): BuilderInstances;
+export declare function dependencyKeys(payload: unknown | BuilderWhen, paths?: BuilderPaths): ReadonlyArray<string>;
+export declare class BuilderOptionGraph {
+    #private;
+    readonly paths: GraphPaths;
+    constructor(paths?: GraphPaths);
+    get(name: string): GraphPath;
+    add(option: BuilderOptionValidated): BuilderOptionGraph;
+}