@builder-builder/builder 0.0.14 → 0.0.16

package/dist/entities/serialise.js

@@ -1,61 +1,64 @@
 import * as v from 'valibot';
+import { check } from '../check.js';
 import { BuilderPathSchema, BuilderPathsSchema } from '../paths.js';
 import { BuilderParameterSchema, BuilderRefSchema, isParamable } from '../references.js';
-import { check } from '../check.js';
+import { BuilderSchema, BuilderSerialisedSchema } from './builder/index.js';
 import { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionWhenSerialisedSchema } from './collection/index.js';
 import { BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentWhenSerialisedSchema } from './component/index.js';
 import { BuilderExpectationSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema } from './expectation.js';
 import { BuilderModelSchema, BuilderModelSerialisedSchema } from './model/index.js';
 import { BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema } from './option/index.js';
+import { BuilderPricingSchema, BuilderPricingSerialisedSchema, BuilderRatesSchema } from './pricing/index.js';
 import { BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIInputSchema, BuilderUIInputSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema } from './ui/index.js';
-import { BuilderSchema, BuilderSerialisedSchema } from './builder/index.js';
 export const entitiesMap = {
     builder: { runtime: BuilderSchema, serialised: BuilderSerialisedSchema },
     model: { runtime: BuilderModelSchema, serialised: BuilderModelSerialisedSchema },
-    ui: { runtime: BuilderUISchema, serialised: BuilderUISerialisedSchema },
     select: { runtime: BuilderSelectTypeSchema, serialised: BuilderSelectTypeSerialisedSchema },
     toggle: { runtime: BuilderToggleTypeSchema, serialised: BuilderToggleTypeSerialisedSchema },
-    uiPage: { runtime: BuilderUIPageSchema, serialised: BuilderUIPageSerialisedSchema },
-    uiDescribe: { runtime: BuilderUIDescribeSchema, serialised: BuilderUIDescribeSerialisedSchema },
-    uiPages: { runtime: BuilderUIPagesSchema, serialised: BuilderUIPagesSerialisedSchema },
-    uiInput: { runtime: BuilderUIInputSchema, serialised: BuilderUIInputSerialisedSchema },
-    componentDetails: {
-        runtime: BuilderComponentDetailsSchema,
-        serialised: BuilderComponentDetailsSerialisedSchema
-    },
-    collectionConfig: {
-        runtime: BuilderCollectionConfigSchema,
-        serialised: BuilderCollectionConfigSerialisedSchema
-    },
-    expectations: {
-        runtime: BuilderExpectationsSchema,
-        serialised: BuilderExpectationsSerialisedSchema
+    optionSelectMap: {
+        runtime: BuilderOptionSelectMapSerialisedSchema,
+        serialised: BuilderOptionSelectMapSerialisedSchema
     },
-    uiItems: { runtime: BuilderUIItemsSerialisedSchema, serialised: BuilderUIItemsSerialisedSchema },
     optionWhen: {
         runtime: BuilderOptionWhenSerialisedSchema,
         serialised: BuilderOptionWhenSerialisedSchema
     },
-    componentWhen: {
-        runtime: BuilderComponentWhenSerialisedSchema,
-        serialised: BuilderComponentWhenSerialisedSchema
-    },
-    collectionWhen: {
-        runtime: BuilderCollectionWhenSerialisedSchema,
-        serialised: BuilderCollectionWhenSerialisedSchema
-    },
-    optionSelectMap: {
-        runtime: BuilderOptionSelectMapSerialisedSchema,
-        serialised: BuilderOptionSelectMapSerialisedSchema
+    componentDetails: {
+        runtime: BuilderComponentDetailsSchema,
+        serialised: BuilderComponentDetailsSerialisedSchema
     },
     componentSelectMap: {
         runtime: BuilderComponentSelectMapSerialisedSchema,
         serialised: BuilderComponentSelectMapSerialisedSchema
     },
+    componentWhen: {
+        runtime: BuilderComponentWhenSerialisedSchema,
+        serialised: BuilderComponentWhenSerialisedSchema
+    },
+    collectionConfig: {
+        runtime: BuilderCollectionConfigSchema,
+        serialised: BuilderCollectionConfigSerialisedSchema
+    },
     collectionSelectMap: {
         runtime: BuilderCollectionSelectMapSerialisedSchema,
         serialised: BuilderCollectionSelectMapSerialisedSchema
     },
+    collectionWhen: {
+        runtime: BuilderCollectionWhenSerialisedSchema,
+        serialised: BuilderCollectionWhenSerialisedSchema
+    },
+    ui: { runtime: BuilderUISchema, serialised: BuilderUISerialisedSchema },
+    uiDescribe: { runtime: BuilderUIDescribeSchema, serialised: BuilderUIDescribeSerialisedSchema },
+    uiItems: { runtime: BuilderUIItemsSerialisedSchema, serialised: BuilderUIItemsSerialisedSchema },
+    uiPage: { runtime: BuilderUIPageSchema, serialised: BuilderUIPageSerialisedSchema },
+    uiPages: { runtime: BuilderUIPagesSchema, serialised: BuilderUIPagesSerialisedSchema },
+    uiInput: { runtime: BuilderUIInputSchema, serialised: BuilderUIInputSerialisedSchema },
+    pricing: { runtime: BuilderPricingSchema, serialised: BuilderPricingSerialisedSchema },
+    pricingRates: { runtime: BuilderRatesSchema, serialised: BuilderRatesSchema },
+    expectations: {
+        runtime: BuilderExpectationsSchema,
+        serialised: BuilderExpectationsSerialisedSchema
+    },
     paths: { runtime: BuilderPathsSchema, serialised: BuilderPathsSchema },
     path: { runtime: BuilderPathSchema, serialised: BuilderPathSchema },
     number: { runtime: v.number(), serialised: v.number() },
@@ -93,64 +96,82 @@ const serialiserMap = [
     serialiser(BuilderSchema, (value) => ({
         model: serialiseValue(value.model),
         ui: serialiseValue(value.ui),
-        bindings: serialiseRecord(value.bindings)
+        bindings: serialiseRecord(value.bindings),
+        tags: value.tags,
+        pricing: value.pricing == null ? value.pricing : serialiseValue(value.pricing)
     })),
     serialiser(BuilderModelSchema, (value) => ({
         models: value.models.map(serialiseValue),
         options: value.options.map(serialiseValue),
         components: value.components.map(serialiseValue),
         collections: value.collections.map(serialiseValue),
-        expectations: value.expectations.map(serialiseValue)
+        expectations: value.expectations.map(serialiseValue),
+        tags: value.tags
     })),
     serialiser(BuilderUISchema, (value) => ({
         uis: value.uis.map(serialiseValue),
         items: value.items.map(serialiseValue),
-        expectations: value.expectations.map(serialiseValue)
+        expectations: value.expectations.map(serialiseValue),
+        tags: value.tags
     })),
     serialiser(BuilderUIPageSchema, (value) => ({
         type: 'page',
         label: serialiseValue(value.label),
-        inputs: serialiseValue(value.inputs)
+        inputs: serialiseValue(value.inputs),
+        tags: value.tags
     })),
     serialiser(BuilderUIDescribeSchema, (value) => ({
         type: 'describe',
         label: serialiseValue(value.label),
-        inputs: serialiseValue(value.inputs)
+        inputs: serialiseValue(value.inputs),
+        tags: value.tags
     })),
     serialiser(BuilderUIPagesSchema, (value) => ({
         type: 'pages',
         name: value.name,
         label: serialiseValue(value.label),
-        items: serialiseValue(value.items)
+        items: serialiseValue(value.items),
+        tags: value.tags
+    })),
+    serialiser(BuilderPricingSchema, (value) => ({
+        rates: value.rates.map(serialiseValue),
+        formula: serialiseValue(value.formula)
     })),
     serialiser(BuilderUIInputSchema, (value) => serialiseRecord({ ...value })),
     serialiser(BuilderOptionSchema, serialiseNamedEntry),
     serialiser(BuilderComponentSchema, serialiseNamedEntry),
     serialiser(BuilderCollectionSchema, serialiseNamedEntry),
-    serialiser(BuilderComponentDetailsSchema, (value) => ({ fields: serialiseValue(value.fields) })),
+    serialiser(BuilderComponentDetailsSchema, (value) => ({
+        fields: serialiseValue(value.fields),
+        tags: value.tags
+    })),
     serialiser(BuilderComponentFieldSchema, (value) => ({
         type: 'component-field',
         name: value.name,
         valueType: value.valueType,
-        isOptional: value.isOptional
+        isOptional: value.isOptional,
+        tags: value.tags
     })),
     serialiser(BuilderCollectionConfigSchema, (value) => ({
         model: serialiseValue(value.model),
         min: serialiseValue(value.min),
-        max: serialiseValue(value.max)
+        max: serialiseValue(value.max),
+        tags: value.tags
     })),
     serialiser(BuilderSelectTypeSchema, (value) => ({
         type: 'select',
         options: value.options,
         defaultValue: value.defaultValue,
         isOptional: value.isOptional,
-        optionLabels: value.optionLabels
+        optionLabels: value.optionLabels,
+        tags: value.tags
     })),
     serialiser(BuilderToggleTypeSchema, (value) => ({
         type: 'toggle',
         valueType: value.valueType,
         defaultValue: value.defaultValue,
-        isOptional: value.isOptional
+        isOptional: value.isOptional,
+        tags: value.tags
     })),
     serialiser(BuilderExpectationSchema, (value) => ({ name: value.name, kind: value.kind }))
 ];
@@ -162,6 +183,9 @@ function serialiseNamedEntry(value) {
     if (value.paths != null) {
         entry.paths = serialiseValue(value.paths);
     }
+    if (value.tags != null) {
+        entry.tags = serialiseValue(value.tags);
+    }
     return entry;
 }
 function serialiseRecord(record) {

package/dist/entities/tags.d.ts

@@ -0,0 +1,3 @@
+import * as v from 'valibot';
+export declare const BuilderTagsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>;
+export type BuilderTags = v.InferOutput<typeof BuilderTagsSchema>;

package/dist/entities/tags.js

@@ -0,0 +1,2 @@
+import * as v from 'valibot';
+export const BuilderTagsSchema = v.pipe(v.array(v.string()), v.readonly());

package/dist/entities/ui/describe.d.ts

@@ -1,4 +1,5 @@
 import type { Paramable } from '../../references';
+import type { BuilderTags } from '../tags';
 import type { BuilderUIInputs } from './input';
 import * as v from 'valibot';
 export declare const BuilderDescriptionItemSchema: v.SchemaWithPipe<readonly [v.TupleSchema<[v.StringSchema<undefined>, v.StringSchema<undefined>], undefined>, v.ReadonlyAction<[string, string]>]>;
@@ -9,7 +10,9 @@ export declare class BuilderUIDescribe<const Label extends Paramable<string> = P
     readonly type: "describe";
     readonly label: Label;
     readonly inputs: Inputs;
-    constructor(label: Label, inputs: Inputs);
+    readonly tags?: BuilderTags;
+    constructor(label: Label, inputs: Inputs, tags?: BuilderTags);
+    tag(...tags: Array<string>): BuilderUIDescribe<Label, Inputs>;
 }
 export declare const BuilderUIDescribeSchema: v.InstanceSchema<typeof BuilderUIDescribe, undefined>;
 export declare const BuilderUIDescribeSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
@@ -135,6 +138,7 @@ export declare const BuilderUIDescribeSerialisedSchema: v.SchemaWithPipe<readonl
         }>]>, v.UnknownSchema], undefined>, undefined>, v.ReadonlyAction<{
             [x: string]: unknown;
         }>]>], undefined>, undefined>;
