@builder-builder/builder 0.0.28 → 0.0.29

package/dist/entities/model/model.js

@@ -1,8 +1,8 @@
 import * as v from 'valibot';
-import { BuilderCollectionsSerialisedSchema } from '../collection/index.js';
-import { BuilderComponentsSerialisedSchema } from '../component/index.js';
+import { BuilderCollection, BuilderCollectionsSerialisedSchema } from '../collection/index.js';
+import { BuilderComponent, BuilderComponentsSerialisedSchema, componentConfig } from '../component/index.js';
 import { BuilderExpectationsSerialisedSchema } from '../expectation.js';
-import { BuilderOptionsSerialisedSchema } from '../option/index.js';
+import { BuilderOption, BuilderOptionsSerialisedSchema } from '../option/index.js';
 import { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
 import { builderCollectionMethod, builderComponentMethod, builderOptionMethod } from './methods.js';
@@ -27,37 +27,35 @@ export class BuilderModel {
     }
     get option() {
         const method = builderOptionMethod();
-        const add = (name, payload) => {
-            return this.#next({ options: [...this.options, method(name, payload)] });
-        };
-        const when = (paths, name, config) => {
-            return this.#next({ options: [...this.options, method.when(paths, name, config)] });
-        };
-        return Object.assign(add, { when });
+        return ((name, payload) => this.#next({
+            options: [...this.options, method(name, payload)]
+        }));
     }
     get component() {
         const method = builderComponentMethod();
-        const add = (name, details) => {
-            return this.#next({ components: [...this.components, method(name, details)] });
-        };
-        const when = (paths, name, config) => {
-            return this.#next({
-                components: [...this.components, method.when(paths, name, config)]
-            });
-        };
-        return Object.assign(add, { when });
+        return ((name, details) => this.#next({
+            components: [...this.components, method(name, details)]
+        }));
     }
     get collection() {
         const method = builderCollectionMethod();
-        const add = (name, payload) => {
-            return this.#next({ collections: [...this.collections, method(name, payload)] });
-        };
-        const when = (paths, name, config) => {
-            return this.#next({
-                collections: [...this.collections, method.when(paths, name, config)]
-            });
+        return ((name, payload) => this.#next({
+            collections: [...this.collections, method(name, payload)]
+        }));
+    }
+    if(paths) {
+        return {
+            option: (name, payload) => this.#next({ options: [...this.options, new BuilderOption(name, payload, paths)] }),
+            collection: (name, payload) => this.#next({
+                collections: [...this.collections, new BuilderCollection(name, payload, paths)]
+            }),
+            component: (name, payload) => this.#next({
+                components: [
+                    ...this.components,
+                    new BuilderComponent(name, payload ?? componentConfig(), paths)
+                ]
+            })
         };
-        return Object.assign(add, { when });
     }
     expect(...expectations) {
         return this.#next({ expectations: [...this.expectations, ...expectations] });

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

@@ -0,0 +1,9 @@
+import type { Paramable } from '../../references';
+import type { BuilderPath } from '../paths';
+import type { BuilderCondition } from '../condition';
+import type { BuilderOptionConfig } from './config';
+export type BuilderOptionCondition = BuilderCondition<Paramable<BuilderOptionConfig>, Paramable<BuilderPath>, Paramable<Record<string, Paramable<BuilderOptionConfig> | null>>, Paramable<BuilderPath>>;
+export declare const optionCondition: {
+    match: <const MatchPayload extends Paramable<import("./value").BuilderValueConfig<import("valibot").GenericSchema<string | number | boolean | null>> | import("./select").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>>>, const MatchPath extends Paramable<BuilderPath>, const SelectMap extends Paramable<import("..").BuilderMatchSelectMap<Paramable<import("./value").BuilderValueConfig<import("valibot").GenericSchema<string | number | boolean | null>> | import("./select").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("..").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends Paramable<import("./value").BuilderValueConfig<import("valibot").GenericSchema<string | number | boolean | null>> | import("./select").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>>>, const UnlessPath extends Paramable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("../../primitive").BuilderPrimitivesNonEmpty, values: Values) => import("..").BuilderUnlessConfig<Values, UnlessPath>;
+};

package/dist/entities/option/condition.js

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

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

@@ -1,109 +1,84 @@
 import * as v from 'valibot';
-export declare const BuilderOptionConfigSchema: v.UnionSchema<[v.InstanceSchema<typeof import("./select.js").BuilderSelectConfig, undefined>, v.InstanceSchema<typeof import("./toggle.js").BuilderToggleConfig, undefined>], undefined>;
+export declare const BuilderOptionConfigSchema: v.UnionSchema<[v.InstanceSchema<typeof import("./select.js").BuilderSelectConfig, undefined>, v.InstanceSchema<typeof import("./value.js").BuilderValueConfig, undefined>], undefined>;
 export type BuilderOptionConfig = v.InferOutput<typeof BuilderOptionConfigSchema>;
-export declare const BuilderOptionConfigSerialisedSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"select", undefined>;
-    readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
-    readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+export declare const BuilderOptionConfigSerialisedSchema: 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 optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
     readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
-}, undefined>, v.ReadonlyAction<{
-    type: "select";
-    readonly options: readonly [string, ...string[]];
-    defaultValue: string | null;
-    isOptional: boolean;
-    optionLabels: {
-        [x: string]: string;
-    };
-    tags?: readonly string[] | undefined;
-}>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"toggle", undefined>;
-    readonly kind: v.PicklistSchema<["string", "boolean", "number"], 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>, v.ReadonlyAction<{
-    type: "toggle";
+}, undefined>], undefined>, v.ReadonlyAction<{
     kind: "string" | "number" | "boolean";
+    type: "value";
     defaultValue: string | number | boolean | null;
     isOptional: boolean;
     tags?: readonly string[] | undefined;
-}>]>], undefined>, v.ReadonlyAction<Readonly<{
-    type: "select";
+} | {
+    kind: "select";
     readonly options: readonly [string, ...string[]];
-    defaultValue: string | null;
-    isOptional: boolean;
-    optionLabels: {
+    optionLabels?: {
         [x: string]: string;
-    };
-    tags?: readonly string[] | undefined;
-}> | Readonly<{
-    type: "toggle";
-    kind: "string" | "number" | "boolean";
+    } | undefined;
+    type: "value";
     defaultValue: string | number | boolean | null;
     isOptional: boolean;
     tags?: readonly string[] | undefined;
-}>>]>;
+}>]>;
 export type BuilderOptionConfigSerialised = v.InferOutput<typeof BuilderOptionConfigSerialisedSchema>;
-export declare const BuilderOptionConfigsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"select", undefined>;
-    readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
-    readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+export declare const BuilderOptionConfigsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<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 optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
     readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
-}, undefined>, v.ReadonlyAction<{
-    type: "select";
-    readonly options: readonly [string, ...string[]];
-    defaultValue: string | null;
-    isOptional: boolean;
-    optionLabels: {
-        [x: string]: string;
-    };
-    tags?: readonly string[] | undefined;
-}>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"toggle", undefined>;
-    readonly kind: v.PicklistSchema<["string", "boolean", "number"], 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>, v.ReadonlyAction<{
-    type: "toggle";
+}, undefined>], undefined>, v.ReadonlyAction<{
     kind: "string" | "number" | "boolean";
+    type: "value";
     defaultValue: string | number | boolean | null;
     isOptional: boolean;
     tags?: readonly string[] | undefined;
-}>]>], undefined>, v.ReadonlyAction<Readonly<{
-    type: "select";
+} | {
+    kind: "select";
     readonly options: readonly [string, ...string[]];
-    defaultValue: string | null;
-    isOptional: boolean;
-    optionLabels: {
+    optionLabels?: {
         [x: string]: string;
-    };
+    } | undefined;
+    type: "value";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
     tags?: readonly string[] | undefined;
-}> | Readonly<{
-    type: "toggle";
+}>]>, undefined>, v.ReadonlyAction<(Readonly<{
     kind: "string" | "number" | "boolean";
+    type: "value";
     defaultValue: string | number | boolean | null;
     isOptional: boolean;
     tags?: readonly string[] | undefined;
-}>>]>, undefined>, v.ReadonlyAction<(Readonly<Readonly<{
-    type: "select";
+}> | Readonly<{
+    kind: "select";
     readonly options: readonly [string, ...string[]];
-    defaultValue: string | null;
-    isOptional: boolean;
-    optionLabels: {
+    optionLabels?: {
         [x: string]: string;
-    };
-    tags?: readonly string[] | undefined;
-}>> | Readonly<Readonly<{
-    type: "toggle";
-    kind: "string" | "number" | "boolean";
+    } | undefined;
+    type: "value";
     defaultValue: string | number | boolean | null;
     isOptional: boolean;
     tags?: readonly string[] | undefined;
-}>>)[]>]>;
+}>)[]>]>;
 export type BuilderOptionConfigsSerialised = v.InferOutput<typeof BuilderOptionConfigsSerialisedSchema>;
 export declare function optionValueSchema(payload: BuilderOptionConfigSerialised): v.GenericSchema;

package/dist/entities/option/config.js

@@ -1,15 +1,15 @@
 import * as v from 'valibot';
