@builder-builder/builder 0.0.7 → 0.0.9

package/dist/entities/collection/config.js

@@ -0,0 +1,23 @@
+import * as v from 'valibot';
+import { refable } from '../../references.js';
+import { serialisable } from '../../serialisable.js';
+import { BuilderSerialisedSchema } from '../builder/index.js';
+export class BuilderCollectionConfig {
+    builder;
+    min;
+    max;
+    constructor(builder, min, max) {
+        this.builder = builder;
+        this.min = min;
+        this.max = max;
+    }
+}
+export const BuilderCollectionConfigSchema = v.instance(BuilderCollectionConfig);
+export const BuilderCollectionConfigSerialisedSchema = serialisable(BuilderCollectionConfig, v.object({
+    builder: refable(v.lazy(() => BuilderSerialisedSchema)),
+    min: refable(v.number()),
+    max: refable(v.number())
+}));
+export function collectionConfig(builder, min, max) {
+    return new BuilderCollectionConfig(builder, min, max);
+}

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

@@ -0,0 +1,7 @@
+import type { BuilderState } from '../builder/index';
+import type { BuilderExpectations } from '../expectation';
+import type { BuilderCollection } from './collection';
+import { BuilderExpectation } from '../expectation.js';
+export declare function collectionExpectation<const Name extends string>(name: Name): BuilderExpectation<Name, unknown, "collection">;
+export type CollectionsExpected<Expectations extends BuilderExpectations> = Expectations extends readonly [infer Head, ...infer Tail extends BuilderExpectations] ? Head extends BuilderExpectation<infer Name, any, 'collection'> ? [BuilderCollection<Name>, ...CollectionsExpected<Tail>] : CollectionsExpected<Tail> : [];
+export type CollectionsAsserted<State extends BuilderState, Expectations extends BuilderExpectations, Current extends State['collections'] = State['collections'], Asserted extends CollectionsExpected<Expectations> = CollectionsExpected<Expectations>> = Current extends [] ? CollectionsExpected<Expectations> : number extends Asserted['length'] ? Asserted : [...Current, ...Asserted];

package/dist/entities/collection/expectation.js

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

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

@@ -0,0 +1,8 @@
+export type { BuilderCollectionPayload, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhenSerialised, BuilderErrorInvalidCollectionBounds, CollectionNamesOf, CollectionShape } from './collection';
+export type { BuilderCollectionConfigSerialised } from './config';
+export type { CollectionsAsserted, CollectionsExpected } from './expectation';
+export type { BuilderCollectionWhen } from './when';
+export { BuilderCollection, BuilderCollectionSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema } from './collection.js';
+export { BuilderCollectionConfig, BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, collectionConfig } from './config.js';
+export { collectionExpectation } from './expectation.js';
+export { collectionWhen } from './when.js';

package/dist/entities/collection/index.js

@@ -0,0 +1,4 @@
+export { BuilderCollection, BuilderCollectionSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema } from './collection.js';
+export { BuilderCollectionConfig, BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, collectionConfig } from './config.js';
+export { collectionExpectation } from './expectation.js';
+export { collectionWhen } from './when.js';

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

@@ -0,0 +1,9 @@
+import type { Refable } from '../../references';
+import type { BuilderWhen } from '../when';
+import type { BuilderCollectionConfig } from './config';
+export type BuilderCollectionWhen = BuilderWhen<Refable<BuilderCollectionConfig>>;
+export declare const collectionWhen: {
+    enable: <const Values extends Refable<BuilderCollectionConfig<Refable<import("..").BuilderGeneric>, Refable<number>, Refable<number>>>>(values: Values) => import("../when").BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends Refable<BuilderCollectionConfig<Refable<import("..").BuilderGeneric>, Refable<number>, Refable<number>>>, const MatchPath extends Refable<import("../..").BuilderPath>, const SelectMap extends Refable<import("../when").BuilderMatchSelectMap<Refable<BuilderCollectionConfig<Refable<import("..").BuilderGeneric>, Refable<number>, Refable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("../when").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends Refable<BuilderCollectionConfig<Refable<import("..").BuilderGeneric>, Refable<number>, Refable<number>>>, const UnlessPath extends Refable<import("../..").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("../..").BuilderPrimitives, values: Values) => import("../when").BuilderUnlessConfig<Values, UnlessPath>;
+};

package/dist/entities/collection/when.js

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

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

