@builder-builder/builder 0.0.10 → 0.0.11

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,9 +1,9 @@
-export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail } from './assert/index';
-export type { BuilderOrder } from './order/index';
-export type { BuilderRefEntities, BuilderRefEntity } from './refs';
+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 { refs } from './refs.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,5 +1,6 @@
-export { createInstance } from './instance/index.js';
-export { createModels } from './models/index.js';
-export { order } from './order/index.js';
-export { refs } from './refs.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;
-            }
-            return `${labelContext.join(', ')}, ${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}`;
-                    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;
+}

package/dist/mappers/{models → variants}/option-graph.js

@@ -1,6 +1,21 @@
 import { check } from '../../check.js';
+import { BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../../entities/index.js';
 import { resolveOption } from '../resolve.js';
-import { crossProduct, dependencyKeys } from './graph.js';
+export function crossProduct(left, right) {
+    return left.flatMap((leftModel) => right.map((rightModel) => ({ ...leftModel, ...rightModel })));
+}
+export function dependencyKeys(payload, paths = []) {
+    const keys = new Set(paths.map(([first]) => String(first)));
+    if (check.is(BuilderWhenMatchSchema, payload)) {
+        const [firstMatchSegment] = payload.matchPath;
+        keys.add(String(firstMatchSegment));
+    }
+    else if (check.is(BuilderWhenUnlessSchema, payload)) {
+        const [firstUnlessSegment] = payload.unlessPath;
+        keys.add(String(firstUnlessSegment));
+    }
+    return Array.from(keys);
+}
 export class BuilderOptionGraph {
     paths;
     constructor(paths = []) {
@@ -12,43 +27,39 @@ export class BuilderOptionGraph {
         return graphPath;
     }
     add(option) {
-        check.falsy(this.#has(option.name), `Duplicate option name '${option.name}'! ❌`);
-        const { gatePaths, payload } = option;
-        const optionDependencyKeys = dependencyKeys(payload, gatePaths);
+        const { paths, payload } = option;
+        const optionDependencyKeys = dependencyKeys(payload, paths);
         if (optionDependencyKeys.length === 0) {
-            const resolved = resolveOption(option, {});
-            check.truthy(resolved, `Option '${option.name}' without dependencies must resolve! ❌`);
-            const values = this.#optionValues(resolved.name, resolved.payload);
+            const payload = resolveOption(option, {});
+            check.truthy(payload, `Option '${option.name}' without dependencies must resolve! ❌`);
+            const values = this.#optionValues(option.name, payload);
             return new BuilderOptionGraph([
                 ...this.paths,
                 {
                     name: option.name,
                     keys: new Set(),
-                    models: values.map((value) => ({ [option.name]: value }))
+                    instances: values.map((value) => ({ [option.name]: value }))
                 }
             ]);
         }
         const merged = this.#mergePaths(new Set(optionDependencyKeys), this.paths);
-        const finalModels = [];
-        merged.models.forEach((model) => {
-            const result = resolveOption(option, model);
-            if (result) {
-                this.#optionValues(result.name, result.payload).forEach((value) => {
-                    finalModels.push({ ...model, [result.name]: value });
+        const finalInstances = [];
+        merged.instances.forEach((instance) => {
+            const payload = resolveOption(option, instance);
+            if (payload) {
+                this.#optionValues(option.name, payload).forEach((value) => {
+                    finalInstances.push({ ...instance, [option.name]: value });
                 });
             }
             else {
-                finalModels.push({ ...model });
+                finalInstances.push({ ...instance });
             }
         });
         return new BuilderOptionGraph([
             ...this.paths,
-            { name: option.name, keys: merged.keys, models: finalModels }
+            { name: option.name, keys: merged.keys, instances: finalInstances }
         ]);
     }
-    #has(name) {
-        return this.paths.some((graphPath) => graphPath.name === name);
-    }
     #mergePaths(dependencyKeys, graphPaths) {
         const dependencyPaths = Array.from(dependencyKeys).map((dependencyKey) => {
             const dependencyPath = graphPaths.find((graphPath) => graphPath.name === dependencyKey);
@@ -58,9 +69,9 @@ export class BuilderOptionGraph {
         const [first, ...rest] = dependencyPaths;
         return rest.reduce((merged, next) => {
             const keys = new Set([...merged.keys, ...next.keys, next.name]);
-            const models = crossProduct(next.models, merged.models);
-            return { keys, models };
-        }, { keys: new Set([...first.keys, first.name]), models: first.models });
+            const instances = crossProduct(next.instances, merged.instances);
+            return { keys, instances };
+        }, { keys: new Set([...first.keys, first.name]), instances: first.instances });
     }
     #optionValues(name, values) {
         if (values.type === 'select') {

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

@@ -0,0 +1,3 @@
+import type { BuilderModelValidated, BuilderValidated } from '../../entities/index';
+import type { BuilderComponentVariants } from '../../instance';
+export declare function createVariants(entity: BuilderValidated | BuilderModelValidated): BuilderComponentVariants;