@builder-builder/builder 0.0.6 → 0.0.8

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

@@ -0,0 +1,11 @@
+import type { BuilderPath } from '../../paths';
+import type { BuilderPrimitives } from '../../primitive';
+import type { Refable } from '../../references';
+import type { BuilderEnableConfig, BuilderMatchConfig, BuilderMatchSelectMap, BuilderUnlessConfig, BuilderWhen } from '../when';
+import type { BuilderComponentDetails } from './details';
+export type BuilderComponentWhen = BuilderWhen<Refable<BuilderComponentDetails>>;
+export declare const componentWhen: {
+    enable: <const Payload extends Refable<BuilderComponentDetails>>(payload?: Payload) => BuilderEnableConfig<Payload>;
+    match: <const Payload extends Refable<BuilderComponentDetails>, const MatchPath extends Refable<BuilderPath>, const SelectMap extends Refable<BuilderMatchSelectMap<Refable<BuilderComponentDetails>>>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderMatchConfig<Payload, MatchPath, SelectMap>;
+    unless: <const UnlessPath extends Refable<BuilderPath>, const Payload extends Refable<BuilderComponentDetails>>(unlessPath: UnlessPath, disabledValues: BuilderPrimitives, payload?: Payload) => BuilderUnlessConfig<Payload, UnlessPath>;
+};

package/dist/entities/component/when.js

@@ -0,0 +1,20 @@
+import { createWhenFactories } from '../when.js';
+import { componentDetails } from './details.js';
+const baseFactories = createWhenFactories();
+export const componentWhen = {
+    enable: (payload) => {
+        return {
+            type: 'enable',
+            payload: (payload ?? componentDetails([]))
+        };
+    },
+    match: baseFactories.match,
+    unless: (unlessPath, disabledValues, payload) => {
+        return {
+            type: 'unless',
+            unlessPath,
+            disabledValues,
+            payload: (payload ?? componentDetails([]))
+        };
+    }
+};

package/dist/entities/errors.d.ts

@@ -0,0 +1,21 @@
+import type { BuilderPath } from '../paths';
+import type { BuilderExpectationKind } from './expectation';
+export type BuilderErrorUnmetExpectation = {
+    readonly kind: 'unmet-expectation';
+    readonly expectationKind: BuilderExpectationKind;
+    readonly name: string;
+};
+export type BuilderErrorUnboundParameter = {
+    readonly kind: 'unbound-parameter';
+    readonly name: string;
+};
+export type BuilderErrorInvalidGatePath = {
+    readonly kind: 'invalid-gate-path';
+    readonly name: string;
+    readonly path: BuilderPath;
+};
+export type BuilderErrorDuplicateName = {
+    readonly kind: 'duplicate-name';
+    readonly entryKind: 'option' | 'component' | 'collection';
+    readonly name: string;
+};

package/dist/entities/expectation.d.ts

@@ -0,0 +1,44 @@
+import * as v from 'valibot';
+export declare const BuilderExpectationKindSchema: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
+export type BuilderExpectationKind = v.InferOutput<typeof BuilderExpectationKindSchema>;
+export declare class BuilderExpectation<Name extends string = string, Value = unknown, Kind extends BuilderExpectationKind = BuilderExpectationKind> {
+    readonly type: 'expectation';
+    readonly _value: Value;
+    readonly name: Name;
+    readonly kind: Kind;
+    constructor(name: Name, kind: Kind);
+}
+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" | "detail">[]>]>;
+export type BuilderExpectations = v.InferOutput<typeof BuilderExpectationsSchema>;
+export declare const BuilderExpectationSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
+}, undefined>, v.MetadataAction<{
+    name: string;
+    kind: "option" | "component" | "collection" | "detail";
+}, {
+    readonly serialisable: typeof BuilderExpectation;
+    readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
+}>, v.ReadonlyAction<{
+    name: string;
+    kind: "option" | "component" | "collection" | "detail";
+}>]>;
+export type BuilderExpectationSerialised = v.InferOutput<typeof BuilderExpectationSerialisedSchema>;
+export declare const BuilderExpectationsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
+}, undefined>, v.MetadataAction<{
+    name: string;
+    kind: "option" | "component" | "collection" | "detail";
+}, {
+    readonly serialisable: typeof BuilderExpectation;
+    readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
+}>, v.ReadonlyAction<{
+    name: string;
+    kind: "option" | "component" | "collection" | "detail";
+}>]>, undefined>, v.ReadonlyAction<Readonly<{
+    name: string;
+    kind: "option" | "component" | "collection" | "detail";
+}>[]>]>;
+export type BuilderExpectationsSerialised = v.InferOutput<typeof BuilderExpectationsSerialisedSchema>;