@@ -0,0 +1,403 @@
+import type { BuilderPaths } from '../../paths';
+import type { Refable } from '../../references';
+import type { BuilderWhen, WhenSerialised } from '../when';
+import type { BuilderComponentDetails, BuilderComponentDetailsSerialised } from './details';
+import * as v from 'valibot';
+export type BuilderComponentPayload = BuilderComponentDetails | BuilderWhen<Refable<BuilderComponentDetails>>;
+export declare class BuilderComponent<const Name extends string = string, const Payload extends Refable<BuilderComponentPayload> = Refable<BuilderComponentPayload>, const GatePaths extends Refable<BuilderPaths> = Refable<BuilderPaths>> {
+    readonly type: 'component';
+    readonly name: Name;
+    readonly payload: Payload;
+    readonly gatePaths?: GatePaths;
+    constructor(name: Name, payload: Payload, gatePaths?: GatePaths);
+}
+export declare const BuilderComponentSchema: v.InstanceSchema<typeof BuilderComponent, undefined>;
+export type BuilderComponents = ReadonlyArray<BuilderComponent>;
+export declare const BuilderComponentWhenSerialisedSchema: v.GenericSchema;
+export type BuilderComponentWhenSerialised = WhenSerialised<BuilderComponentDetailsSerialised>;
+export declare const BuilderComponentSerialisedSchema: 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.ObjectSchema<{
+        readonly expectations: 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.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 import("..").BuilderExpectation;
+            readonly instance: v.InstanceSchema<typeof import("..").BuilderExpectation, undefined>;
+        }>, v.ReadonlyAction<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>]>, undefined>, v.ReadonlyAction<Readonly<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>[]>]>], undefined>, v.MetadataAction<import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | readonly Readonly<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>[], {
+            readonly refable: 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 import("..").BuilderExpectation;
+                readonly instance: v.InstanceSchema<typeof import("..").BuilderExpectation, undefined>;
+            }>, v.ReadonlyAction<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>]>, undefined>, v.ReadonlyAction<Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[]>]>;
+        }>]>;
+    }, undefined>, v.MetadataAction<{
+        expectations: import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | readonly Readonly<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>[];
+    }, {
+        readonly serialisable: typeof BuilderComponentDetails;
+        readonly instance: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
+    }>, v.ReadonlyAction<{
+        expectations: import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | readonly Readonly<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>[];
+    }>]>, v.GenericSchema], undefined>], undefined>, v.MetadataAction<unknown, {
+        readonly refable: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly expectations: 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.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 import("..").BuilderExpectation;
+                readonly instance: v.InstanceSchema<typeof import("..").BuilderExpectation, undefined>;
+            }>, v.ReadonlyAction<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>]>, undefined>, v.ReadonlyAction<Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[]>]>], undefined>, v.MetadataAction<import("../..").BuilderRef | Readonly<{
+                type: "ref";
+                id: string;
+                name: string;
+            }> | readonly Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[], {
+                readonly refable: 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 import("..").BuilderExpectation;
+                    readonly instance: v.InstanceSchema<typeof import("..").BuilderExpectation, undefined>;
+                }>, v.ReadonlyAction<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }>]>, undefined>, v.ReadonlyAction<Readonly<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }>[]>]>;
+            }>]>;
+        }, undefined>, v.MetadataAction<{
+            expectations: import("../..").BuilderRef | Readonly<{
+                type: "ref";
+                id: string;
+                name: string;
+            }> | readonly Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[];
+        }, {
+            readonly serialisable: typeof BuilderComponentDetails;
+            readonly instance: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
+        }>, v.ReadonlyAction<{
+            expectations: import("../..").BuilderRef | Readonly<{
+                type: "ref";
+                id: string;
+                name: string;
+            }> | readonly Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[];
+        }>]>, 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 BuilderComponent;
+    readonly instance: v.InstanceSchema<typeof BuilderComponent, undefined>;
+}>, v.ReadonlyAction<{
+    name: string;
+    payload: unknown;
+    gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }> | undefined;
+}>]>;
+export type BuilderComponentSerialised = v.InferOutput<typeof BuilderComponentSerialisedSchema>;
+export declare const BuilderComponentsSerialisedSchema: 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.ObjectSchema<{
+        readonly expectations: 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.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 import("..").BuilderExpectation;
+            readonly instance: v.InstanceSchema<typeof import("..").BuilderExpectation, undefined>;
+        }>, v.ReadonlyAction<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>]>, undefined>, v.ReadonlyAction<Readonly<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>[]>]>], undefined>, v.MetadataAction<import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | readonly Readonly<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>[], {
+            readonly refable: 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 import("..").BuilderExpectation;
+                readonly instance: v.InstanceSchema<typeof import("..").BuilderExpectation, undefined>;
+            }>, v.ReadonlyAction<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>]>, undefined>, v.ReadonlyAction<Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[]>]>;
+        }>]>;
+    }, undefined>, v.MetadataAction<{
+        expectations: import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | readonly Readonly<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>[];
+    }, {
+        readonly serialisable: typeof BuilderComponentDetails;
+        readonly instance: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
+    }>, v.ReadonlyAction<{
+        expectations: import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | readonly Readonly<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>[];
+    }>]>, v.GenericSchema], undefined>], undefined>, v.MetadataAction<unknown, {
+        readonly refable: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly expectations: 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.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 import("..").BuilderExpectation;
+                readonly instance: v.InstanceSchema<typeof import("..").BuilderExpectation, undefined>;
+            }>, v.ReadonlyAction<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>]>, undefined>, v.ReadonlyAction<Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[]>]>], undefined>, v.MetadataAction<import("../..").BuilderRef | Readonly<{
+                type: "ref";
+                id: string;
+                name: string;
+            }> | readonly Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[], {
+                readonly refable: 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 import("..").BuilderExpectation;
+                    readonly instance: v.InstanceSchema<typeof import("..").BuilderExpectation, undefined>;
+                }>, v.ReadonlyAction<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }>]>, undefined>, v.ReadonlyAction<Readonly<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }>[]>]>;
+            }>]>;
+        }, undefined>, v.MetadataAction<{
+            expectations: import("../..").BuilderRef | Readonly<{
+                type: "ref";
+                id: string;
+                name: string;
+            }> | readonly Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[];
+        }, {
+            readonly serialisable: typeof BuilderComponentDetails;
+            readonly instance: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
+        }>, v.ReadonlyAction<{
+            expectations: import("../..").BuilderRef | Readonly<{
+                type: "ref";
+                id: string;
+                name: string;
+            }> | readonly Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[];
+        }>]>, 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 BuilderComponent;
+    readonly instance: v.InstanceSchema<typeof BuilderComponent, 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 BuilderComponentsSerialised = v.InferOutput<typeof BuilderComponentsSerialisedSchema>;