+        readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
     }, undefined>, v.ReadonlyAction<{
         type: "input";
         path: readonly (string | number)[] | Readonly<{
@@ -171,6 +175,7 @@ export declare const BuilderUIDescribeSerialisedSchema: v.SchemaWithPipe<readonl
         }> | Readonly<{
             [x: string]: unknown;
         }> | undefined;
+        tags?: readonly string[] | undefined;
     }>]>], undefined>, undefined>, v.ReadonlyAction<(Readonly<{
         type: "parameter";
         id: string;
@@ -214,7 +219,9 @@ export declare const BuilderUIDescribeSerialisedSchema: v.SchemaWithPipe<readonl
         }> | Readonly<{
             [x: string]: unknown;
         }> | undefined;
+        tags?: readonly string[] | undefined;
     }>)[]>]>], undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "describe";
     label: string | Readonly<{
@@ -275,6 +282,8 @@ export declare const BuilderUIDescribeSerialisedSchema: v.SchemaWithPipe<readonl
         }> | Readonly<{
             [x: string]: unknown;
         }> | undefined;
+        tags?: readonly string[] | undefined;
     }>)[];
+    tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderUIDescribeSerialised = v.InferOutput<typeof BuilderUIDescribeSerialisedSchema>;

package/dist/entities/ui/describe.js