package/dist/entities/expectation.js

@@ -0,0 +1,23 @@
+import * as v from 'valibot';
+import { serialisable } from '../serialisable.js';
+export const BuilderExpectationKindSchema = v.picklist([
+    'option',
+    'component',
+    'collection',
+    'detail'
+]);
+export class BuilderExpectation {
+    name;
+    kind;
+    constructor(name, kind) {
+        this.name = name;
+        this.kind = kind;
+    }
+}
+export const BuilderExpectationSchema = v.instance(BuilderExpectation);
+export const BuilderExpectationsSchema = v.pipe(v.array(BuilderExpectationSchema), v.readonly());
+export const BuilderExpectationSerialisedSchema = serialisable(BuilderExpectation, v.object({
+    name: v.string(),
+    kind: BuilderExpectationKindSchema
+}));
+export const BuilderExpectationsSerialisedSchema = v.pipe(v.array(BuilderExpectationSerialisedSchema), v.readonly());

package/dist/entities/index.d.ts

@@ -0,0 +1,18 @@
+export type { BuilderGeneric, BuilderInstanceOf, BuilderReference, BuilderReferences, BuilderSerialised, BuilderState, BuilderStateAppend, BuilderStateEmpty, BuilderStateOf } from './builder/index';
+export type { BuilderCollectionConfigSerialised, BuilderCollectionPayload, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderErrorInvalidCollectionBounds, CollectionNamesOf, CollectionShape } from './collection/index';
+export type { BuilderComponentDetailsSerialised, BuilderComponentPayload, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised } from './component/index';
+export type { BuilderErrorDuplicateName, BuilderErrorInvalidGatePath, BuilderErrorUnboundParameter, BuilderErrorUnmetExpectation } from './errors';
+export type { BuilderOptionPayload, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionValues, BuilderOptionValuesSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderSelectTypeLabels, BuilderSelectTypeSerialised, BuilderSelectTypeValues, BuilderToggleTypeSerialised, BuilderToggleValueType } from './option/index';
+export type { BuilderDescription, BuilderDescriptionItem, BuilderErrorPagesUnknownCollection, BuilderUIDescribeSerialised, BuilderUIGeneric, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUILabelSerialised, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIReference, BuilderUIReferences, BuilderUISerialised } from './ui/index';
+export type { BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised } from './expectation';
+export type { BuilderWhen, BuilderWhenConfig, WhenSerialised } from './when';
+export type { BuilderCollectionConfigValidated, BuilderCollectionsValidated, BuilderCollectionValidated, BuilderComponentDetailsValidated, BuilderComponentsValidated, BuilderComponentValidated, BuilderOptionsValidated, BuilderOptionValidated, BuilderUIItemsValidated, BuilderUIItemValidated, BuilderUIValidated, BuilderValidated, Strip, StripTuple } from './validate';
+export { Builder, builders, BuilderSchema, BuilderSerialisedSchema, mergeBuilderParts } from './builder/index.js';
+export { BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, collectionConfig, collectionExpectation, collectionWhen } from './collection/index.js';
+export { BuilderComponent, BuilderComponentDetails, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, componentDetails, componentExpectation, componentWhen, detailExpectation } from './component/index.js';
+export { deserialise, serialise } from './serialise.js';
+export { BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema, createWhenFactories, createWhenSerialisedSchema } from './when.js';
+export { BuilderExpectation, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema } from './expectation.js';
+export { parameter } from '../references.js';
+export { BuilderOption, BuilderOptionSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSelectType, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleType, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema, optionExpectation, optionWhen, select, toggleBoolean, toggleNumber, toggleString } from './option/index.js';
+export { BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUILabel, BuilderUILabelSchema, BuilderUILabelSerialisedSchema, BuilderUIPage, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPages, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, mergeUIParts, uis } from './ui/index.js';

package/dist/entities/index.js

