@builder-builder/builder 0.0.28 → 0.0.29

package/dist/entities/collection/collection.js

@@ -5,7 +5,7 @@ import { createEntityValidator } from '../kind.js';
 import { BuilderPathsSchema } from '../paths.js';
 import { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
-import { createSelectMapSerialisedSchema, createWhenSerialisedSchema } from '../when.js';
+import { createSelectMapSerialisedSchema, createConditionSerialisedSchema } from '../condition.js';
 import { BuilderCollectionConfigSerialisedSchema } from './config.js';
 export class BuilderCollection {
     name;
@@ -23,14 +23,17 @@ export class BuilderCollection {
     }
 }
 export const BuilderCollectionSchema = v.instance(BuilderCollection);
-export const BuilderCollectionWhenSerialisedSchema = createWhenSerialisedSchema(BuilderCollectionConfigSerialisedSchema);
+export const BuilderCollectionConditionSerialisedSchema = createConditionSerialisedSchema(BuilderCollectionConfigSerialisedSchema);
 export const BuilderCollectionSelectMapSerialisedSchema = createSelectMapSerialisedSchema(BuilderCollectionConfigSerialisedSchema);
 export const BuilderCollectionSerialisedSchema = serialisable(v.object({
     name: NameSchema,
-    payload: paramable(v.union([BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema])),
+    payload: paramable(v.union([
+        BuilderCollectionConfigSerialisedSchema,
+        BuilderCollectionConditionSerialisedSchema
+    ])),
     paths: v.optional(paramable(BuilderPathsSchema)),
     tags: v.optional(BuilderTagsSchema)
 }));
 export const BuilderCollectionsSerialisedSchema = v.pipe(v.array(BuilderCollectionSerialisedSchema), v.readonly());
-export const validateCollectionWhen = createEntityValidator('collectionWhen', BuilderCollectionWhenSerialisedSchema);
+export const validateCollectionCondition = createEntityValidator('collectionCondition', BuilderCollectionConditionSerialisedSchema);
 export const validateCollectionSelectMap = createEntityValidator('collectionSelectMap', BuilderCollectionSelectMapSerialisedSchema);

package/dist/entities/collection/{when.d.ts → condition.d.ts}

@@ -1,10 +1,9 @@
 import type { Paramable } from '../../references';
 import type { BuilderPath } from '../paths';
-import type { BuilderWhen } from '../when';
+import type { BuilderCondition } from '../condition';
 import type { BuilderCollectionConfig } from './config';
-export type BuilderCollectionWhen = BuilderWhen<Paramable<BuilderCollectionConfig>, Paramable<BuilderPath>, Paramable<Record<string, Paramable<BuilderCollectionConfig> | null>>, Paramable<BuilderPath>>;
-export declare const collectionWhen: {
-    enable: <const Values extends Paramable<BuilderCollectionConfig<Paramable<import("..").BuilderModelGeneric>, Paramable<number>, Paramable<number>>>>(values: Values) => import("..").BuilderEnableConfig<Values>;
+export type BuilderCollectionCondition = BuilderCondition<Paramable<BuilderCollectionConfig>, Paramable<BuilderPath>, Paramable<Record<string, Paramable<BuilderCollectionConfig> | null>>, Paramable<BuilderPath>>;
+export declare const collectionCondition: {
     match: <const MatchPayload extends Paramable<BuilderCollectionConfig<Paramable<import("..").BuilderModelGeneric>, Paramable<number>, Paramable<number>>>, const MatchPath extends Paramable<BuilderPath>, const SelectMap extends Paramable<import("..").BuilderMatchSelectMap<Paramable<BuilderCollectionConfig<Paramable<import("..").BuilderModelGeneric>, Paramable<number>, Paramable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("..").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
     unless: <const Values extends Paramable<BuilderCollectionConfig<Paramable<import("..").BuilderModelGeneric>, Paramable<number>, Paramable<number>>>, const UnlessPath extends Paramable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("../../primitive").BuilderPrimitivesNonEmpty, values: Values) => import("..").BuilderUnlessConfig<Values, UnlessPath>;
 };

package/dist/entities/collection/condition.js

@@ -0,0 +1,2 @@
+import { createConditionFactories } from '../condition.js';
+export const collectionCondition = createConditionFactories();

package/dist/entities/collection/config.d.ts

@@ -195,39 +195,38 @@ export declare const validateCollectionConfig: (input: unknown, references?: imp
         readonly options: readonly {
             readonly name: string;
             readonly payload: {
-                readonly type: "enable";
-                readonly payload: {
-                    readonly type: "select";
-                    readonly options: readonly [string, ...string[]];
-                    readonly defaultValue: string | null;
-                    readonly isOptional: boolean;
-                    readonly optionLabels: {
-                        readonly [x: string]: string;
-                    } & import("../../validate").BuilderValidatedBrand;
-                    readonly tags?: readonly string[] | undefined;
-                } | {
-                    readonly type: "toggle";
-                    readonly kind: "string" | "number" | "boolean";
-                    readonly defaultValue: string | number | boolean | null;
-                    readonly isOptional: boolean;
-                    readonly tags?: readonly string[] | undefined;
-                };
+                readonly kind: "string" | "number" | "boolean";
+                readonly type: "value";
+                readonly defaultValue: string | number | boolean | null;
+                readonly isOptional: boolean;
+                readonly tags?: readonly string[] | undefined;
+            } | {
+                readonly kind: "select";
+                readonly options: readonly [string, ...string[]];
+                readonly optionLabels?: ({
+                    readonly [x: string]: string;
+                } & import("../../validate").BuilderValidatedBrand) | undefined;
+                readonly type: "value";
+                readonly defaultValue: string | number | boolean | null;
+                readonly isOptional: boolean;
+                readonly tags?: readonly string[] | undefined;
             } | {
                 readonly type: "match";
                 readonly matchPath: readonly (string | number)[];
                 readonly selectMap: {
                     readonly [x: string]: {
-                        readonly type: "select";
-                        readonly options: readonly [string, ...string[]];
-                        readonly defaultValue: string | null;
+                        readonly kind: "string" | "number" | "boolean";
+                        readonly type: "value";
+                        readonly defaultValue: string | number | boolean | null;
                         readonly isOptional: boolean;
-                        readonly optionLabels: {
-                            readonly [x: string]: string;
-                        } & import("../../validate").BuilderValidatedBrand;
                         readonly tags?: readonly string[] | undefined;
                     } | {
-                        readonly type: "toggle";
-                        readonly kind: "string" | "number" | "boolean";
+                        readonly kind: "select";
+                        readonly options: readonly [string, ...string[]];
+                        readonly optionLabels?: ({
+                            readonly [x: string]: string;
+                        } & import("../../validate").BuilderValidatedBrand) | undefined;
+                        readonly type: "value";
                         readonly defaultValue: string | number | boolean | null;
                         readonly isOptional: boolean;
                         readonly tags?: readonly string[] | undefined;
@@ -238,36 +237,22 @@ export declare const validateCollectionConfig: (input: unknown, references?: imp
                 readonly unlessPath: readonly (string | number)[];
                 readonly disabledValues: readonly (string | number | boolean | null)[];
                 readonly payload: {
-                    readonly type: "select";
-                    readonly options: readonly [string, ...string[]];
-                    readonly defaultValue: string | null;
+                    readonly kind: "string" | "number" | "boolean";
+                    readonly type: "value";
+                    readonly defaultValue: string | number | boolean | null;
                     readonly isOptional: boolean;
-                    readonly optionLabels: {
-                        readonly [x: string]: string;
-                    } & import("../../validate").BuilderValidatedBrand;
                     readonly tags?: readonly string[] | undefined;
                 } | {
-                    readonly type: "toggle";
-                    readonly kind: "string" | "number" | "boolean";
+                    readonly kind: "select";
+                    readonly options: readonly [string, ...string[]];
+                    readonly optionLabels?: ({
+                        readonly [x: string]: string;
+                    } & import("../../validate").BuilderValidatedBrand) | undefined;
+                    readonly type: "value";
                     readonly defaultValue: string | number | boolean | null;
                     readonly isOptional: boolean;
                     readonly tags?: readonly string[] | undefined;
                 };
-            } | {
-                readonly type: "select";
-                readonly options: readonly [string, ...string[]];
-                readonly defaultValue: string | null;
-                readonly isOptional: boolean;
-                readonly optionLabels: {
-                    readonly [x: string]: string;
-                } & import("../../validate").BuilderValidatedBrand;
-                readonly tags?: readonly string[] | undefined;
-            } | {
-                readonly type: "toggle";
-                readonly kind: "string" | "number" | "boolean";
-                readonly defaultValue: string | number | boolean | null;
-                readonly isOptional: boolean;
-                readonly tags?: readonly string[] | undefined;
             };
             readonly paths?: readonly (readonly (string | number)[])[] | undefined;
             readonly tags?: readonly string[] | undefined;
@@ -283,18 +268,6 @@ export declare const validateCollectionConfig: (input: unknown, references?: imp
                     readonly tags?: readonly string[] | undefined;
                 }[];
                 readonly tags?: readonly string[] | undefined;
-            } | {
-                readonly type: "enable";
-                readonly payload: {
-                    readonly details: readonly {
-                        readonly type: "component-detail";
-                        readonly name: string;
-                        readonly kind: "string" | "number" | "boolean" | "price" | "image";
-                        readonly isOptional: boolean;
-                        readonly tags?: readonly string[] | undefined;
-                    }[];
-                    readonly tags?: readonly string[] | undefined;
-                };
             } | {
                 readonly type: "match";
                 readonly matchPath: readonly (string | number)[];
@@ -336,14 +309,6 @@ export declare const validateCollectionConfig: (input: unknown, references?: imp
                 readonly min: number;
                 readonly max: number;
                 readonly tags?: readonly string[] | undefined;
-            } | {
-                readonly type: "enable";
-                readonly payload: {
-                    readonly model: /*elided*/ any & import("../../validate").BuilderValidatedBrand;
-                    readonly min: number;
-                    readonly max: number;
-                    readonly tags?: readonly string[] | undefined;
-                };
             } | {
                 readonly type: "match";
                 readonly matchPath: readonly (string | number)[];
@@ -368,10 +333,27 @@ export declare const validateCollectionConfig: (input: unknown, references?: imp
             };
             readonly tags?: readonly string[] | undefined;
         }[];
-        readonly expectations: readonly ({
+        readonly expectations: readonly {
             readonly name: string;
             readonly kind: "option" | "component" | "collection";
-        } & import("../../validate").BuilderValidatedBrand)[];
+            readonly payload?: {
+                readonly kind: "string" | "number" | "boolean";
+                readonly type: "value";
+                readonly defaultValue: string | number | boolean | null;
+                readonly isOptional: boolean;
+                readonly tags?: readonly string[] | undefined;
+            } | {
+                readonly kind: "select";
+                readonly options: readonly [string, ...string[]];
+                readonly optionLabels?: ({
+                    readonly [x: string]: string;
+                } & import("../../validate").BuilderValidatedBrand) | undefined;
+                readonly type: "value";
+                readonly defaultValue: string | number | boolean | null;
+                readonly isOptional: boolean;
+                readonly tags?: readonly string[] | undefined;
+            } | undefined;
+        }[];
         readonly tags?: readonly string[] | undefined;
     } & import("../../validate").BuilderValidatedBrand;
     readonly min: number;

package/dist/entities/collection/index.d.ts

@@ -1,8 +1,8 @@
-export type { BuilderCollectionPayload, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhenSerialised, CollectionNamesOf, CollectionShape } from './collection';
+export type { BuilderCollectionPayload, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionConditionSerialised, CollectionNamesOf, CollectionShape } from './collection';
 export type { BuilderCollectionConfigSerialised, BuilderCollectionConfigsSerialised } from './config';
 export type { CollectionsAsserted } from './expectation';
-export type { BuilderCollectionWhen } from './when';
-export { BuilderCollection, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, validateCollectionSelectMap, validateCollectionWhen } from './collection.js';
+export type { BuilderCollectionCondition } from './condition';
+export { BuilderCollection, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionConditionSerialisedSchema, validateCollectionSelectMap, validateCollectionCondition } from './collection.js';
 export { BuilderCollectionConfig, BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionConfigsSerialisedSchema, collectionConfig, validateCollectionConfig } from './config.js';
 export { collectionExpectation } from './expectation.js';
-export { collectionWhen } from './when.js';
+export { collectionCondition } from './condition.js';

package/dist/entities/collection/index.js

@@ -1,4 +1,4 @@
-export { BuilderCollection, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, validateCollectionSelectMap, validateCollectionWhen } from './collection.js';
+export { BuilderCollection, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionConditionSerialisedSchema, validateCollectionSelectMap, validateCollectionCondition } from './collection.js';
 export { BuilderCollectionConfig, BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionConfigsSerialisedSchema, collectionConfig, validateCollectionConfig } from './config.js';
 export { collectionExpectation } from './expectation.js';
-export { collectionWhen } from './when.js';
+export { collectionCondition } from './condition.js';

package/dist/entities/component/component.d.ts

@@ -1,11 +1,11 @@
 import type { Paramable } from '../../references';
 import type { BuilderPaths } from '../paths';
 import type { BuilderTags } from '../tags';
-import type { BuilderWhenSerialised } from '../when';
+import type { BuilderConditionSerialised } from '../condition';
 import type { BuilderComponentConfig, BuilderComponentConfigSerialised } from './config';
-import type { BuilderComponentWhen } from './when';
+import type { BuilderComponentCondition } from './condition';
 import * as v from 'valibot';
-export type BuilderComponentPayload = BuilderComponentConfig | BuilderComponentWhen;
+export type BuilderComponentPayload = BuilderComponentConfig | BuilderComponentCondition;
 export declare class BuilderComponent<const Name extends string = string, const Payload extends Paramable<BuilderComponentPayload> = Paramable<BuilderComponentPayload>, const Paths extends Paramable<BuilderPaths> = Paramable<BuilderPaths>> {
     readonly type: 'component';
     readonly name: Name;
@@ -17,7 +17,7 @@ export declare class BuilderComponent<const Name extends string = string, const
 }
 export declare const BuilderComponentSchema: v.InstanceSchema<typeof BuilderComponent, undefined>;
 export type BuilderComponents = ReadonlyArray<BuilderComponent>;
-export declare const BuilderComponentWhenSerialisedSchema: v.GenericSchema<BuilderWhenSerialised<Readonly<{
+export declare const BuilderComponentConditionSerialisedSchema: v.GenericSchema<BuilderConditionSerialised<Readonly<{
     details: Readonly<{
         type: "parameter";
         id: string;
@@ -34,7 +34,7 @@ export declare const BuilderComponentWhenSerialisedSchema: v.GenericSchema<Build
     }>[];
     tags?: readonly string[] | undefined;
 }>>>;
-export type BuilderComponentWhenSerialised = BuilderWhenSerialised<BuilderComponentConfigSerialised>;
+export type BuilderComponentConditionSerialised = BuilderConditionSerialised<BuilderComponentConfigSerialised>;
 export declare const BuilderComponentSelectMapSerialisedSchema: v.GenericSchema<import("..").BuilderMatchSelectMap<Readonly<{
     type: "parameter";
     id: string;
@@ -123,7 +123,7 @@ export declare const BuilderComponentSerialisedSchema: v.SchemaWithPipe<readonly
             tags?: readonly string[] | undefined;
         }>[];
         tags?: readonly string[] | undefined;
-    }>]>, v.GenericSchema<BuilderWhenSerialised<Readonly<{
+    }>]>, v.GenericSchema<BuilderConditionSerialised<Readonly<{
         details: Readonly<{
             type: "parameter";
             id: string;
@@ -181,7 +181,7 @@ export declare const BuilderComponentSerialisedSchema: v.SchemaWithPipe<readonly
             tags?: readonly string[] | undefined;
         }>[];
         tags?: readonly string[] | undefined;
-    }> | BuilderWhenSerialised<Readonly<{
+    }> | BuilderConditionSerialised<Readonly<{
         details: Readonly<{
             type: "parameter";
             id: string;
@@ -276,7 +276,7 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
             tags?: readonly string[] | undefined;
         }>[];
         tags?: readonly string[] | undefined;
-    }>]>, v.GenericSchema<BuilderWhenSerialised<Readonly<{
+    }>]>, v.GenericSchema<BuilderConditionSerialised<Readonly<{
         details: Readonly<{
             type: "parameter";
             id: string;
@@ -334,7 +334,7 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
             tags?: readonly string[] | undefined;
         }>[];
         tags?: readonly string[] | undefined;
-    }> | BuilderWhenSerialised<Readonly<{
+    }> | BuilderConditionSerialised<Readonly<{
         details: Readonly<{
             type: "parameter";
             id: string;
@@ -385,7 +385,7 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
             tags?: readonly string[] | undefined;
         }>[];
         tags?: readonly string[] | undefined;
-    }> | BuilderWhenSerialised<Readonly<{
+    }> | BuilderConditionSerialised<Readonly<{
         details: Readonly<{
             type: "parameter";
             id: string;
@@ -413,19 +413,7 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
     tags?: readonly string[] | undefined;
 }>[]>]>;
 export type BuilderComponentsSerialised = v.InferOutput<typeof BuilderComponentsSerialisedSchema>;
-export declare const validateComponentWhen: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors").BuilderIssuesScope) => import("..").ValidationResult<{
-    readonly type: "enable";
-    readonly payload: {
-        readonly details: readonly {
-            readonly type: "component-detail";
-            readonly name: string;
-            readonly kind: "string" | "number" | "boolean" | "price" | "image";
-            readonly isOptional: boolean;
-            readonly tags?: readonly string[] | undefined;
-        }[];
-        readonly tags?: readonly string[] | undefined;
-    };
-} | {
+export declare const validateComponentCondition: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors").BuilderIssuesScope) => import("..").ValidationResult<{
     readonly type: "match";
     readonly matchPath: readonly (string | number)[];
     readonly selectMap: {

package/dist/entities/component/component.js

@@ -5,7 +5,7 @@ import { createEntityValidator } from '../kind.js';
 import { BuilderPathsSchema } from '../paths.js';
 import { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
-import { createSelectMapSerialisedSchema, createWhenSerialisedSchema } from '../when.js';
+import { createSelectMapSerialisedSchema, createConditionSerialisedSchema } from '../condition.js';
 import { BuilderComponentConfigSerialisedSchema } from './config.js';
 export class BuilderComponent {
     name;
@@ -23,14 +23,14 @@ export class BuilderComponent {
     }
 }
 export const BuilderComponentSchema = v.instance(BuilderComponent);
-export const BuilderComponentWhenSerialisedSchema = createWhenSerialisedSchema(BuilderComponentConfigSerialisedSchema);
+export const BuilderComponentConditionSerialisedSchema = createConditionSerialisedSchema(BuilderComponentConfigSerialisedSchema);
 export const BuilderComponentSelectMapSerialisedSchema = createSelectMapSerialisedSchema(BuilderComponentConfigSerialisedSchema);
 export const BuilderComponentSerialisedSchema = serialisable(v.object({
     name: NameSchema,
-    payload: paramable(v.union([BuilderComponentConfigSerialisedSchema, BuilderComponentWhenSerialisedSchema])),
+    payload: paramable(v.union([BuilderComponentConfigSerialisedSchema, BuilderComponentConditionSerialisedSchema])),
     paths: v.optional(paramable(BuilderPathsSchema)),
     tags: v.optional(BuilderTagsSchema)
 }));
 export const BuilderComponentsSerialisedSchema = v.pipe(v.array(BuilderComponentSerialisedSchema), v.readonly());
-export const validateComponentWhen = createEntityValidator('componentWhen', BuilderComponentWhenSerialisedSchema);
+export const validateComponentCondition = createEntityValidator('componentCondition', BuilderComponentConditionSerialisedSchema);
 export const validateComponentSelectMap = createEntityValidator('componentSelectMap', BuilderComponentSelectMapSerialisedSchema);

package/dist/entities/component/{when.d.ts → condition.d.ts}

@@ -1,11 +1,10 @@
 import type { BuilderPrimitivesNonEmpty } from '../../primitive';
 import type { Paramable } from '../../references';
 import type { BuilderPath } from '../paths';
-import type { BuilderEnableConfig, BuilderMatchConfig, BuilderMatchSelectMap, BuilderUnlessConfig, BuilderWhen } from '../when';
+import type { BuilderMatchConfig, BuilderMatchSelectMap, BuilderUnlessConfig, BuilderCondition } from '../condition';
 import type { BuilderComponentConfig } from './config';
-export type BuilderComponentWhen = BuilderWhen<Paramable<BuilderComponentConfig>, Paramable<BuilderPath>, Paramable<Record<string, Paramable<BuilderComponentConfig> | null>>, Paramable<BuilderPath>>;
-export declare const componentWhen: {
-    enable: <const Payload extends Paramable<BuilderComponentConfig>>(payload?: Payload) => BuilderEnableConfig<Payload>;
+export type BuilderComponentCondition = BuilderCondition<Paramable<BuilderComponentConfig>, Paramable<BuilderPath>, Paramable<Record<string, Paramable<BuilderComponentConfig> | null>>, Paramable<BuilderPath>>;
+export declare const componentCondition: {
     match: <const Payload extends Paramable<BuilderComponentConfig>, const MatchPath extends Paramable<BuilderPath>, const SelectMap extends Paramable<BuilderMatchSelectMap<Paramable<BuilderComponentConfig>>>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderMatchConfig<Payload, MatchPath, SelectMap>;
     unless: <const UnlessPath extends Paramable<BuilderPath>, const Payload extends Paramable<BuilderComponentConfig>>(unlessPath: UnlessPath, disabledValues: BuilderPrimitivesNonEmpty, payload?: Payload) => BuilderUnlessConfig<Payload, UnlessPath>;
 };

package/dist/entities/component/{when.js → condition.js}

@@ -1,13 +1,7 @@
-import { createWhenFactories } from '../when.js';
+import { createConditionFactories } from '../condition.js';
 import { componentConfig } from './config.js';
-const baseFactories = createWhenFactories();
-export const componentWhen = {
-    enable: (payload) => {
-        return {
-            type: 'enable',
-            payload: (payload ?? componentConfig())
-        };
-    },
+const baseFactories = createConditionFactories();
+export const componentCondition = {
     match: baseFactories.match,
     unless: (unlessPath, disabledValues, payload) => {
         return {

package/dist/entities/component/index.d.ts

@@ -1,10 +1,10 @@
-export type { BuilderComponentPayload, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhenSerialised } from './component';
+export type { BuilderComponentPayload, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentConditionSerialised } from './component';
 export type { BuilderComponentConfigSerialised, BuilderComponentConfigsSerialised } from './config';
 export type { ComponentAsserted } from './expectation';
 export type { BuilderComponentDetailKind, BuilderComponentDetails, BuilderComponentDetailSerialised, BuilderComponentDetailsSerialised } from './detail';
-export type { BuilderComponentWhen } from './when';
-export { BuilderComponent, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, validateComponentSelectMap, validateComponentWhen } from './component.js';
+export type { BuilderComponentCondition } from './condition';
+export { BuilderComponent, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentConditionSerialisedSchema, validateComponentSelectMap, validateComponentCondition } from './component.js';
 export { BuilderComponentConfig, BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentConfigsSerialisedSchema, componentConfig, validateComponentConfig } from './config.js';
 export { componentExpectation } from './expectation.js';
 export { BuilderComponentDetail, BuilderComponentDetailKindSchema, BuilderComponentDetailSchema, BuilderComponentDetailSerialisedSchema, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, detailBoolean, detailImage, detailNumber, detailPrice, detailString, detailValueSchema } from './detail.js';
-export { componentWhen } from './when.js';
+export { componentCondition } from './condition.js';

package/dist/entities/component/index.js

@@ -1,5 +1,5 @@
-export { BuilderComponent, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, validateComponentSelectMap, validateComponentWhen } from './component.js';
+export { BuilderComponent, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentConditionSerialisedSchema, validateComponentSelectMap, validateComponentCondition } from './component.js';
 export { BuilderComponentConfig, BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentConfigsSerialisedSchema, componentConfig, validateComponentConfig } from './config.js';
 export { componentExpectation } from './expectation.js';
 export { BuilderComponentDetail, BuilderComponentDetailKindSchema, BuilderComponentDetailSchema, BuilderComponentDetailSerialisedSchema, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, detailBoolean, detailImage, detailNumber, detailPrice, detailString, detailValueSchema } from './detail.js';
-export { componentWhen } from './when.js';
+export { componentCondition } from './condition.js';

package/dist/entities/{when.d.ts → condition.d.ts}

@@ -3,10 +3,6 @@ import type { BuilderParameter, BuilderParameterSerialised, Paramable } from '..
 import type { BuilderModelGeneric, BuilderModelState, BuilderModelStateOf } from './model/index';
 import type { BuilderPath, BuilderPaths } from './paths';
 import * as v from 'valibot';
-export type BuilderEnableConfig<Payload = unknown> = {
-    readonly type: 'enable';
-    readonly payload: Payload;
-};
 export type BuilderMatchSelectMap<Item> = Record<string, Item | null>;
 export type BuilderMatchConfig<Payload = unknown, MatchPath = BuilderPath, SelectMap = BuilderMatchSelectMap<Payload>> = {
     readonly type: 'match';
@@ -19,11 +15,10 @@ export type BuilderUnlessConfig<Payload = unknown, UnlessPath = BuilderPath> = {
     readonly disabledValues: BuilderPrimitives;
     readonly payload: Payload;
 };
-export type BuilderWhen<Payload = unknown, MatchPath = BuilderPath, MatchSelectMap = Record<string, Payload | null>, UnlessPath = BuilderPath> = BuilderEnableConfig<Payload> | BuilderMatchConfig<Payload, MatchPath, MatchSelectMap> | BuilderUnlessConfig<Payload, UnlessPath>;
-export type BuilderWhenSerialised<Payload> = {
-    readonly type: 'enable';
-    readonly payload: Payload | BuilderParameterSerialised;
-} | {
+export type BuilderCondition<Payload = unknown, MatchPath = BuilderPath, MatchSelectMap = Record<string, Payload | null>, UnlessPath = BuilderPath> = BuilderMatchConfig<Payload, MatchPath, MatchSelectMap> | BuilderUnlessConfig<Payload, UnlessPath>;
+export declare function match<const MatchPath extends Paramable<BuilderPath>, const SelectMap extends Paramable<BuilderMatchSelectMap<unknown>>>(matchPath: MatchPath, selectMap: SelectMap): BuilderMatchConfig<unknown, MatchPath, SelectMap>;
+export declare function unless<const Values, const UnlessPath extends Paramable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: BuilderPrimitivesNonEmpty, values: Values): BuilderUnlessConfig<Values, UnlessPath>;
+export type BuilderConditionSerialised<Payload> = {
     readonly type: 'match';
     readonly matchPath: BuilderParameterSerialised | BuilderPath;
     readonly selectMap: Record<string, (Payload | BuilderParameterSerialised) | null> | BuilderParameterSerialised;
@@ -33,13 +28,10 @@ export type BuilderWhenSerialised<Payload> = {
     readonly disabledValues: BuilderPrimitives;
     readonly payload: Payload | BuilderParameterSerialised;
 };
-export type WhenConfigPayload<Config extends BuilderWhenGeneric, Payload> = Config extends {
+export type ConditionConfigPayload<Config extends BuilderConditionGeneric, Payload> = Config extends {
     readonly payload: infer Inner extends Payload;
 } ? Inner : Config extends BuilderMatchConfig ? NonNullable<Config['selectMap'][keyof Config['selectMap']]> & Payload : never;
-export declare const BuilderWhenEnableSchema: v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"enable", undefined>;
-}, undefined>;
-export declare const BuilderWhenMatchSchema: v.ObjectSchema<{
+export declare const BuilderConditionMatchSchema: v.ObjectSchema<{
     readonly type: v.LiteralSchema<"match", undefined>;
     readonly matchPath: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly type: v.LiteralSchema<"parameter", undefined>;
@@ -57,7 +49,7 @@ export declare const BuilderWhenMatchSchema: v.ObjectSchema<{
         id: string;
     }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>;
 }, undefined>;
-export declare const BuilderWhenUnlessSchema: v.ObjectSchema<{
+export declare const BuilderConditionUnlessSchema: v.ObjectSchema<{
     readonly type: v.LiteralSchema<"unless", undefined>;
     readonly unlessPath: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly type: v.LiteralSchema<"parameter", undefined>;
@@ -75,9 +67,7 @@ export declare const BuilderWhenUnlessSchema: v.ObjectSchema<{
         id: string;
     }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>;
 }, undefined>;
-export declare const BuilderWhenConfigSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"enable", undefined>;
-}, undefined>, v.ObjectSchema<{
+export declare const BuilderConditionConfigSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"match", undefined>;
     readonly matchPath: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly type: v.LiteralSchema<"parameter", undefined>;
@@ -112,8 +102,6 @@ export declare const BuilderWhenConfigSchema: v.SchemaWithPipe<readonly [v.Varia
         id: string;
     }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>;
 }, undefined>], undefined>, v.ReadonlyAction<{
-    type: "enable";
-} | {
     type: "match";
     matchPath: readonly (string | number)[] | Readonly<{
         type: "parameter";
@@ -134,21 +122,20 @@ export declare const BuilderWhenConfigSchema: v.SchemaWithPipe<readonly [v.Varia
         id: string;
     }>;
 }>]>;
-export type BuilderWhenConfig = v.InferOutput<typeof BuilderWhenConfigSchema>;
-export type BuilderWhenGeneric = BuilderWhen<unknown, unknown, unknown, unknown>;
-export declare const BuilderWhenSerialisedSchema: v.GenericSchema<BuilderWhenSerialised<unknown>>;
-export declare function whenBranches<Leaf>(payload: unknown, schema: v.GenericSchema<Leaf>): ReadonlyArray<Leaf>;
+export type BuilderConditionConfig = v.InferOutput<typeof BuilderConditionConfigSchema>;
+export type BuilderConditionGeneric = BuilderCondition<unknown, unknown, unknown, unknown>;
+export declare const BuilderConditionSerialisedSchema: v.GenericSchema<BuilderConditionSerialised<unknown>>;
+export declare function conditionBranches<Leaf>(payload: unknown, schema: v.GenericSchema<Leaf>): ReadonlyArray<Leaf>;
 export declare function createSelectMapSerialisedSchema<Payload extends v.GenericSchema>(payloadSchema: Payload): v.GenericSchema<BuilderMatchSelectMap<v.InferOutput<Payload> | BuilderParameterSerialised>>;
-export declare function createWhenSerialisedSchema<Payload extends v.GenericSchema>(payloadSchema: Payload): v.GenericSchema<BuilderWhenSerialised<v.InferOutput<Payload>>>;
-export declare function createWhenFactories<Payload>(): {
-    enable: <const Values extends Paramable<Payload>>(values: Values) => BuilderEnableConfig<Values>;
+export declare function createConditionSerialisedSchema<Payload extends v.GenericSchema>(payloadSchema: Payload): v.GenericSchema<BuilderConditionSerialised<v.InferOutput<Payload>>>;
+export declare function createConditionFactories<Payload>(): {
     match: <const MatchPayload extends Paramable<Payload>, const MatchPath extends Paramable<BuilderPath>, const SelectMap extends Paramable<BuilderMatchSelectMap<Paramable<Payload>>>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
     unless: <const Values extends Paramable<Payload>, const UnlessPath extends Paramable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: BuilderPrimitivesNonEmpty, values: Values) => BuilderUnlessConfig<Values, UnlessPath>;
 };
 export type BuilderValidPath<State extends BuilderModelState> = InstanceValidPath<State['instance']>;
 export type BuilderValidPaths<State extends BuilderModelState> = ReadonlyArray<BuilderValidPath<State>>;
 export type BuilderValidPathsOf<Input extends Paramable<BuilderModelGeneric>> = BuilderValidPaths<BuilderModelStateOf<Input>>;
-export type BuilderWhenConstrained<State extends BuilderModelState, Config> = Config extends BuilderParameter ? Config : Config extends {
+export type BuilderConditionConstrained<State extends BuilderModelState, Config> = Config extends BuilderParameter ? Config : Config extends {
     readonly type: 'match';
     readonly matchPath: infer MatchPath extends BuilderPath;
     readonly selectMap: infer SelectMap;
@@ -161,25 +148,25 @@ export type BuilderWhenConstrained<State extends BuilderModelState, Config> = Co
 } ? Config & {
     readonly unlessPath: [UnlessPath] extends [Readonly<BuilderValidPath<State>>] ? UnlessPath : Readonly<BuilderValidPath<State>>;
 } : Config;
-export type WhenConfigNullable<Config extends BuilderWhenGeneric> = Config extends {
+export type ConditionConfigNullable<Config extends BuilderConditionGeneric> = Config extends {
     readonly type: 'unless';
 } ? null : Config extends {
     readonly type: 'match';
     readonly selectMap: infer SelectMap;
 } ? null extends SelectMap[keyof SelectMap] ? null : never : never;
-export type WhenNullability<State extends BuilderModelState, ConditionPaths extends Paramable<BuilderPaths>, Config extends Paramable<BuilderWhenGeneric>> = [ConditionPaths] extends [BuilderParameter] ? null : WhenNullabilityFromPaths<State['instance'], Extract<ConditionPaths, BuilderValidPaths<State>>, Config>;
+export type ConditionNullability<State extends BuilderModelState, ConditionPaths extends Paramable<BuilderPaths>, Config extends Paramable<BuilderConditionGeneric>> = [ConditionPaths] extends [BuilderParameter] ? null : ConditionNullabilityFromPaths<State['instance'], Extract<ConditionPaths, BuilderValidPaths<State>>, Config>;
 type BuilderResolvePath<Instance, Path extends BuilderPath> = Path extends readonly [
     infer Head extends keyof Instance & string
 ] ? Instance[Head] : Path extends readonly [
     infer Head extends keyof Instance & string,
     ...infer Tail extends BuilderPath
 ] ? Instance[Head] extends ReadonlyArray<infer Item> ? Tail extends readonly [number, ...infer Rest extends BuilderPath] ? BuilderResolvePath<Item, Rest> : never : BuilderResolvePath<Instance[Head], Tail> : never;
-type WhenNullabilityFromPaths<Instance, ConditionPaths extends BuilderPaths, Config extends Paramable<BuilderWhenGeneric>> = Config extends BuilderParameter ? WhenPathsNullable<Instance, ConditionPaths> : Config extends BuilderWhenGeneric ? WhenPathsNullable<Instance, ConditionPaths> | WhenConfigNullable<Config> : never;
-type WhenPathsNullable<Instance, ConditionPaths extends BuilderPaths> = ConditionPaths extends readonly [
+type ConditionNullabilityFromPaths<Instance, ConditionPaths extends BuilderPaths, Config extends Paramable<BuilderConditionGeneric>> = Config extends BuilderParameter ? ConditionPathsNullable<Instance, ConditionPaths> : Config extends BuilderConditionGeneric ? ConditionPathsNullable<Instance, ConditionPaths> | ConditionConfigNullable<Config> : never;
+type ConditionPathsNullable<Instance, ConditionPaths extends BuilderPaths> = ConditionPaths extends readonly [
     infer Head extends BuilderPath,
     ...infer Tail extends BuilderPaths
-] ? WhenPathNullable<Instance, Head> | WhenPathsNullable<Instance, Tail> : never;
-type WhenPathNullable<Instance, Path extends BuilderPath> = null extends BuilderResolvePath<Instance, Path> ? null : never;
+] ? ConditionPathNullable<Instance, Head> | ConditionPathsNullable<Instance, Tail> : never;
+type ConditionPathNullable<Instance, Path extends BuilderPath> = null extends BuilderResolvePath<Instance, Path> ? null : never;
 type InstanceValidPath<Instance, Depth extends ReadonlyArray<never> = []> = Depth['length'] extends 10 ? never : Instance extends BuilderPrimitive | null ? never : Instance extends ReadonlyArray<infer Item> ? [number] | [number, ...InstanceValidPath<Item, [...Depth, never]>] : {
     [Key in keyof Instance & string]: [Key] | (Instance[Key] extends BuilderPrimitive | null ? never : [Key, ...InstanceValidPath<Instance[Key], [...Depth, never]>]);
 }[keyof Instance & string];