package/dist/entities/component/component.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 { BuilderComponentDetailsSerialisedSchema } from './details.js';
+export class BuilderComponent {
+    name;
+    payload;
+    gatePaths;
+    constructor(name, payload, gatePaths) {
+        this.name = name;
+        this.payload = payload;
+        this.gatePaths = gatePaths;
+    }
+}
+export const BuilderComponentSchema = v.instance(BuilderComponent);
+export const BuilderComponentWhenSerialisedSchema = createWhenSerialisedSchema(BuilderComponentDetailsSerialisedSchema);
+export const BuilderComponentSerialisedSchema = serialisable(BuilderComponent, v.object({
+    name: v.string(),
+    payload: refable(v.union([BuilderComponentDetailsSerialisedSchema, BuilderComponentWhenSerialisedSchema])),
+    gatePaths: v.optional(refable(BuilderPathsSchema))
+}));
+export const BuilderComponentsSerialisedSchema = v.pipe(v.array(BuilderComponentSerialisedSchema), v.readonly());

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

@@ -0,0 +1,82 @@
+import type { Refable } from '../../references';
+import type { BuilderExpectations } from '../expectation';
+import * as v from 'valibot';
+export declare class BuilderComponentDetails<Expectations extends Refable<BuilderExpectations> = Refable<BuilderExpectations>> {
+    readonly type: 'component-details';
+    expectations: Expectations;
+    constructor(expectations: Expectations);
+}
+export declare const BuilderComponentDetailsSchema: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
+export declare const BuilderComponentDetailsSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly expectations: 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.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 import("..").BuilderExpectation;
+        readonly instance: v.InstanceSchema<typeof import("..").BuilderExpectation, undefined>;
+    }>, v.ReadonlyAction<{
+        name: string;
+        kind: "option" | "component" | "collection" | "detail";
+    }>]>, undefined>, v.ReadonlyAction<Readonly<{
+        name: string;
+        kind: "option" | "component" | "collection" | "detail";
+    }>[]>]>], undefined>, v.MetadataAction<import("../..").BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }> | readonly Readonly<{
+        name: string;
+        kind: "option" | "component" | "collection" | "detail";
+    }>[], {
+        readonly refable: 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 import("..").BuilderExpectation;
+            readonly instance: v.InstanceSchema<typeof import("..").BuilderExpectation, undefined>;
+        }>, v.ReadonlyAction<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>]>, undefined>, v.ReadonlyAction<Readonly<{
+            name: string;
+            kind: "option" | "component" | "collection" | "detail";
+        }>[]>]>;
+    }>]>;
+}, undefined>, v.MetadataAction<{
+    expectations: import("../..").BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }> | readonly Readonly<{
+        name: string;
+        kind: "option" | "component" | "collection" | "detail";
+    }>[];
+}, {
+    readonly serialisable: typeof BuilderComponentDetails;
+    readonly instance: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
+}>, v.ReadonlyAction<{
+    expectations: import("../..").BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }> | readonly Readonly<{
+        name: string;
+        kind: "option" | "component" | "collection" | "detail";
+    }>[];
+}>]>;
+export type BuilderComponentDetailsSerialised = v.InferOutput<typeof BuilderComponentDetailsSerialisedSchema>;
+export declare function componentDetails<const Expectations extends Refable<BuilderExpectations> = Refable<BuilderExpectations>>(expectations?: Expectations): BuilderComponentDetails;