@@ -0,0 +1,9 @@
+export { Builder, builders, BuilderSchema, BuilderSerialisedSchema, mergeBuilderParts } from './builder/index.js';
+export { BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, collectionConfig, collectionExpectation, collectionWhen } from './collection/index.js';
+export { BuilderComponent, BuilderComponentDetails, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, componentDetails, componentExpectation, componentWhen, detailExpectation } from './component/index.js';
+export { deserialise, serialise } from './serialise.js';
+export { BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema, createWhenFactories, createWhenSerialisedSchema } from './when.js';
+export { BuilderExpectation, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema } from './expectation.js';
+export { parameter } from '../references.js';
+export { BuilderOption, BuilderOptionSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSelectType, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleType, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema, optionExpectation, optionWhen, select, toggleBoolean, toggleNumber, toggleString } from './option/index.js';
+export { BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUILabel, BuilderUILabelSchema, BuilderUILabelSerialisedSchema, BuilderUIPage, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPages, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, mergeUIParts, uis } from './ui/index.js';

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

@@ -0,0 +1,2 @@
+import { BuilderExpectation } from '../expectation.js';
+export declare function optionExpectation<const Name extends string>(name: Name): BuilderExpectation<Name, string, "option">;

package/dist/entities/option/expectation.js

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

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

@@ -0,0 +1,11 @@
+export type { BuilderOptionPayload, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionWhenSerialised } from './option';
+export type { BuilderSelectTypeLabels, BuilderSelectTypeSerialised, BuilderSelectTypeValues } from './select';
+export type { BuilderToggleTypeSerialised, BuilderToggleValueType } from './toggle';
+export type { BuilderOptionValues, BuilderOptionValuesSerialised } from './values';
+export type { BuilderOptionWhen } from './when';
+export { BuilderOption, BuilderOptionSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema } from './option.js';
+export { BuilderSelectType, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, select } from './select.js';
+export { BuilderToggleType, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema, toggleBoolean, toggleNumber, toggleString } from './toggle.js';
+export { BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema } from './values.js';
+export { optionExpectation } from './expectation.js';
+export { optionWhen } from './when.js';

package/dist/entities/option/index.js

@@ -0,0 +1,6 @@
+export { BuilderOption, BuilderOptionSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema } from './option.js';
+export { BuilderSelectType, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, select } from './select.js';
+export { BuilderToggleType, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema, toggleBoolean, toggleNumber, toggleString } from './toggle.js';
+export { BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema } from './values.js';
+export { optionExpectation } from './expectation.js';
+export { optionWhen } from './when.js';

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