@@ -1,6 +1,7 @@
 import * as v from 'valibot';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 import { BuilderUIInputsSerialisedSchema } from './input.js';
 export const BuilderDescriptionItemSchema = v.pipe(v.tuple([v.string(), v.string()]), v.readonly());
 export const BuilderDescriptionSchema = v.pipe(v.array(BuilderDescriptionItemSchema), v.readonly());
@@ -8,14 +9,20 @@ export class BuilderUIDescribe {
     type = 'describe';
     label;
     inputs;
-    constructor(label, inputs) {
+    tags;
+    constructor(label, inputs, tags) {
         this.label = label;
         this.inputs = inputs;
+        this.tags = tags;
+    }
+    tag(...tags) {
+        return new BuilderUIDescribe(this.label, this.inputs, tags);
     }
 }
 export const BuilderUIDescribeSchema = v.instance(BuilderUIDescribe);
 export const BuilderUIDescribeSerialisedSchema = serialisable(v.object({
     type: v.literal('describe'),
     label: paramable(v.string()),
-    inputs: paramable(BuilderUIInputsSerialisedSchema)
+    inputs: paramable(BuilderUIInputsSerialisedSchema),
+    tags: v.optional(BuilderTagsSchema)
 }));

package/dist/entities/ui/input.d.ts

@@ -2,20 +2,24 @@ import type { BuilderPath } from '../../paths';
 import type { Paramable, ParamableSerialised } from '../../references';
 import type { BuilderModelGeneric, BuilderModelStateOf } from '../model/model';
 import type { BuilderModelState } from '../model/state';
+import type { BuilderTags } from '../tags';
 import type { BuilderValidPath } from '../when';
 import * as v from 'valibot';
 export type BuilderUIInputMetadata = Paramable<Record<string, Paramable<unknown>>>;
 export type BuilderUIInputMetadataSerialised = ParamableSerialised<Record<string, ParamableSerialised<unknown>>>;
 export declare class BuilderUIInput<const Path extends Paramable<BuilderPath> = Paramable<BuilderPath>, const DisplayName extends Paramable<string> = Paramable<string>, const Kind extends Paramable<string> = Paramable<string>, const Metadata extends BuilderUIInputMetadata = BuilderUIInputMetadata> {
+    #private;
     readonly type: "input";
     readonly path: Path;
     readonly displayName?: DisplayName;
     readonly kind?: Kind;
     readonly metadata?: Metadata;
-    constructor(path: Path, displayName?: DisplayName, kind?: Kind, metadata?: Metadata);
+    readonly tags?: BuilderTags;
+    constructor(path: Path, displayName?: DisplayName, kind?: Kind, metadata?: Metadata, tags?: BuilderTags);
     display<const NewDisplayName extends Paramable<string>>(displayName: NewDisplayName): BuilderUIInput<Path, NewDisplayName, Kind, Metadata>;
     as<const NewKind extends Paramable<string>>(kind: NewKind): BuilderUIInput<Path, DisplayName, NewKind, Metadata>;
     meta<const NewMetadata extends BuilderUIInputMetadata>(metadata: NewMetadata): BuilderUIInput<Path, DisplayName, Kind, NewMetadata>;
+    tag(...tags: Array<string>): BuilderUIInput<Path, DisplayName, Kind, Metadata>;
 }
 export declare function input<const Path extends Paramable<BuilderPath>>(path: Path): BuilderUIInput<Path>;
 export declare const BuilderUIInputSchema: v.InstanceSchema<typeof BuilderUIInput, undefined>;
@@ -114,6 +118,7 @@ export declare const BuilderUIInputSerialisedSchema: v.SchemaWithPipe<readonly [
     }>]>, v.UnknownSchema], undefined>, undefined>, v.ReadonlyAction<{
         [x: string]: unknown;
     }>]>], undefined>, undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "input";
     path: readonly (string | number)[] | Readonly<{
@@ -150,6 +155,7 @@ export declare const BuilderUIInputSerialisedSchema: v.SchemaWithPipe<readonly [
     }> | Readonly<{
         [x: string]: unknown;
     }> | undefined;
+    tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderUIInputSerialised = v.InferOutput<typeof BuilderUIInputSerialisedSchema>;
 export declare const BuilderUIInputsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
@@ -244,6 +250,7 @@ export declare const BuilderUIInputsSerialisedSchema: v.SchemaWithPipe<readonly
     }>]>, v.UnknownSchema], undefined>, undefined>, v.ReadonlyAction<{
         [x: string]: unknown;
     }>]>], undefined>, undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "input";
     path: readonly (string | number)[] | Readonly<{
@@ -280,6 +287,7 @@ export declare const BuilderUIInputsSerialisedSchema: v.SchemaWithPipe<readonly
     }> | Readonly<{
         [x: string]: unknown;
     }> | undefined;
