@builder-builder/builder 0.0.27 → 0.0.29

package/dist/entities/component/config.js

@@ -4,39 +4,41 @@ import { paramable } from '../../references.js';
 import { createEntityValidator } from '../kind.js';
 import { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
-import { BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSerialisedSchema } from './field.js';
+import { BuilderComponentDetailsSerialisedSchema } from './detail.js';
 export class BuilderComponentConfig {
-    fields;
+    details;
     tags;
-    constructor(fields, tags) {
-        this.fields = fields;
+    constructor(details, tags) {
+        this.details = details;
         this.tags = tags;
     }
     tag(...tags) {
-        return new BuilderComponentConfig(this.fields, tags);
+        return new BuilderComponentConfig(this.details, tags);
     }
 }
 export const BuilderComponentConfigSchema = v.instance(BuilderComponentConfig);
 export const BuilderComponentConfigSerialisedSchema = serialisable(v.object({
-    fields: paramable(BuilderComponentFieldsSerialisedSchema),
+    details: paramable(BuilderComponentDetailsSerialisedSchema),
     tags: v.optional(BuilderTagsSchema)
 }));
 export const BuilderComponentConfigsSerialisedSchema = v.pipe(v.array(BuilderComponentConfigSerialisedSchema), v.readonly());
-export function componentConfig(...fields) {
-    return new BuilderComponentConfig(fields);
+export function componentConfig(...details) {
+    return new BuilderComponentConfig(details);
 }
 export const validateComponentConfig = createEntityValidator('componentConfig', BuilderComponentConfigSerialisedSchema, (input, errors) => {
-    if (!check.is(BuilderComponentFieldsSerialisedSchema, input.fields)) {
+    if (!check.is(BuilderComponentDetailsSerialisedSchema, input.details)) {
         return;
     }
-    const seen = new Set();
-    input.fields.forEach((field) => {
-        if (!check.is(BuilderComponentFieldSerialisedSchema, field)) {
-            return;
+    const seenNames = new Set();
+    const seenKinds = new Set();
+    input.details.forEach((detail) => {
+        if (seenNames.has(detail.name)) {
+            errors.entityDuplicateDetail();
         }
-        if (seen.has(field.name)) {
-            errors.entityDuplicateField();
+        seenNames.add(detail.name);
+        if (detail.kind === 'price' && seenKinds.has(detail.kind)) {
+            errors.entityDuplicatePrice();
         }
-        seen.add(field.name);
+        seenKinds.add(detail.kind);
     });
 });

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

@@ -0,0 +1,61 @@
+import type { BuilderPrimitive } from '../../primitive';
+import type { BuilderTags } from '../tags';
+import * as v from 'valibot';
+export declare const BuilderComponentDetailKindSchema: v.PicklistSchema<["string", "boolean", "number", "price", "image"], undefined>;
+export type BuilderComponentDetailKind = v.InferOutput<typeof BuilderComponentDetailKindSchema>;
+export declare class BuilderComponentDetail<const Name extends string = string, const ValueSchema extends v.GenericSchema<BuilderPrimitive> = v.GenericSchema<BuilderPrimitive>> {
+    #private;
+    readonly value: v.InferOutput<ValueSchema>;
+    readonly type: "component-detail";
+    readonly name: Name;
+    readonly kind: BuilderComponentDetailKind;
+    readonly valueSchema: ValueSchema;
+    readonly isOptional: boolean;
+    readonly tags?: BuilderTags;
+    constructor(name: Name, kind: BuilderComponentDetailKind, optional?: boolean, tags?: BuilderTags);
+    optional(): BuilderComponentDetail<Name, v.NullableSchema<ValueSchema, undefined>>;
+    tag(...tags: Array<string>): BuilderComponentDetail<Name, ValueSchema>;
+}
+export declare function detailString<const Name extends string>(name: Name): BuilderComponentDetail<Name, v.StringSchema<undefined>>;
+export declare function detailNumber<const Name extends string>(name: Name): BuilderComponentDetail<Name, v.NumberSchema<undefined>>;
+export declare function detailBoolean<const Name extends string>(name: Name): BuilderComponentDetail<Name, v.BooleanSchema<undefined>>;
+export declare function detailPrice<const Name extends string>(name: Name): BuilderComponentDetail<Name, v.NumberSchema<undefined>>;
+export declare function detailImage<const Name extends string>(name: Name): BuilderComponentDetail<Name, v.StringSchema<undefined>>;
+export declare const BuilderComponentDetailSchema: v.InstanceSchema<typeof BuilderComponentDetail, undefined>;
+export declare const BuilderComponentDetailsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.InstanceSchema<typeof BuilderComponentDetail, undefined>, undefined>, v.ReadonlyAction<BuilderComponentDetail<string, v.GenericSchema<string | number | boolean | null>>[]>]>;
+export type BuilderComponentDetails = v.InferOutput<typeof BuilderComponentDetailsSchema>;
+export declare const BuilderComponentDetailSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"component-detail", undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly kind: v.PicklistSchema<["string", "boolean", "number", "price", "image"], 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: "component-detail";
+    name: string;
+    kind: "string" | "number" | "boolean" | "price" | "image";
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+}>]>;
+export type BuilderComponentDetailSerialised = v.InferOutput<typeof BuilderComponentDetailSerialisedSchema>;
+export declare const BuilderComponentDetailsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"component-detail", undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly kind: v.PicklistSchema<["string", "boolean", "number", "price", "image"], 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: "component-detail";
+    name: string;
+    kind: "string" | "number" | "boolean" | "price" | "image";
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+}>]>, undefined>, v.ReadonlyAction<Readonly<{
+    type: "component-detail";
+    name: string;
+    kind: "string" | "number" | "boolean" | "price" | "image";
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+}>[]>]>;
+export type BuilderComponentDetailsSerialised = v.InferOutput<typeof BuilderComponentDetailsSerialisedSchema>;
+export declare function detailValueSchema(kind: BuilderComponentDetailKind, optional: boolean): v.GenericSchema<BuilderPrimitive>;

package/dist/entities/component/detail.js

@@ -0,0 +1,71 @@
+import * as v from 'valibot';
+import { BooleanSchema, NameSchema, NumberSchema, StringSchema, UrlSchema } from '../../primitive.js';
+import { serialisable } from '../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
+export const BuilderComponentDetailKindSchema = v.picklist([
+    'string',
+    'boolean',
+    'number',
+    'price',
+    'image'
+]);
+export class BuilderComponentDetail {
+    type = 'component-detail';
+    name;
+    kind;
+    valueSchema;
+    isOptional;
+    tags;
+    constructor(name, kind, optional = false, tags) {
+        this.name = name;
+        this.kind = kind;
+        this.valueSchema = detailValueSchema(kind, optional);
+        this.isOptional = optional;
+        this.tags = tags;
+    }
+    #next(patch) {
+        return new BuilderComponentDetail(this.name, this.kind, patch.optional ?? this.isOptional, patch.tags ?? this.tags);
+    }
+    optional() {
+        return this.#next({ optional: true });
+    }
+    tag(...tags) {
+        return this.#next({ tags });
+    }
+}
+export function detailString(name) {
+    return new BuilderComponentDetail(name, 'string');
+}
+export function detailNumber(name) {
+    return new BuilderComponentDetail(name, 'number');
+}
+export function detailBoolean(name) {
+    return new BuilderComponentDetail(name, 'boolean');
+}
+export function detailPrice(name) {
+    return new BuilderComponentDetail(name, 'price');
+}
+export function detailImage(name) {
+    return new BuilderComponentDetail(name, 'image');
+}
+export const BuilderComponentDetailSchema = v.instance(BuilderComponentDetail);
+export const BuilderComponentDetailsSchema = v.pipe(v.array(BuilderComponentDetailSchema), v.readonly());
+export const BuilderComponentDetailSerialisedSchema = serialisable(v.object({
+    type: v.literal('component-detail'),
+    name: NameSchema,
+    kind: BuilderComponentDetailKindSchema,
+    isOptional: BooleanSchema,
+    tags: v.optional(BuilderTagsSchema)
+}));
+export const BuilderComponentDetailsSerialisedSchema = v.pipe(v.array(BuilderComponentDetailSerialisedSchema), v.readonly());
+export function detailValueSchema(kind, optional) {
+    const kindSchemas = {
+        string: StringSchema,
+        number: NumberSchema,
+        boolean: BooleanSchema,
+        price: NumberSchema,
+        image: UrlSchema
+    };
+    const baseSchema = kindSchemas[kind];
+    return optional ? v.nullable(baseSchema) : baseSchema;
+}

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 { BuilderComponentFields, BuilderComponentFieldsSerialised, BuilderComponentFieldSerialised, BuilderComponentFieldValueType } from './field';
-export type { BuilderComponentWhen } from './when';
-export { BuilderComponent, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, validateComponentSelectMap, validateComponentWhen } from './component.js';
+export type { BuilderComponentDetailKind, BuilderComponentDetails, BuilderComponentDetailSerialised, BuilderComponentDetailsSerialised } from './detail';
+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 { BuilderComponentField, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, detailBoolean, detailNumber, detailString, detailValueSchema } from './field.js';
-export { componentWhen } from './when.js';
+export { BuilderComponentDetail, BuilderComponentDetailKindSchema, BuilderComponentDetailSchema, BuilderComponentDetailSerialisedSchema, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, detailBoolean, detailImage, detailNumber, detailPrice, detailString, detailValueSchema } from './detail.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 { BuilderComponentField, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, detailBoolean, detailNumber, detailString, detailValueSchema } from './field.js';
-export { componentWhen } from './when.js';
+export { BuilderComponentDetail, BuilderComponentDetailKindSchema, BuilderComponentDetailSchema, BuilderComponentDetailSerialisedSchema, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, detailBoolean, detailImage, detailNumber, detailPrice, detailString, detailValueSchema } from './detail.js';
+export { componentCondition } from './condition.js';

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

@@ -1,12 +1,8 @@
-import type { BuilderPrimitive, BuilderPrimitives } from '../primitive';
+import type { BuilderPrimitive, BuilderPrimitives, BuilderPrimitivesNonEmpty } from '../primitive';
 import type { BuilderParameter, BuilderParameterSerialised, Paramable } from '../references';
 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: BuilderPrimitives, values: Values) => BuilderUnlessConfig<Values, UnlessPath>;