@@ -0,0 +1,347 @@
+import type { BuilderPaths } from '../../paths';
+import type { Refable } from '../../references';
+import type { BuilderWhen, WhenSerialised } from '../when';
+import type { BuilderOptionValues, BuilderOptionValuesSerialised } from './values';
+import * as v from 'valibot';
+export type BuilderOptionPayload = BuilderOptionValues | BuilderWhen<Refable<BuilderOptionValues>>;
+export declare class BuilderOption<const Name extends string = string, const Payload extends Refable<BuilderOptionPayload> = Refable<BuilderOptionPayload>, const GatePaths extends Refable<BuilderPaths> = Refable<BuilderPaths>> {
+    readonly type: 'option';
+    readonly name: Name;
+    readonly payload: Payload;
+    readonly gatePaths?: GatePaths;
+    constructor(name: Name, payload: Payload, gatePaths?: GatePaths);
+}
+export declare const BuilderOptionSchema: v.InstanceSchema<typeof BuilderOption, undefined>;
+export type BuilderOptions = ReadonlyArray<BuilderOption>;
+export declare const BuilderOptionWhenSerialisedSchema: v.GenericSchema;
+export type BuilderOptionWhenSerialised = WhenSerialised<BuilderOptionValuesSerialised>;
+export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly payload: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.UnionSchema<[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>;
+        readonly isOptional: v.BooleanSchema<undefined>;
+        readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+    }, undefined>, v.MetadataAction<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }, {
+        readonly serialisable: typeof import("./select").BuilderSelectType;
+        readonly instance: v.InstanceSchema<typeof import("./select").BuilderSelectType, undefined>;
+    }>, v.ReadonlyAction<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"toggle", undefined>;
+        readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+        readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+        readonly isOptional: v.BooleanSchema<undefined>;
+    }, undefined>, v.MetadataAction<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }, {
+        readonly serialisable: typeof import("./toggle").BuilderToggleType;
+        readonly instance: v.InstanceSchema<typeof import("./toggle").BuilderToggleType, undefined>;
+    }>, v.ReadonlyAction<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }>]>], undefined>, v.ReadonlyAction<Readonly<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }> | Readonly<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }>>]>, v.GenericSchema], undefined>], undefined>, v.MetadataAction<unknown, {
+        readonly refable: v.UnionSchema<[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>;
+            readonly isOptional: v.BooleanSchema<undefined>;
+            readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+        }, undefined>, v.MetadataAction<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+        }, {
+            readonly serialisable: typeof import("./select").BuilderSelectType;
+            readonly instance: v.InstanceSchema<typeof import("./select").BuilderSelectType, undefined>;
+        }>, v.ReadonlyAction<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+        }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"toggle", undefined>;
+            readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+            readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+            readonly isOptional: v.BooleanSchema<undefined>;
+        }, undefined>, v.MetadataAction<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+        }, {
+            readonly serialisable: typeof import("./toggle").BuilderToggleType;
+            readonly instance: v.InstanceSchema<typeof import("./toggle").BuilderToggleType, undefined>;
+        }>, v.ReadonlyAction<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+        }>]>], undefined>, v.ReadonlyAction<Readonly<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+        }> | Readonly<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+        }>>]>, v.GenericSchema], undefined>;
+    }>]>;
+    readonly gatePaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>], undefined>, v.MetadataAction<readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>, {
+        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+    }>]>, undefined>;
+}, undefined>, v.MetadataAction<{
+    name: string;
+    payload: unknown;
+    gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }> | undefined;
+}, {
+    readonly serialisable: typeof BuilderOption;
+    readonly instance: v.InstanceSchema<typeof BuilderOption, undefined>;
+}>, v.ReadonlyAction<{
+    name: string;
+    payload: unknown;
+    gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }> | undefined;
+}>]>;
+export type BuilderOptionSerialised = v.InferOutput<typeof BuilderOptionSerialisedSchema>;
+export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly payload: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.UnionSchema<[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>;
+        readonly isOptional: v.BooleanSchema<undefined>;
+        readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+    }, undefined>, v.MetadataAction<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }, {
+        readonly serialisable: typeof import("./select").BuilderSelectType;
+        readonly instance: v.InstanceSchema<typeof import("./select").BuilderSelectType, undefined>;
+    }>, v.ReadonlyAction<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"toggle", undefined>;
+        readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+        readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+        readonly isOptional: v.BooleanSchema<undefined>;
+    }, undefined>, v.MetadataAction<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }, {
+        readonly serialisable: typeof import("./toggle").BuilderToggleType;
+        readonly instance: v.InstanceSchema<typeof import("./toggle").BuilderToggleType, undefined>;
+    }>, v.ReadonlyAction<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }>]>], undefined>, v.ReadonlyAction<Readonly<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }> | Readonly<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }>>]>, v.GenericSchema], undefined>], undefined>, v.MetadataAction<unknown, {
+        readonly refable: v.UnionSchema<[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>;
+            readonly isOptional: v.BooleanSchema<undefined>;
+            readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+        }, undefined>, v.MetadataAction<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+        }, {
+            readonly serialisable: typeof import("./select").BuilderSelectType;
+            readonly instance: v.InstanceSchema<typeof import("./select").BuilderSelectType, undefined>;
+        }>, v.ReadonlyAction<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+        }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"toggle", undefined>;
+            readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+            readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+            readonly isOptional: v.BooleanSchema<undefined>;
+        }, undefined>, v.MetadataAction<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+        }, {
+            readonly serialisable: typeof import("./toggle").BuilderToggleType;
+            readonly instance: v.InstanceSchema<typeof import("./toggle").BuilderToggleType, undefined>;
+        }>, v.ReadonlyAction<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+        }>]>], undefined>, v.ReadonlyAction<Readonly<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+        }> | Readonly<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+        }>>]>, v.GenericSchema], undefined>;
+    }>]>;
+    readonly gatePaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>], undefined>, v.MetadataAction<readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>, {
+        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+    }>]>, undefined>;
+}, undefined>, v.MetadataAction<{
+    name: string;
+    payload: unknown;
+    gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }> | undefined;
+}, {
+    readonly serialisable: typeof BuilderOption;
+    readonly instance: v.InstanceSchema<typeof BuilderOption, undefined>;
+}>, v.ReadonlyAction<{
+    name: string;
+    payload: unknown;
+    gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }> | undefined;
+}>]>, undefined>, v.ReadonlyAction<Readonly<{
+    name: string;
+    payload: unknown;
+    gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }> | undefined;
+}>[]>]>;
+export type BuilderOptionsSerialised = v.InferOutput<typeof BuilderOptionsSerialisedSchema>;