package/dist/entities/component/details.js

@@ -0,0 +1,17 @@
+import * as v from 'valibot';
+import { BuilderExpectationsSerialisedSchema } from '../expectation.js';
+import { refable } from '../../references.js';
+import { serialisable } from '../../serialisable.js';
+export class BuilderComponentDetails {
+    expectations;
+    constructor(expectations) {
+        this.expectations = expectations;
+    }
+}
+export const BuilderComponentDetailsSchema = v.instance(BuilderComponentDetails);
+export const BuilderComponentDetailsSerialisedSchema = serialisable(BuilderComponentDetails, v.object({
+    expectations: refable(BuilderExpectationsSerialisedSchema)
+}));
+export function componentDetails(expectations) {
+    return new BuilderComponentDetails((expectations ?? []));
+}

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

@@ -0,0 +1,8 @@
+import type { BuilderState } from '../builder/index';
+import type { BuilderExpectations } from '../expectation';
+import type { BuilderComponent } from './component';
+import { BuilderExpectation } from '../expectation.js';
+export declare function componentExpectation<const Name extends string>(name: Name): BuilderExpectation<Name, never, "component">;
+export declare function detailExpectation<const Name extends string>(name: Name): BuilderExpectation<Name, string, "detail">;
+export type ComponentsExpected<Expectations extends BuilderExpectations> = Expectations extends readonly [infer Head, ...infer Tail extends BuilderExpectations] ? Head extends BuilderExpectation<infer Name, any, 'component'> ? [BuilderComponent<Name>, ...ComponentsExpected<Tail>] : ComponentsExpected<Tail> : [];
+export type ComponentAsserted<State extends BuilderState, Expectations extends BuilderExpectations, Current extends State['components'] = State['components'], Asserted extends ComponentsExpected<Expectations> = ComponentsExpected<Expectations>> = Current extends [] ? ComponentsExpected<Expectations> : number extends Asserted['length'] ? Asserted : [...Current, ...Asserted];

package/dist/entities/component/expectation.js

@@ -0,0 +1,7 @@
+import { BuilderExpectation } from '../expectation.js';
+export function componentExpectation(name) {
+    return new BuilderExpectation(name, 'component');
+}
+export function detailExpectation(name) {
+    return new BuilderExpectation(name, 'detail');
+}

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

@@ -0,0 +1,8 @@
+export type { BuilderComponentPayload, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhenSerialised } from './component';
+export type { BuilderComponentDetailsSerialised } from './details';
+export type { ComponentAsserted, ComponentsExpected } from './expectation';
+export type { BuilderComponentWhen } from './when';
+export { BuilderComponent, BuilderComponentSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema } from './component.js';
+export { BuilderComponentDetails, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, componentDetails } from './details.js';
+export { componentExpectation, detailExpectation } from './expectation.js';
+export { componentWhen } from './when.js';

package/dist/entities/component/index.js

@@ -0,0 +1,4 @@
+export { BuilderComponent, BuilderComponentSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema } from './component.js';
+export { BuilderComponentDetails, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, componentDetails } from './details.js';
+export { componentExpectation, detailExpectation } from './expectation.js';
+export { componentWhen } from './when.js';