+    tags?: readonly string[] | undefined;
 }>]>], undefined>, undefined>, v.ReadonlyAction<(Readonly<{
     type: "parameter";
     id: string;
@@ -323,6 +331,7 @@ export declare const BuilderUIInputsSerialisedSchema: v.SchemaWithPipe<readonly
     }> | Readonly<{
         [x: string]: unknown;
     }> | undefined;
+    tags?: readonly string[] | undefined;
 }>)[]>]>;
 export type BuilderUIInputsSerialised = v.InferOutput<typeof BuilderUIInputsSerialisedSchema>;
 export type BuilderUIInputs = ReadonlyArray<Paramable<BuilderUIInput>>;

package/dist/entities/ui/input.js

@@ -2,26 +2,37 @@ import * as v from 'valibot';
 import { BuilderPathSchema } from '../../paths.js';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 export class BuilderUIInput {
     type = 'input';
     path;
     displayName;
     kind;
     metadata;
-    constructor(path, displayName, kind, metadata) {
+    tags;
+    constructor(path, displayName, kind, metadata, tags) {
         this.path = path;
         this.displayName = displayName;
         this.kind = kind;
         this.metadata = metadata;
+        this.tags = tags;
+    }
+    #next(patch) {
+        return new BuilderUIInput(this.path, patch.displayName ?? this.displayName, patch.kind ?? this.kind, patch.metadata ?? this.metadata, patch.tags ?? this.tags);
     }
     display(displayName) {
-        return new BuilderUIInput(this.path, displayName, this.kind, this.metadata);
+        return this.#next({
+            displayName: displayName
+        });
     }
     as(kind) {
-        return new BuilderUIInput(this.path, this.displayName, kind, this.metadata);
+        return this.#next({ kind: kind });
     }
     meta(metadata) {
-        return new BuilderUIInput(this.path, this.displayName, this.kind, metadata);
+        return this.#next({ metadata: metadata });
+    }
+    tag(...tags) {
+        return this.#next({ tags });
     }
 }
 export function input(path) {
@@ -34,6 +45,7 @@ export const BuilderUIInputSerialisedSchema = serialisable(v.object({
     path: paramable(BuilderPathSchema),
     displayName: v.optional(paramable(v.string())),
     kind: v.optional(paramable(v.string())),
-    metadata: v.optional(paramable(BuilderUIInputMetadataSchema))
+    metadata: v.optional(paramable(BuilderUIInputMetadataSchema)),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export const BuilderUIInputsSerialisedSchema = v.pipe(v.array(paramable(BuilderUIInputSerialisedSchema)), v.readonly());

package/dist/entities/ui/page.d.ts

@@ -1,11 +1,14 @@
 import type { Paramable } from '../../references';
+import type { BuilderTags } from '../tags';
 import type { BuilderUIInputs } from './input';
 import * as v from 'valibot';
 export declare class BuilderUIPage<const Label extends Paramable<string> = Paramable<string>, const Inputs extends Paramable<BuilderUIInputs> = Paramable<BuilderUIInputs>> {
     readonly type: "page";
     readonly label: Label;
     readonly inputs: Inputs;
-    constructor(label: Label, inputs: Inputs);
+    readonly tags?: BuilderTags;
+    constructor(label: Label, inputs: Inputs, tags?: BuilderTags);
+    tag(...tags: Array<string>): BuilderUIPage<Label, Inputs>;
 }
 export declare const BuilderUIPageSchema: v.InstanceSchema<typeof BuilderUIPage, undefined>;
 export declare const BuilderUIPageSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
@@ -131,6 +134,7 @@ export declare const BuilderUIPageSerialisedSchema: v.SchemaWithPipe<readonly [v
         }>]>, v.UnknownSchema], undefined>, undefined>, v.ReadonlyAction<{
             [x: string]: unknown;
         }>]>], undefined>, undefined>;