package/dist/entities/option/option.js

@@ -0,0 +1,24 @@
+import * as v from 'valibot';
+import { BuilderPathsSchema } from '../../paths.js';
+import { refable } from '../../references.js';
+import { serialisable } from '../../serialisable.js';
+import { createWhenSerialisedSchema } from '../when.js';
+import { BuilderOptionValuesSerialisedSchema } from './values.js';
+export class BuilderOption {
+    name;
+    payload;
+    gatePaths;
+    constructor(name, payload, gatePaths) {
+        this.name = name;
+        this.payload = payload;
+        this.gatePaths = gatePaths;
+    }
+}
+export const BuilderOptionSchema = v.instance(BuilderOption);
+export const BuilderOptionWhenSerialisedSchema = createWhenSerialisedSchema(BuilderOptionValuesSerialisedSchema);
+export const BuilderOptionSerialisedSchema = serialisable(BuilderOption, v.object({
+    name: v.string(),
+    payload: refable(v.union([BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema])),
+    gatePaths: v.optional(refable(BuilderPathsSchema))
+}));
+export const BuilderOptionsSerialisedSchema = v.pipe(v.array(BuilderOptionSerialisedSchema), v.readonly());

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

@@ -0,0 +1,49 @@
+import * as v from 'valibot';
+export type BuilderSelectTypeLabels<Values extends BuilderSelectTypeValues> = Partial<Record<Values[number], string>>;
+export type BuilderSelectTypeValues = readonly [string, ...ReadonlyArray<string>];
+export declare class BuilderSelectType<const Values extends BuilderSelectTypeValues = BuilderSelectTypeValues, const ValueSchema extends v.GenericSchema<string | null> = v.GenericSchema<string | null>> {
+    readonly value: v.InferOutput<ValueSchema>;
+    readonly type: "select";
+    readonly options: Values;
+    readonly valueSchema: ValueSchema;
+    readonly defaultValue: v.InferOutput<ValueSchema>;
+    readonly isOptional: boolean;
+    readonly optionLabels: BuilderSelectTypeLabels<Values>;
+    constructor(values: Values, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, optionLabels?: BuilderSelectTypeLabels<Values>);
+    default(newDefault: v.InferOutput<ValueSchema>): BuilderSelectType<Values, ValueSchema>;
+    optional(): BuilderSelectType<Values, v.NullableSchema<ValueSchema, undefined>>;
+    labels(optionLabels: BuilderSelectTypeLabels<Values>): BuilderSelectType<Values, ValueSchema>;
+}
+type SelectSchema<Values extends BuilderSelectTypeValues> = v.UnionSchema<{
+    [K in keyof Values]: v.LiteralSchema<Values[K], undefined>;
+}, undefined>;
+export declare function select<const Values extends BuilderSelectTypeValues>(values: Values): BuilderSelectType<Values, SelectSchema<Values>>;
+export declare const BuilderSelectTypeSchema: v.InstanceSchema<typeof BuilderSelectType, undefined>;
+export declare const BuilderSelectTypeSerialisedSchema: 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>;
+    readonly isOptional: v.BooleanSchema<undefined>;
+    readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+}, undefined>, v.MetadataAction<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+}, {
+    readonly serialisable: typeof BuilderSelectType;
+    readonly instance: v.InstanceSchema<typeof BuilderSelectType, undefined>;
+}>, v.ReadonlyAction<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+}>]>;
+export type BuilderSelectTypeSerialised = v.InferOutput<typeof BuilderSelectTypeSerialisedSchema>;
+export {};