@builder-builder/builder 0.0.27 → 0.0.29

package/dist/instance.d.ts

@@ -7,57 +7,101 @@ 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 BuilderVariantDetailSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly kind: v.PicklistSchema<["string", "boolean", "number", "price", "image"], undefined>;
+    readonly value: v.NullableSchema<v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>;
+}, undefined>, v.ReadonlyAction<{
+    kind: "string" | "number" | "boolean" | "price" | "image";
+    value: string | number | boolean | null;
+}>]>;
+export type BuilderVariantDetail = v.InferOutput<typeof BuilderVariantDetailSchema>;
 export declare const BuilderComponentVariantSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly instance: v.GenericSchema<BuilderInstance>;
-    readonly details: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
+    readonly details: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly kind: v.PicklistSchema<["string", "boolean", "number", "price", "image"], undefined>;
+        readonly value: v.NullableSchema<v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        kind: "string" | "number" | "boolean" | "price" | "image";
+        value: string | number | boolean | null;
+    }>]>, undefined>, undefined>;
     readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     instance: BuilderInstance;
     details?: {
-        [x: string]: string | number | boolean | null;
+        readonly [x: string]: Readonly<{
+            kind: "string" | "number" | "boolean" | "price" | "image";
+            value: string | number | boolean | null;
+        }>;
     } | undefined;
     tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderComponentVariant = v.InferOutput<typeof BuilderComponentVariantSchema>;
 export declare const BuilderComponentVariantsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly instance: v.GenericSchema<BuilderInstance>;
-    readonly details: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
+    readonly details: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly kind: v.PicklistSchema<["string", "boolean", "number", "price", "image"], undefined>;
+        readonly value: v.NullableSchema<v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        kind: "string" | "number" | "boolean" | "price" | "image";
+        value: string | number | boolean | null;
+    }>]>, undefined>, undefined>;
     readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     instance: BuilderInstance;
     details?: {
-        [x: string]: string | number | boolean | null;
+        readonly [x: string]: Readonly<{
+            kind: "string" | "number" | "boolean" | "price" | "image";
+            value: string | number | boolean | null;
+        }>;
     } | undefined;
     tags?: readonly string[] | undefined;
 }>]>, undefined>, v.ReadonlyAction<Readonly<{
     instance: BuilderInstance;
     details?: {
-        [x: string]: string | number | boolean | null;
+        readonly [x: string]: Readonly<{
+            kind: "string" | "number" | "boolean" | "price" | "image";
+            value: string | number | boolean | null;
+        }>;
     } | undefined;
     tags?: readonly string[] | undefined;
 }>[]>]>;
 export type BuilderComponentVariants = v.InferOutput<typeof BuilderComponentVariantsSchema>;
 export declare const BuilderVariantsSchema: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly instance: v.GenericSchema<BuilderInstance>;
-    readonly details: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
+    readonly details: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly kind: v.PicklistSchema<["string", "boolean", "number", "price", "image"], undefined>;
+        readonly value: v.NullableSchema<v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        kind: "string" | "number" | "boolean" | "price" | "image";
+        value: string | number | boolean | null;
+    }>]>, undefined>, undefined>;
     readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     instance: BuilderInstance;
     details?: {
-        [x: string]: string | number | boolean | null;
+        readonly [x: string]: Readonly<{
+            kind: "string" | "number" | "boolean" | "price" | "image";
+            value: string | number | boolean | null;
+        }>;
     } | undefined;
     tags?: readonly string[] | undefined;
 }>]>, undefined>, v.ReadonlyAction<Readonly<{
     instance: BuilderInstance;
     details?: {
-        [x: string]: string | number | boolean | null;
+        readonly [x: string]: Readonly<{
+            kind: "string" | "number" | "boolean" | "price" | "image";
+            value: string | number | boolean | null;
+        }>;
     } | undefined;
     tags?: readonly string[] | undefined;
 }>[]>]>, undefined>, v.ReadonlyAction<{
     readonly [x: string]: readonly Readonly<{
         instance: BuilderInstance;
         details?: {
-            [x: string]: string | number | boolean | null;
+            readonly [x: string]: Readonly<{
+                kind: "string" | "number" | "boolean" | "price" | "image";
+                value: string | number | boolean | null;
+            }>;
         } | undefined;
         tags?: readonly string[] | undefined;
     }>[];

package/dist/instance.js

@@ -1,11 +1,15 @@
 import * as v from 'valibot';
-import { BuilderTagsSchema } from './entities/index.js';
+import { BuilderComponentDetailKindSchema, BuilderTagsSchema } from './entities/index.js';
 import { BuilderPrimitiveSchema, NameSchema } from './primitive.js';
 export const BuilderInstanceSchema = v.pipe(v.record(NameSchema, v.union([BuilderPrimitiveSchema, v.lazy(() => BuilderInstancesSchema)])), v.readonly());
 export const BuilderInstancesSchema = v.pipe(v.array(BuilderInstanceSchema), v.readonly());
+export const BuilderVariantDetailSchema = v.pipe(v.object({
+    kind: BuilderComponentDetailKindSchema,
+    value: v.nullable(BuilderPrimitiveSchema)
+}), v.readonly());
 export const BuilderComponentVariantSchema = v.pipe(v.object({
     instance: BuilderInstanceSchema,
-    details: v.optional(v.record(NameSchema, BuilderPrimitiveSchema)),
+    details: v.optional(v.record(NameSchema, BuilderVariantDetailSchema)),
     tags: v.optional(BuilderTagsSchema)
 }), v.readonly());
 export const BuilderComponentVariantsSchema = v.pipe(v.array(BuilderComponentVariantSchema), v.readonly());

package/dist/mappers/dependencies.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderModelValidated } from '../entities/index';
+export declare function dependencies(model: BuilderModelValidated): ReadonlyArray<string>;
+export declare function dependencyKeys(payload: unknown, paths?: unknown): ReadonlyArray<string>;