+    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, GatePaths extends Paramable<BuilderPaths>, Config extends Paramable<BuilderWhenGeneric>> = [GatePaths] extends [BuilderParameter] ? null : WhenNullabilityFromPaths<State['instance'], Extract<GatePaths, 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, GatePaths extends BuilderPaths, Config extends Paramable<BuilderWhenGeneric>> = Config extends BuilderParameter ? WhenPathsNullable<Instance, GatePaths> : Config extends BuilderWhenGeneric ? WhenPathsNullable<Instance, GatePaths> | WhenConfigNullable<Config> : never;
-type WhenPathsNullable<Instance, GatePaths extends BuilderPaths> = GatePaths 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];

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

@@ -3,64 +3,59 @@ import { check } from '../errors/index.js';
 import { BuilderPrimitivesSchema, StringSchema } from '../primitive.js';
 import { isParamable, paramable } from '../references.js';
 import { BuilderPathSchema } from './paths.js';
-export const BuilderWhenEnableSchema = v.object({
-    type: v.literal('enable')
-});
-export const BuilderWhenMatchSchema = v.object({
+export function match(matchPath, selectMap) {
+    return { type: 'match', matchPath, selectMap };
+}
+export function unless(unlessPath, disabledValues, values) {
+    return { type: 'unless', unlessPath, disabledValues, payload: values };
+}
+export const BuilderConditionMatchSchema = v.object({
     type: v.literal('match'),
     matchPath: paramable(BuilderPathSchema)
 });
-export const BuilderWhenUnlessSchema = v.object({
+export const BuilderConditionUnlessSchema = v.object({
     type: v.literal('unless'),
     unlessPath: paramable(BuilderPathSchema)
 });
-export const BuilderWhenConfigSchema = v.pipe(v.variant('type', [BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema]), v.readonly());
-export const BuilderWhenSerialisedSchema = createWhenSerialisedSchema(v.unknown());
-export function whenBranches(payload, schema) {
+export const BuilderConditionConfigSchema = v.pipe(v.variant('type', [BuilderConditionMatchSchema, BuilderConditionUnlessSchema]), v.readonly());
+export const BuilderConditionSerialisedSchema = createConditionSerialisedSchema(v.unknown());
+export function conditionBranches(payload, schema) {
     if (check.is(schema, payload)) {
         return [payload];
     }
     if (isParamable(payload)) {
         return [];
     }
-    check.assert(BuilderWhenSerialisedSchema, payload);
-    const when = payload;
-    switch (when.type) {
-        case 'enable':
+    check.assert(BuilderConditionSerialisedSchema, payload);
+    const condition = payload;
+    switch (condition.type) {
         case 'unless': {
-            return [when.payload];
+            return [condition.payload];
         }
         case 'match': {
-            return Object.values(when.selectMap).filter((branch) => branch != null);
+            return Object.values(condition.selectMap).filter((branch) => branch != null);
         }
     }
 }
 export function createSelectMapSerialisedSchema(payloadSchema) {
     return v.pipe(v.record(StringSchema, v.nullable(paramable(payloadSchema))), v.readonly());
 }
-export function createWhenSerialisedSchema(payloadSchema) {
+export function createConditionSerialisedSchema(payloadSchema) {
     const paramablePayload = paramable(payloadSchema);
     return v.pipe(v.variant('type', [
         v.object({
-            ...BuilderWhenEnableSchema.entries,
-            payload: paramablePayload
-        }),
-        v.object({
-            ...BuilderWhenMatchSchema.entries,
+            ...BuilderConditionMatchSchema.entries,
             selectMap: paramable(createSelectMapSerialisedSchema(payloadSchema))
         }),
         v.object({
-            ...BuilderWhenUnlessSchema.entries,
+            ...BuilderConditionUnlessSchema.entries,
             disabledValues: BuilderPrimitivesSchema,
             payload: paramablePayload
         })
     ]), v.readonly());
 }
-export function createWhenFactories() {
+export function createConditionFactories() {
     return {
-        enable: (values) => {
-            return { type: 'enable', payload: values };
-        },
         match: (matchPath, selectMap) => {
             return { type: 'match', matchPath, selectMap };
         },

package/dist/entities/expectation.d.ts

@@ -1,3 +1,4 @@
+import type { BuilderOptionConfig } from './option/index';
 import * as v from 'valibot';
 export declare const BuilderExpectationKindSchema: v.PicklistSchema<["option", "component", "collection"], undefined>;
 export type BuilderExpectationKind = v.InferOutput<typeof BuilderExpectationKindSchema>;
@@ -6,7 +7,8 @@ export declare class BuilderExpectation<Name extends string = string, Value = un
     readonly value: Value;
     readonly name: Name;
     readonly kind: Kind;
-    constructor(name: Name, kind: Kind);
+    readonly payload: BuilderOptionConfig | null;
+    constructor(name: Name, kind: Kind, payload?: BuilderOptionConfig | null);
 }
 export declare const BuilderExpectationSchema: v.InstanceSchema<typeof BuilderExpectation, undefined>;
 export declare const BuilderExpectationsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.InstanceSchema<typeof BuilderExpectation, undefined>, undefined>, v.ReadonlyAction<BuilderExpectation<string, unknown, "option" | "component" | "collection">[]>]>;
@@ -14,23 +16,153 @@ export type BuilderExpectations = v.InferOutput<typeof BuilderExpectationsSchema
 export declare const BuilderExpectationSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
     readonly kind: v.PicklistSchema<["option", "component", "collection"], undefined>;
+    readonly payload: v.OptionalSchema<v.LazySchema<v.SchemaWithPipe<readonly [v.VariantSchema<"kind", [v.StrictObjectSchema<{
+        readonly kind: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+        readonly type: v.LiteralSchema<"value", 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.StrictObjectSchema<{
+        readonly kind: v.LiteralSchema<"select", undefined>;
+        readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
+        readonly optionLabels: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+        readonly type: v.LiteralSchema<"value", 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>], undefined>, v.ReadonlyAction<{
+        kind: "string" | "number" | "boolean";
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+        tags?: readonly string[] | undefined;
+    } | {
+        kind: "select";
+        readonly options: readonly [string, ...string[]];
+        optionLabels?: {
+            [x: string]: string;
+        } | undefined;
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+        tags?: readonly string[] | undefined;
+    }>]>>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     name: string;
     kind: "option" | "component" | "collection";
+    payload?: Readonly<{
+        kind: "string" | "number" | "boolean";
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+        tags?: readonly string[] | undefined;
+    }> | Readonly<{
+        kind: "select";
+        readonly options: readonly [string, ...string[]];
+        optionLabels?: {
+            [x: string]: string;
+        } | undefined;
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+        tags?: readonly string[] | undefined;
+    }> | undefined;
 }>]>;
 export type BuilderExpectationSerialised = v.InferOutput<typeof BuilderExpectationSerialisedSchema>;
 export declare const BuilderExpectationsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
     readonly kind: v.PicklistSchema<["option", "component", "collection"], undefined>;
+    readonly payload: v.OptionalSchema<v.LazySchema<v.SchemaWithPipe<readonly [v.VariantSchema<"kind", [v.StrictObjectSchema<{
+        readonly kind: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+        readonly type: v.LiteralSchema<"value", 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.StrictObjectSchema<{
+        readonly kind: v.LiteralSchema<"select", undefined>;
+        readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
+        readonly optionLabels: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+        readonly type: v.LiteralSchema<"value", 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>], undefined>, v.ReadonlyAction<{
+        kind: "string" | "number" | "boolean";
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+        tags?: readonly string[] | undefined;
+    } | {
+        kind: "select";
+        readonly options: readonly [string, ...string[]];
+        optionLabels?: {
+            [x: string]: string;
+        } | undefined;
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+        tags?: readonly string[] | undefined;
+    }>]>>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     name: string;
     kind: "option" | "component" | "collection";
+    payload?: Readonly<{
+        kind: "string" | "number" | "boolean";
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+        tags?: readonly string[] | undefined;
+    }> | Readonly<{
+        kind: "select";
+        readonly options: readonly [string, ...string[]];
+        optionLabels?: {
+            [x: string]: string;
+        } | undefined;
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+        tags?: readonly string[] | undefined;
+    }> | undefined;
 }>]>, undefined>, v.ReadonlyAction<Readonly<{
     name: string;
     kind: "option" | "component" | "collection";
+    payload?: Readonly<{
+        kind: "string" | "number" | "boolean";
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+        tags?: readonly string[] | undefined;
+    }> | Readonly<{
+        kind: "select";
+        readonly options: readonly [string, ...string[]];
+        optionLabels?: {
+            [x: string]: string;
+        } | undefined;
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+        tags?: readonly string[] | undefined;
+    }> | undefined;
 }>[]>]>;
 export type BuilderExpectationsSerialised = v.InferOutput<typeof BuilderExpectationsSerialisedSchema>;
-export declare const validateExpectations: (input: unknown, references?: import("./references.js").BuilderReferences, errors?: import("../errors/errors.js").BuilderErrorsScope) => import("./validated.js").ValidationResult<readonly ({
+export declare const validateExpectations: (input: unknown, references?: import("./references").BuilderReferences, issues?: import("../errors").BuilderIssuesScope) => import("./validated").ValidationResult<readonly {
     readonly name: string;
     readonly kind: "option" | "component" | "collection";
-} & import("../validate/brand.js").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;
+}[]>;