@builder-builder/builder 0.0.28 → 0.0.29

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/option-graph.js

@@ -69,7 +69,7 @@ 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.kind === 'boolean') {

package/dist/public.d.ts

@@ -1,5 +1,5 @@
 export type { BB, BBOptions, BuilderEntityValidators } from './bb';
-export type { Builder, BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentConfig, BuilderComponentConfigSerialised, BuilderComponentDetail, BuilderComponentDetailKind, BuilderComponentDetails, BuilderComponentDetailSerialised, BuilderComponentDetailsSerialised, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderEnableConfig, BuilderEntityKind, BuilderEntitySerialised, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderInstanceOf, BuilderInstanceValidated, BuilderMatchConfig, BuilderMatchSelectMap, BuilderModel, BuilderModels, BuilderModelSerialised, BuilderModelValidated, BuilderOption, BuilderOptionConfig, BuilderOptionConfigSerialised, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderPath, BuilderPaths, BuilderPricing, BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce, BuilderPricingSerialised, BuilderReference, BuilderReferences, BuilderSelectConfig, BuilderSelectConfigLabels, BuilderSelectConfigSerialised, BuilderSelectConfigValues, BuilderSerialised, BuilderTags, BuilderToggleConfig, BuilderToggleConfigSerialised, BuilderToggleKind, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIInput, BuilderUIInputMetadata, BuilderUIInputMetadataSerialised, BuilderUIInputs, BuilderUIInputSerialised, BuilderUIInputsSerialised, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIs, BuilderUISerialised, BuilderUIsSerialised, BuilderUIValidated, BuilderUnlessConfig, BuilderValidated, BuilderVariantsValidated, BuilderWhen, BuilderWhenConfig, BuilderWhenSerialised } from './entities/index';
+export type { Builder, BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionCondition, BuilderCollectionConditionSerialised, BuilderComponent, BuilderComponentConfig, BuilderComponentConfigSerialised, BuilderComponentDetail, BuilderComponentDetailKind, BuilderComponentDetails, BuilderComponentDetailSerialised, BuilderComponentDetailsSerialised, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentCondition, BuilderComponentConditionSerialised, BuilderDescription, BuilderDescriptionItem, BuilderEntityKind, BuilderEntitySerialised, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderInstanceOf, BuilderInstanceValidated, BuilderMatchConfig, BuilderMatchSelectMap, BuilderModel, BuilderModels, BuilderModelSerialised, BuilderModelValidated, BuilderOption, BuilderOptionConfig, BuilderOptionConfigSerialised, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionCondition, BuilderOptionConditionSerialised, BuilderPath, BuilderPaths, BuilderPricing, BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce, BuilderPricingSerialised, BuilderReference, BuilderReferences, BuilderSelectConfig, BuilderSerialised, BuilderTags, BuilderValueConfig, BuilderValueConfigSerialised, BuilderValueKind, BuilderValueOptionLabels, BuilderValueOptions, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIInput, BuilderUIInputMetadata, BuilderUIInputMetadataSerialised, BuilderUIInputs, BuilderUIInputSerialised, BuilderUIInputsSerialised, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIs, BuilderUISerialised, BuilderUIsSerialised, BuilderUIValidated, BuilderUnlessConfig, BuilderValidated, BuilderVariantsValidated, BuilderCondition, BuilderConditionConfig, BuilderConditionSerialised } from './entities/index';
 export type { BuilderEnvironment } from './environment';
 export type { BuilderIssue, BuilderIssueLocation, BuilderIssues } from './errors/index';
 export type { BuilderIssueKind } from './errors/index.js';
@@ -9,29 +9,29 @@ export type { BuilderPrimitive, BuilderPrimitives } from './primitive';
 export type { BuilderParameter, BuilderParameterSerialised, BuilderRef, Paramable, ParamableSerialised } from './references';
 export type { BuilderInstanceValidationResult, BuilderModelValidationResult, BuilderPricingValidationResult, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions, BuilderVariantsValidationResult } from './validate/index';
 export { bb } from './bb.js';
-export { builder, detailBoolean, detailImage, detailNumber, detailPrice, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { builder, input, match, model, pricing, serialise, unless } from './entities/index.js';
 export { BuilderException } from './errors/index.js';
 export { ordinal } from './mappers/index.js';
 export { parameter, ref } from './references.js';
-import { collectionConfig, collectionExpectation, componentConfig, componentExpectation, optionExpectation, uis } from './entities/index.js';
-export declare const collection: typeof collectionConfig & {
-    enable: <const Values extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>(values: Values) => import("./public").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitivesNonEmpty, values: Values) => import("./public").BuilderUnlessConfig<Values, UnlessPath>;
-};
-export declare const component: typeof componentConfig & {
-    enable: <const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>>(payload?: Payload) => import("./public").BuilderEnableConfig<Payload>;
-    match: <const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderComponentConfig>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<Payload, MatchPath, SelectMap>;
-    unless: <const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>, const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitivesNonEmpty, payload?: Payload) => import("./public").BuilderUnlessConfig<Payload, UnlessPath>;
-};
+import { collectionConfig, collectionExpectation, componentConfig, componentExpectation, detailBoolean, detailImage, detailNumber, detailPrice, detailString, optionExpectation, valueBoolean, valueNumber, valueSelect, valueString, uis } from './entities/index.js';
+export declare const collection: typeof collectionConfig;
+export declare const component: typeof componentConfig;
 export declare const has: {
     collection: typeof collectionExpectation;
     component: typeof componentExpectation;
     option: typeof optionExpectation;
 };