package/dist/mappers/dependencies.js

@@ -0,0 +1,45 @@
+import { BuilderPathSchema, BuilderPathsSchema, BuilderConditionMatchSchema, BuilderConditionUnlessSchema } 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(BuilderConditionMatchSchema, payload) &&
+        check.is(BuilderPathSchema, payload.matchPath)) {
+        const [firstMatchSegment] = payload.matchPath;
+        keys.add(String(firstMatchSegment));
+    }
+    else if (check.is(BuilderConditionUnlessSchema, 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/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/resolve.js

@@ -1,26 +1,26 @@
 import * as v from 'valibot';
-import { BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderPathsSchema, modelsMerge, whenBranches } from '../entities/index.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderCollectionConditionSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentConditionSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionConditionSerialisedSchema, BuilderPathsSchema, modelsMerge, conditionBranches } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { BuilderInstanceSchema, BuilderInstancesSchema } from '../instance.js';
 import { BuilderPrimitiveSchema, NameSchema, NumberSchema } from '../primitive.js';
 import { BuilderRefSerialisedSchema, paramable } from '../references.js';
 export function resolveOption(option, model, instance, references = []) {
-    return resolveEntryInstance(option, BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema, model, instance, references);
+    return resolveEntryInstance(option, BuilderOptionConfigSerialisedSchema, BuilderOptionConditionSerialisedSchema, model, instance, references);
 }
 export function resolveOptions(option, references = []) {
-    return resolveEntryExhaustive(option, BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema, references);
+    return resolveEntryExhaustive(option, BuilderOptionConfigSerialisedSchema, BuilderOptionConditionSerialisedSchema, references);
 }
 export function resolveComponent(component, model, instance, references = []) {
-    return resolveEntryInstance(component, BuilderComponentConfigSerialisedSchema, BuilderComponentWhenSerialisedSchema, model, instance, references);
+    return resolveEntryInstance(component, BuilderComponentConfigSerialisedSchema, BuilderComponentConditionSerialisedSchema, model, instance, references);
 }
 export function resolveComponents(component, references = []) {
-    return resolveEntryExhaustive(component, BuilderComponentConfigSerialisedSchema, BuilderComponentWhenSerialisedSchema, references);
+    return resolveEntryExhaustive(component, BuilderComponentConfigSerialisedSchema, BuilderComponentConditionSerialisedSchema, references);
 }
 export function resolveCollection(collection, model, instance, references = []) {
-    return resolveEntryInstance(collection, BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema, model, instance, references);
+    return resolveEntryInstance(collection, BuilderCollectionConfigSerialisedSchema, BuilderCollectionConditionSerialisedSchema, model, instance, references);
 }
 export function resolveCollections(collection, references = []) {
-    return resolveEntryExhaustive(collection, BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema, references);
+    return resolveEntryExhaustive(collection, BuilderCollectionConfigSerialisedSchema, BuilderCollectionConditionSerialisedSchema, references);
 }
 export function resolveReference(value, references, schema = v.unknown()) {
     let resolved = value;
@@ -72,28 +72,29 @@ export function resolveItems(model, instance, pairs, references = []) {
     }
     return resolveItems(resolved.model, item, rest, references);
 }
-function resolveEntryInstance(entry, schema, whenSchema, model, instance, references) {
-    const payload = resolveReference(entry.payload, references, paramable(v.union([schema, whenSchema])));
+function resolveEntryInstance(entry, schema, conditionSchema, model, instance, references) {
+    const payload = resolveReference(entry.payload, references, paramable(v.union([schema, conditionSchema])));
+    if (entry.paths != null) {
+        check.assert(BuilderPathsSchema, entry.paths);
+        if (!entry.paths.every((path) => Boolean(resolvePath(model, instance, path, references)?.value))) {
+            return null;
+        }
+    }
     if (check.is(schema, payload)) {
         return payload;
     }
-    check.assert(BuilderPathsSchema, entry.paths);
     const config = payload;
-    if (!entry.paths.every((path) => Boolean(resolvePath(model, instance, path, references)?.value))) {
-        return null;
-    }
     switch (config.type) {
-        case 'enable': {
-            return config.payload;
-        }
         case 'match': {
-            const selectMap = config.selectMap;
-            const matched = resolvePath(model, instance, config.matchPath, references);
-            return selectMap[`${matched?.value}`] ?? null;
+            const value = resolvePath(model, instance, config.matchPath, references)?.value;
+            if (value == null) {
+                return null;
+            }
+            return config.selectMap[`${value}`] ?? null;
         }
         case 'unless': {
             const value = resolvePath(model, instance, config.unlessPath, references)?.value;
-            if (!value) {
+            if (value == null) {
                 return null;
             }
             check.assert(BuilderPrimitiveSchema, value);
@@ -104,6 +105,6 @@ function resolveEntryInstance(entry, schema, whenSchema, model, instance, refere
         }
     }
 }
-function resolveEntryExhaustive(entry, schema, whenSchema, references) {
-    return whenBranches(resolveReference(entry.payload, references, paramable(v.union([schema, whenSchema]))), schema);
+function resolveEntryExhaustive(entry, schema, conditionSchema, references) {
+    return conditionBranches(resolveReference(entry.payload, references, paramable(v.union([schema, conditionSchema]))), schema);
 }

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 = []) {
@@ -83,13 +69,13 @@ export class BuilderOptionGraph {
         }, { keys: new Set([...first.keys, first.name]), instances: first.instances });
     }
     #optionValues(name, values) {
-        if (values.type === 'select') {
+        if (values.kind === '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());