+        readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
     }, undefined>, v.ReadonlyAction<{
         type: "input";
         path: readonly (string | number)[] | Readonly<{
@@ -167,6 +171,7 @@ export declare const BuilderUIPageSerialisedSchema: v.SchemaWithPipe<readonly [v
         }> | Readonly<{
             [x: string]: unknown;
         }> | undefined;
+        tags?: readonly string[] | undefined;
     }>]>], undefined>, undefined>, v.ReadonlyAction<(Readonly<{
         type: "parameter";
         id: string;
@@ -210,7 +215,9 @@ export declare const BuilderUIPageSerialisedSchema: v.SchemaWithPipe<readonly [v
         }> | Readonly<{
             [x: string]: unknown;
         }> | undefined;
+        tags?: readonly string[] | undefined;
     }>)[]>]>], undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "page";
     label: string | Readonly<{
@@ -271,6 +278,8 @@ export declare const BuilderUIPageSerialisedSchema: v.SchemaWithPipe<readonly [v
         }> | Readonly<{
             [x: string]: unknown;
         }> | undefined;
+        tags?: readonly string[] | undefined;
     }>)[];
+    tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderUIPageSerialised = v.InferOutput<typeof BuilderUIPageSerialisedSchema>;

package/dist/entities/ui/page.js