-import { BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, selectValueSchema } from './select.js';
-import { BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, toggleValueSchema } from './toggle.js';
+import { BuilderSelectConfigSchema, selectValueSchema } from './select.js';
+import { BuilderValueConfigSchema, BuilderValueConfigSerialisedSchema, valueKindSchema } from './value.js';
 export const BuilderOptionConfigSchema = v.union([
     BuilderSelectConfigSchema,
-    BuilderToggleConfigSchema
+    BuilderValueConfigSchema
 ]);
-export const BuilderOptionConfigSerialisedSchema = v.pipe(v.variant('type', [BuilderSelectConfigSerialisedSchema, BuilderToggleConfigSerialisedSchema]), v.readonly());
+export const BuilderOptionConfigSerialisedSchema = BuilderValueConfigSerialisedSchema;
 export const BuilderOptionConfigsSerialisedSchema = v.pipe(v.array(BuilderOptionConfigSerialisedSchema), v.readonly());
 export function optionValueSchema(payload) {
-    if (payload.type === 'select') {
+    if (payload.kind === 'select') {
         return selectValueSchema(payload.options, payload.isOptional);
     }
-    return toggleValueSchema(payload.kind, payload.isOptional);
+    return valueKindSchema(payload.kind, payload.isOptional);
 }

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

@@ -1,2 +1,7 @@
+import type { BuilderOptionConfig } from './config';
 import { BuilderExpectation } from '../expectation.js';
-export declare function optionExpectation<const Name extends string>(name: Name): BuilderExpectation<Name, string, "option">;
+export declare function optionExpectation<const Name extends string, const Payload extends BuilderOptionConfig | null = null>(name: Name, payload?: Payload): BuilderExpectation<Name, OptionExpectationValue<Payload>, "option">;
+type OptionExpectationValue<Payload> = Payload extends {
+    readonly value: infer Value;
+} ? Value : unknown;
+export {};

package/dist/entities/option/expectation.js

@@ -1,4 +1,4 @@
 import { BuilderExpectation } from '../expectation.js';
-export function optionExpectation(name) {
-    return new BuilderExpectation(name, 'option');
+export function optionExpectation(name, payload) {
+    return new BuilderExpectation(name, 'option', payload ?? null);
 }

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

@@ -1,11 +1,11 @@
 export type { BuilderOptionConfig, BuilderOptionConfigSerialised, BuilderOptionConfigsSerialised } from './config';
-export type { BuilderOptionPayload, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionWhenSerialised } from './option';
-export type { BuilderSelectConfigLabels, BuilderSelectConfigSerialised, BuilderSelectConfigValues } from './select';
-export type { BuilderToggleConfigSerialised, BuilderToggleKind } from './toggle';
-export type { BuilderOptionWhen } from './when';
+export type { BuilderOptionPayload, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionConditionSerialised } from './option';
+export type { BuilderValueOptionLabels, BuilderValueOptions } from './select';
+export type { BuilderValueConfigSerialised, BuilderValueKind } from './value';
+export type { BuilderOptionCondition } from './condition';
 export { BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionConfigsSerialisedSchema, optionValueSchema } from './config.js';
 export { optionExpectation } from './expectation.js';
-export { BuilderOption, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema, validateOptionSelectMap, validateOptionWhen } from './option.js';
-export { BuilderSelectConfig, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, select, validateSelect } from './select.js';
-export { BuilderToggleConfig, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, toggleBoolean, toggleNumber, toggleString, validateToggle } from './toggle.js';
-export { optionWhen } from './when.js';
+export { BuilderOption, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionConditionSerialisedSchema, validateOptionSelectMap, validateOptionCondition } from './option.js';
+export { BuilderSelectConfig, BuilderSelectConfigSchema, valueSelect } from './select.js';
+export { BuilderValueConfig, BuilderValueConfigSchema, BuilderValueConfigSerialisedSchema, valueBoolean, valueNumber, valueString, validateValue } from './value.js';
+export { optionCondition } from './condition.js';

package/dist/entities/option/index.js

@@ -1,6 +1,6 @@
 export { BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionConfigsSerialisedSchema, optionValueSchema } from './config.js';
 export { optionExpectation } from './expectation.js';
-export { BuilderOption, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema, validateOptionSelectMap, validateOptionWhen } from './option.js';
-export { BuilderSelectConfig, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, select, validateSelect } from './select.js';
-export { BuilderToggleConfig, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, toggleBoolean, toggleNumber, toggleString, validateToggle } from './toggle.js';
-export { optionWhen } from './when.js';
+export { BuilderOption, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionConditionSerialisedSchema, validateOptionSelectMap, validateOptionCondition } from './option.js';
+export { BuilderSelectConfig, BuilderSelectConfigSchema, valueSelect } from './select.js';
+export { BuilderValueConfig, BuilderValueConfigSchema, BuilderValueConfigSerialisedSchema, valueBoolean, valueNumber, valueString, validateValue } from './value.js';
+export { optionCondition } from './condition.js';