-export declare const option: {
-    enable: <const Values extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("./public").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitivesNonEmpty, values: Values) => import("./public").BuilderUnlessConfig<Values, UnlessPath>;
+export declare const detail: {
+    boolean: typeof detailBoolean;
+    image: typeof detailImage;
+    number: typeof detailNumber;
+    price: typeof detailPrice;
+    string: typeof detailString;
 };
 export declare const ui: typeof uis;
+export declare const value: {
+    boolean: typeof valueBoolean;
+    number: typeof valueNumber;
+    select: typeof valueSelect;
+    string: typeof valueString;
+};

package/dist/public.js

@@ -1,19 +1,27 @@
 export { bb } from './bb.js';
-export { builder, detailBoolean, detailImage, detailNumber, detailPrice, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { builder, input, match, model, pricing, serialise, unless } from './entities/index.js';
 export { BuilderException } from './errors/index.js';
 export { ordinal } from './mappers/index.js';
 export { parameter, ref } from './references.js';
-import { collectionConfig, collectionExpectation, collectionWhen, componentConfig, componentExpectation, componentWhen, optionExpectation, optionWhen, uis } from './entities/index.js';
-export const collection = Object.assign(collectionConfig, {
-    ...collectionWhen
-});
-export const component = Object.assign(componentConfig, {
-    ...componentWhen
-});
+import { collectionConfig, collectionExpectation, componentConfig, componentExpectation, detailBoolean, detailImage, detailNumber, detailPrice, detailString, optionExpectation, valueBoolean, valueNumber, valueSelect, valueString, uis } from './entities/index.js';
+export const collection = collectionConfig;
+export const component = componentConfig;
 export const has = {
     collection: collectionExpectation,
     component: componentExpectation,
     option: optionExpectation
 };
-export const option = optionWhen;
+export const detail = {
+    boolean: detailBoolean,
+    image: detailImage,
+    number: detailNumber,
+    price: detailPrice,
+    string: detailString
+};
 export const ui = uis;
+export const value = {
+    boolean: valueBoolean,
+    number: valueNumber,
+    select: valueSelect,
+    string: valueString
+};

package/dist/validate/expectations.js

@@ -1,10 +1,28 @@
+import { BuilderOptionConfigSerialisedSchema } from '../entities/index.js';
+import { check } from '../errors/index.js';
 export function checkExpectations(model, expectations, issues) {
-    expectations.forEach(({ kind, name }, index) => {
+    expectations.forEach(({ kind, name, payload }, index) => {
         issues.scope(index, () => {
-            if (model[`${kind}s`].some((entry) => entry.name === name)) {
+            const entry = model[`${kind}s`].find((candidate) => candidate.name === name);
+            if (entry == null) {
+                issues.modelUnmetExpectation();
                 return;
             }
-            issues.modelUnmetExpectation();
+            if (payload != null && !isExpectedOption(entry.payload, payload)) {
+                issues.modelInvalidExpectation();
+            }
         });
     });
 }
+function isExpectedOption(payload, expectation) {
+    if (!check.is(BuilderOptionConfigSerialisedSchema, payload)) {
+        return true;
+    }
+    if (expectation.kind === 'select') {
+        if (payload.kind !== 'select') {
+            return false;
+        }
+        return expectation.options.every((option) => payload.options.includes(option));
+    }
+    return payload.kind === expectation.kind;
+}

package/dist/validate/model.js

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderPathsSchema, BuilderWhenSerialisedSchema, whenBranches, model, modelsMerge, serialise, validateCollectionConfig, validateComponentConfig, validateSelect, validateToggle } from '../entities/index.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderPathsSchema, BuilderConditionSerialisedSchema, conditionBranches, model, modelsMerge, serialise, validateCollectionConfig, validateComponentConfig, validateValue } from '../entities/index.js';
 import { BuilderIssuesScope, check } from '../errors/index.js';
 import { dependencies } from '../mappers/index.js';
 import { isParamable } from '../references.js';
@@ -50,26 +50,23 @@ export function validateModelStructure(input, resolve, issues) {
         const modelInput = resolved;
         const childModels = issues.scope('models', () => modelInput.models.flatMap((part, partIndex) => issues.scope(partIndex, () => [walkStructure(part)])));
         const options = issues.scope('options', () => walkEntries(modelInput.options, 'option', (resolved) => {
-            whenBranches(resolved.payload, BuilderOptionConfigSerialisedSchema)
+            conditionBranches(resolved.payload, BuilderOptionConfigSerialisedSchema)
                 .filter((config) => !isParamable(config))
                 .forEach((config) => {
-                if (config.type === 'select') {
-                    validateSelect(config, [], issues);
-                }
-                else if (config.type === 'toggle') {
-                    validateToggle(config, [], issues);
+                if (config.type === 'value') {
+                    validateValue(config, [], issues);
                 }
             });
         }));
         const components = issues.scope('components', () => walkEntries(modelInput.components, 'component', (resolved) => {
-            whenBranches(resolved.payload, BuilderComponentConfigSerialisedSchema)
+            conditionBranches(resolved.payload, BuilderComponentConfigSerialisedSchema)
                 .filter((config) => !isParamable(config))
                 .forEach((config) => {
                 validateComponentConfig(config, [], issues);
             });
         }));
         const collections = issues.scope('collections', () => walkEntries(modelInput.collections, 'collection', (resolved) => {
-            whenBranches(resolved.payload, BuilderCollectionConfigSerialisedSchema)
+            conditionBranches(resolved.payload, BuilderCollectionConfigSerialisedSchema)
                 .filter((config) => !isParamable(config))
                 .forEach((config) => {
                 validateCollectionConfig(config, [], issues);
@@ -117,7 +114,7 @@ export function validateModelStructure(input, resolve, issues) {
                 const resolvedPaths = issues.scope('paths', () => resolve(entry.paths, BuilderPathsSchema));
                 paths = resolvedPaths ?? entry.paths;
             }
-            const payloadSchema = v.union([payloadSchemaFor(kind), BuilderWhenSerialisedSchema]);
+            const payloadSchema = v.union([payloadSchemaFor(kind), BuilderConditionSerialisedSchema]);
             const payload = issues.scope('payload', () => resolve(entry.payload, payloadSchema));
             const resolvedEntry = { ...entry, paths, payload: payload ?? entry.payload };
             if (seenLocal.has(resolvedEntry.name)) {
@@ -159,7 +156,7 @@ export function validateModelStructure(input, resolve, issues) {
                     });
                 });
             }
-            if (!check.is(BuilderWhenSerialisedSchema, payload)) {
+            if (!check.is(BuilderConditionSerialisedSchema, payload)) {
                 return;
             }
             if (payload.type === 'match' && Array.isArray(payload.matchPath)) {

package/dist/validate/resolve.js

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderPathSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderPathSchema, BuilderConditionSerialisedSchema } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { NumberSchema, StringSchema } from '../primitive.js';
 import { BuilderParameterSerialisedSchema, BuilderRefSerialisedSchema } from '../references.js';
@@ -24,8 +24,8 @@ export function resolver(issues, references = [], bindings = {}) {
         if (check.is(BuilderRefSerialisedSchema, value)) {
             return resolveReference(value, schema);
         }
-        if (check.is(BuilderWhenSerialisedSchema, value)) {
-            return resolveWhen(value, schema);
+        if (check.is(BuilderConditionSerialisedSchema, value)) {
+            return resolveCondition(value, schema);
         }
         if (check.is(BuilderCollectionConfigSerialisedSchema, value)) {
             return resolveCollectionConfig(value);
@@ -61,25 +61,21 @@ export function resolver(issues, references = [], bindings = {}) {
         }
         return resolveReference(binding, schema);
     }
-    function resolveWhen(when, payloadSchema) {
-        if (when.type === 'enable') {
-            const payload = issues.scope('payload', () => resolve(when.payload, payloadSchema));
-            return { ...when, payload: payload ?? when.payload };
-        }
-        if (when.type === 'unless') {
-            const unlessPath = issues.scope('unlessPath', () => resolve(when.unlessPath, BuilderPathSchema));
-            const payload = issues.scope('payload', () => resolve(when.payload, payloadSchema));
+    function resolveCondition(condition, payloadSchema) {
+        if (condition.type === 'unless') {
+            const unlessPath = issues.scope('unlessPath', () => resolve(condition.unlessPath, BuilderPathSchema));
+            const payload = issues.scope('payload', () => resolve(condition.payload, payloadSchema));
             return {
-                ...when,
-                unlessPath: unlessPath ?? when.unlessPath,
-                payload: payload ?? when.payload
+                ...condition,
+                unlessPath: unlessPath ?? condition.unlessPath,
+                payload: payload ?? condition.payload
             };
         }
-        const matchPath = issues.scope('matchPath', () => resolve(when.matchPath, BuilderPathSchema));
+        const matchPath = issues.scope('matchPath', () => resolve(condition.matchPath, BuilderPathSchema));
         const selectMapSchema = v.record(StringSchema, v.nullable(v.unknown()));
-        const map = issues.scope('selectMap', () => resolve(when.selectMap, selectMapSchema));
+        const map = issues.scope('selectMap', () => resolve(condition.selectMap, selectMapSchema));
         if (map == null) {
-            return { ...when, matchPath: matchPath ?? when.matchPath };
+            return { ...condition, matchPath: matchPath ?? condition.matchPath };
         }
         const selectMap = issues.scope('selectMap', () => Object.entries(map).reduce((values, [key, entryValue]) => {
             if (entryValue == null) {
@@ -88,7 +84,7 @@ export function resolver(issues, references = [], bindings = {}) {
             const resolved = issues.scope(key, () => resolve(entryValue, payloadSchema));
             return { ...values, [key]: resolved ?? entryValue };
         }, {}));
-        return { ...when, matchPath: matchPath ?? when.matchPath, selectMap };
+        return { ...condition, matchPath: matchPath ?? condition.matchPath, selectMap };
     }
     function resolveCollectionConfig(config) {
         const model = issues.scope('model', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.28",
+  "version": "0.0.29",
   "type": "module",
   "engines": {
     "node": ">=24"

package/dist/components/BuilderOptionSelect.svelte.d.ts

@@ -1,21 +0,0 @@
-import { SvelteComponentTyped } from "svelte";
-import type { BuilderRenderOption } from '../index.js';
-export type BuilderBuilderOptionSelectProps = {
-    readonly option: BuilderRenderOption;
-    readonly placeholder?: string;
-    readonly id?: string;
-};
-export type BuilderBuilderOptionSelectUpdateEvent = CustomEvent<string | null>;
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type BuilderOptionSelectProps = typeof __propDef.props;
-export type BuilderOptionSelectEvents = typeof __propDef.events;
-export type BuilderOptionSelectSlots = typeof __propDef.slots;
-export default class BuilderOptionSelect extends SvelteComponentTyped<BuilderOptionSelectProps, BuilderOptionSelectEvents, BuilderOptionSelectSlots> {
-}
-export {};

package/dist/components/BuilderOptionToggleBoolean.svelte.d.ts

@@ -1,20 +0,0 @@
-import { SvelteComponentTyped } from "svelte";
-import type { BuilderRenderOption } from '../index.js';
-export type BuilderBuilderOptionToggleBooleanProps = {
-    readonly option: BuilderRenderOption;
-    readonly id?: string;
-};
-export type BuilderBuilderOptionToggleBooleanUpdateEvent = CustomEvent<boolean>;
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type BuilderOptionToggleBooleanProps = typeof __propDef.props;
-export type BuilderOptionToggleBooleanEvents = typeof __propDef.events;
-export type BuilderOptionToggleBooleanSlots = typeof __propDef.slots;
-export default class BuilderOptionToggleBoolean extends SvelteComponentTyped<BuilderOptionToggleBooleanProps, BuilderOptionToggleBooleanEvents, BuilderOptionToggleBooleanSlots> {
-}
-export {};

package/dist/components/BuilderOptionToggleNumber.svelte.d.ts

@@ -1,21 +0,0 @@
-import { SvelteComponentTyped } from "svelte";
-import type { BuilderRenderOption } from '../index.js';
-export type BuilderBuilderOptionToggleNumberProps = {
-    readonly option: BuilderRenderOption;
-    readonly placeholder?: string;
-    readonly id?: string;
-};
-export type BuilderBuilderOptionToggleNumberUpdateEvent = CustomEvent<number>;
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type BuilderOptionToggleNumberProps = typeof __propDef.props;
-export type BuilderOptionToggleNumberEvents = typeof __propDef.events;
-export type BuilderOptionToggleNumberSlots = typeof __propDef.slots;
-export default class BuilderOptionToggleNumber extends SvelteComponentTyped<BuilderOptionToggleNumberProps, BuilderOptionToggleNumberEvents, BuilderOptionToggleNumberSlots> {
-}
-export {};

package/dist/components/BuilderOptionToggleString.svelte.d.ts

@@ -1,21 +0,0 @@
-import { SvelteComponentTyped } from "svelte";
-import type { BuilderRenderOption } from '../index.js';
-export type BuilderBuilderOptionToggleStringProps = {
-    readonly option: BuilderRenderOption;
-    readonly placeholder?: string;
-    readonly id?: string;
-};
-export type BuilderBuilderOptionToggleStringUpdateEvent = CustomEvent<string>;
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type BuilderOptionToggleStringProps = typeof __propDef.props;
-export type BuilderOptionToggleStringEvents = typeof __propDef.events;
-export type BuilderOptionToggleStringSlots = typeof __propDef.slots;
-export default class BuilderOptionToggleString extends SvelteComponentTyped<BuilderOptionToggleStringProps, BuilderOptionToggleStringEvents, BuilderOptionToggleStringSlots> {
-}
-export {};

package/dist/entities/collection/when.js

@@ -1,2 +0,0 @@
-import { createWhenFactories } from '../when.js';
-export const collectionWhen = createWhenFactories();

package/dist/entities/option/toggle.d.ts

@@ -1,45 +0,0 @@
-import type { BuilderPrimitive } from '../../primitive';
-import type { BuilderTags } from '../tags';
-import * as v from 'valibot';
-export declare const BuilderToggleKindSchema: v.PicklistSchema<["string", "boolean", "number"], undefined>;
-export type BuilderToggleKind = v.InferOutput<typeof BuilderToggleKindSchema>;
-export declare class BuilderToggleConfig<const ValueSchema extends v.GenericSchema<BuilderPrimitive> = v.GenericSchema<BuilderPrimitive>> {
-    #private;
-    readonly value: v.InferOutput<ValueSchema>;
-    readonly type: "toggle";
-    readonly kind: BuilderToggleKind;
-    readonly valueSchema: ValueSchema;
-    readonly defaultValue: v.InferOutput<ValueSchema>;
-    readonly isOptional: boolean;
-    readonly tags?: BuilderTags;
-    constructor(kind: BuilderToggleKind, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, tags?: BuilderTags);
-    default(newDefault: v.InferOutput<ValueSchema>): BuilderToggleConfig<ValueSchema>;
-    optional(): BuilderToggleConfig<v.NullableSchema<ValueSchema, undefined>>;
-    tag(...tags: Array<string>): BuilderToggleConfig<ValueSchema>;
-}
-export declare function toggleString(): BuilderToggleConfig<v.StringSchema<undefined>>;
-export declare function toggleBoolean(): BuilderToggleConfig<v.BooleanSchema<undefined>>;
-export declare function toggleNumber(): BuilderToggleConfig<v.NumberSchema<undefined>>;
-export declare const BuilderToggleConfigSchema: v.InstanceSchema<typeof BuilderToggleConfig, undefined>;
-export declare const BuilderToggleConfigSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"toggle", undefined>;
-    readonly kind: v.PicklistSchema<["string", "boolean", "number"], undefined>;
-    readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
-    readonly isOptional: v.BooleanSchema<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<{
-    type: "toggle";
-    kind: "string" | "number" | "boolean";
-    defaultValue: string | number | boolean | null;
-    isOptional: boolean;
-    tags?: readonly string[] | undefined;
-}>]>;
-export type BuilderToggleConfigSerialised = v.InferOutput<typeof BuilderToggleConfigSerialisedSchema>;
-export declare function toggleValueSchema(kind: BuilderToggleKind, optional: boolean): v.GenericSchema;
-export declare const validateToggle: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors/errors").BuilderIssuesScope) => import("..").ValidationResult<{
-    readonly type: "toggle";
-    readonly kind: "string" | "number" | "boolean";
-    readonly defaultValue: string | number | boolean | null;
-    readonly isOptional: boolean;
-    readonly tags?: readonly string[] | undefined;
-}>;

package/dist/entities/option/toggle.js

@@ -1,71 +0,0 @@
-import * as v from 'valibot';
-import { check } from '../../errors/index.js';
-import { BooleanSchema, NumberSchema, StringSchema } from '../../primitive.js';
-import { createEntityValidator } from '../kind.js';
-import { serialisable } from '../serialisable.js';
-import { BuilderTagsSchema } from '../tags.js';
-export const BuilderToggleKindSchema = v.picklist(['string', 'boolean', 'number']);
-export class BuilderToggleConfig {
-    type = 'toggle';
-    kind;
-    valueSchema;
-    defaultValue;
-    isOptional;
-    tags;
-    constructor(kind, defaultValue, optional, tags) {
-        this.kind = kind;
-        this.valueSchema = toggleValueSchema(kind, optional || false);
-        this.defaultValue = defaultValue;
-        this.isOptional = optional || false;
-        this.tags = tags;
-    }
-    #next(patch) {
-        return new BuilderToggleConfig(this.kind, 'defaultValue' in patch
-            ? patch.defaultValue
-            : this.defaultValue, patch.optional ?? this.isOptional, patch.tags ?? this.tags);
-    }
-    default(newDefault) {
-        return this.#next({ defaultValue: newDefault });
-    }
-    optional() {
-        return this.#next({ optional: true });
-    }
-    tag(...tags) {
-        return this.#next({ tags });
-    }
-}
-export function toggleString() {
-    return new BuilderToggleConfig('string', '');
-}
-export function toggleBoolean() {
-    return new BuilderToggleConfig('boolean', false);
-}
-export function toggleNumber() {
-    return new BuilderToggleConfig('number', 0);
-}
-export const BuilderToggleConfigSchema = v.instance(BuilderToggleConfig);
-export const BuilderToggleConfigSerialisedSchema = serialisable(v.object({
-    type: v.literal('toggle'),
-    kind: BuilderToggleKindSchema,
-    defaultValue: v.nullable(v.union([BooleanSchema, StringSchema, NumberSchema])),
-    isOptional: BooleanSchema,
-    tags: v.optional(BuilderTagsSchema)
-}));
-export function toggleValueSchema(kind, optional) {
-    const kindSchemas = {
-        string: StringSchema,
-        boolean: BooleanSchema,
-        number: NumberSchema
-    };
-    const baseSchema = kindSchemas[kind];
-    return optional ? v.nullable(baseSchema) : baseSchema;
-}
-export const validateToggle = createEntityValidator('toggle', BuilderToggleConfigSerialisedSchema, (input, errors) => {
-    if (input.defaultValue == null) {
-        return;
-    }
-    const valueSchema = toggleValueSchema(input.kind, input.isOptional);
-    if (!check.is(valueSchema, input.defaultValue)) {
-        errors.scope('defaultValue', () => errors.entityInvalidToggleDefault());
-    }
-});

package/dist/entities/option/when.d.ts

@@ -1,10 +0,0 @@
-import type { Paramable } from '../../references';
-import type { BuilderPath } from '../paths';
-import type { BuilderWhen } from '../when';
-import type { BuilderOptionConfig } from './config';
-export type BuilderOptionWhen = BuilderWhen<Paramable<BuilderOptionConfig>, Paramable<BuilderPath>, Paramable<Record<string, Paramable<BuilderOptionConfig> | null>>, Paramable<BuilderPath>>;
-export declare const optionWhen: {
-    enable: <const Values extends Paramable<import("./select").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("..").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends Paramable<import("./select").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends Paramable<BuilderPath>, const SelectMap extends Paramable<import("..").BuilderMatchSelectMap<Paramable<import("./select").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("..").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends Paramable<import("./select").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends Paramable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("../../primitive").BuilderPrimitivesNonEmpty, values: Values) => import("..").BuilderUnlessConfig<Values, UnlessPath>;
-};

package/dist/entities/option/when.js

@@ -1,2 +0,0 @@
-import { createWhenFactories } from '../when.js';
-export const optionWhen = createWhenFactories();