@@ -1,19 +1,26 @@
 import * as v from 'valibot';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 import { BuilderUIInputsSerialisedSchema } from './input.js';
 export class BuilderUIPage {
     type = 'page';
     label;
     inputs;
-    constructor(label, inputs) {
+    tags;
+    constructor(label, inputs, tags) {
         this.label = label;
         this.inputs = inputs;
+        this.tags = tags;
+    }
+    tag(...tags) {
+        return new BuilderUIPage(this.label, this.inputs, tags);
     }
 }
 export const BuilderUIPageSchema = v.instance(BuilderUIPage);
 export const BuilderUIPageSerialisedSchema = serialisable(v.object({
     type: v.literal('page'),
     label: paramable(v.string()),
-    inputs: paramable(BuilderUIInputsSerialisedSchema)
+    inputs: paramable(BuilderUIInputsSerialisedSchema),
+    tags: v.optional(BuilderTagsSchema)
 }));

package/dist/entities/ui/pages.d.ts

@@ -1,4 +1,5 @@
 import type { Paramable, ParamableSerialised } from '../../references';
+import type { BuilderTags } from '../tags';
 import type { BuilderUIDescribe, BuilderUIDescribeSerialised } from './describe';
 import type { BuilderUIPage, BuilderUIPageSerialised } from './page';
 import * as v from 'valibot';
@@ -9,7 +10,9 @@ export declare class BuilderUIPages<const Name extends string = string, const La
     readonly name: Name;
     readonly label: Label;
     readonly items: Items;
-    constructor(name: Name, label: Label, items: Items);
+    readonly tags?: BuilderTags;
+    constructor(name: Name, label: Label, items: Items, tags?: BuilderTags);
+    tag(...tags: Array<string>): BuilderUIPages<Name, Label, Items>;
 }
 export declare const BuilderUIPagesSchema: v.InstanceSchema<typeof BuilderUIPages, undefined>;
 export type BuilderUIPagesSerialised = {
@@ -17,6 +20,7 @@ export type BuilderUIPagesSerialised = {
     readonly name: string;
     readonly label: ParamableSerialised<string>;
     readonly items: ParamableSerialised<BuilderUIItemsSerialised>;
+    readonly tags?: BuilderTags;
 };
 export type BuilderUIItemSerialised = BuilderUIPageSerialised | BuilderUIDescribeSerialised | BuilderUIPagesSerialised;
 export type BuilderUIItemsSerialised = ReadonlyArray<ParamableSerialised<BuilderUIItemSerialised>>;

package/dist/entities/ui/pages.js

@@ -1,6 +1,7 @@
 import * as v from 'valibot';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 import { BuilderUIDescribeSerialisedSchema } from './describe.js';
 import { BuilderUIPageSerialisedSchema } from './page.js';
 export class BuilderUIPages {
@@ -8,10 +9,15 @@ export class BuilderUIPages {
     name;
     label;
     items;
-    constructor(name, label, items) {
+    tags;
+    constructor(name, label, items, tags) {
         this.name = name;
         this.label = label;
         this.items = items;
+        this.tags = tags;
+    }
+    tag(...tags) {
+        return new BuilderUIPages(this.name, this.label, this.items, tags);
     }
 }
 export const BuilderUIPagesSchema = v.instance(BuilderUIPages);
@@ -19,7 +25,8 @@ export const BuilderUIPagesSerialisedSchema = serialisable(v.object({
     type: v.literal('pages'),
     name: v.string(),
     label: paramable(v.string()),
-    items: paramable(v.lazy(() => BuilderUIItemsSerialisedSchema))
+    items: paramable(v.lazy(() => BuilderUIItemsSerialisedSchema)),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export const BuilderUIItemSerialisedSchema = v.union([
     BuilderUIPageSerialisedSchema,

package/dist/entities/ui/ui.d.ts

@@ -3,27 +3,32 @@ import type { BuilderExpectation, BuilderExpectations, BuilderExpectationsSerial
 import type { CollectionNamesOf } from '../collection/index';
 import type { BuilderModel, BuilderModelGeneric, BuilderModelStateOf } from '../model/model';
 import type { BuilderModelStateAsserted } from '../model/expectation';
+import type { BuilderTags } from '../tags';
 import type { BuilderUIValidInputsOf } from './input';
 import type { BuilderUIItems, BuilderUIItemsSerialised } from './pages';
 import * as v from 'valibot';
 export type BuilderUIs = ReadonlyArray<Paramable<BuilderUI>>;
 export type BuilderUIsSerialised = ReadonlyArray<ParamableSerialised<BuilderUISerialised>>;
 export declare class BuilderUI<Model extends BuilderModelGeneric = BuilderModelGeneric> {
+    #private;
     readonly type: 'ui';
     readonly model: Model;
     readonly uis: BuilderUIs;
     readonly items: BuilderUIItems;
     readonly expectations: BuilderExpectations;
-    constructor(uis: BuilderUIs, items: BuilderUIItems, expectations: BuilderExpectations);
+    readonly tags?: BuilderTags;
+    constructor(uis: BuilderUIs, items: BuilderUIItems, expectations: BuilderExpectations, tags?: BuilderTags);
     expect<const Exps extends readonly [BuilderExpectation, ...ReadonlyArray<BuilderExpectation>]>(...expectations: Exps): BuilderUI<BuilderModel<BuilderModelStateAsserted<BuilderModelStateOf<Model>, Exps>>>;
     page(label: Paramable<string>, inputs: Paramable<BuilderUIValidInputsOf<Model>>): BuilderUI<Model>;
     describe(label: Paramable<string>, inputs: Paramable<BuilderUIValidInputsOf<Model>>): BuilderUI<Model>;
     pages<const Name extends CollectionNamesOf<BuilderModelStateOf<Model>>>(name: Name, label: Paramable<string>, itemUI: Paramable<BuilderUI<BuilderModelGeneric>>): BuilderUI<Model>;
+    tag(...tags: Array<string>): BuilderUI<Model>;
 }
 export declare const BuilderUISchema: v.InstanceSchema<typeof BuilderUI, undefined>;
 export interface BuilderUISerialised {
     readonly uis: BuilderUIsSerialised;
     readonly items: BuilderUIItemsSerialised;
     readonly expectations: BuilderExpectationsSerialised;
+    readonly tags?: BuilderTags;
 }
 export declare const BuilderUISerialisedSchema: v.GenericSchema<BuilderUISerialised>;

package/dist/entities/ui/ui.js

@@ -3,6 +3,7 @@ import { check } from '../../check.js';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
 import { BuilderExpectationsSerialisedSchema } from '../expectation.js';
+import { BuilderTagsSchema } from '../tags.js';
 import { BuilderUIDescribe } from './describe.js';
 import { BuilderUIPage } from './page.js';
 import { BuilderUIItemsSerialisedSchema, BuilderUIPages } from './pages.js';
@@ -10,34 +11,48 @@ export class BuilderUI {
     uis;
     items;
     expectations;
-    constructor(uis, items, expectations) {
+    tags;
+    constructor(uis, items, expectations, tags) {
         this.uis = uis;
         this.items = items;
         this.expectations = expectations;
+        this.tags = tags;
+    }
+    #next(patch) {
+        return new BuilderUI(this.uis, patch.items ?? this.items, patch.expectations ?? this.expectations, patch.tags ?? this.tags);
     }
     expect(...expectations) {
-        return new BuilderUI(this.uis, this.items, [
-            ...this.expectations,
-            ...expectations
-        ]);
+        return this.#next({
+            expectations: [...this.expectations, ...expectations]
+        });
     }
     page(label, inputs) {
-        return new BuilderUI(this.uis, [...this.items, new BuilderUIPage(label, inputs)], this.expectations);
+        return this.#next({
+            items: [...this.items, new BuilderUIPage(label, inputs)]
+        });
     }
     describe(label, inputs) {
-        return new BuilderUI(this.uis, [
-            ...this.items,
-            new BuilderUIDescribe(label, inputs)
-        ], this.expectations);
+        return this.#next({
+            items: [
+                ...this.items,
+                new BuilderUIDescribe(label, inputs)
+            ]
+        });
     }
     pages(name, label, itemUI) {
         const items = check.is(BuilderUISchema, itemUI) ? itemUI.items : itemUI;
-        return new BuilderUI(this.uis, [...this.items, new BuilderUIPages(name, label, items)], this.expectations);
+        return this.#next({
+            items: [...this.items, new BuilderUIPages(name, label, items)]
+        });
+    }
+    tag(...tags) {
+        return this.#next({ tags });
     }
 }
 export const BuilderUISchema = v.instance(BuilderUI);
 export const BuilderUISerialisedSchema = serialisable(v.object({
     uis: v.pipe(v.array(paramable(v.lazy(() => BuilderUISerialisedSchema))), v.readonly()),
     items: BuilderUIItemsSerialisedSchema,
-    expectations: BuilderExpectationsSerialisedSchema
+    expectations: BuilderExpectationsSerialisedSchema,
+    tags: v.optional(BuilderTagsSchema)
 }));