@builder-builder/builder 0.0.14 → 0.0.15

package/dist/bb.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderComponentVariantsValidated, BuilderInstanceValidated, BuilderModelValidated, BuilderRefEntities, BuilderUIValidated, BuilderValidated } from './entities/index';
+import type { BuilderComponentVariantsValidated, BuilderInstanceValidated, BuilderModelValidated, BuilderPricingValidated, BuilderRefEntities, BuilderUIValidated, BuilderValidated } from './entities/index';
 import type { BuilderEnvironment, BuilderEnvironmentResult } from './environment';
 import type { BuilderOrder, BuilderRenderResult } from './mappers/index';
 import type { BuilderComponentVariants, BuilderInstance, BuilderInstanceInput } from './instance';
@@ -9,6 +9,7 @@ export type BB<Env extends BuilderEnvironment = 'production'> = {
     readonly validate: {
         builder(input: unknown): BuilderEnvironmentResult<BuilderValidated, Env>;
         model(input: unknown): BuilderEnvironmentResult<BuilderModelValidated, Env>;
+        pricing(input: unknown): BuilderEnvironmentResult<BuilderPricingValidated, Env>;
         ui(input: unknown): BuilderEnvironmentResult<BuilderUIValidated, Env>;
         instance(model: BuilderModelValidated, instance: BuilderInstance): BuilderEnvironmentResult<BuilderInstanceValidated, Env>;
         variants(model: BuilderModelValidated, input: unknown, options?: {
@@ -18,6 +19,7 @@ export type BB<Env extends BuilderEnvironment = 'production'> = {
     instance(entity: BuilderValidated | BuilderModelValidated, partial?: BuilderInstanceInput): BuilderInstance;
     render(builder: BuilderValidated, instance: BuilderInstanceValidated): BuilderRenderResult;
     order(model: BuilderModelValidated, instance: BuilderInstanceValidated, variants: BuilderComponentVariantsValidated): BuilderOrder;
+    pricing(builder: BuilderValidated, order: BuilderOrder): number;
     variants(entity: BuilderValidated | BuilderModelValidated): BuilderComponentVariants;
 };
 export declare const bb: typeof bbProd & {

package/dist/bb.js

@@ -1,5 +1,5 @@
 import { BuilderException } from './exception.js';
-import { assertValidated, createInstance, createVariants, order, render, validateBuilder, validateInstance, validateModel, validateUI, validateVariants } from './mappers/index.js';
+import { assertValidated, createInstance, createVariants, order, pricing, render, validateBuilder, validateInstance, validateModel, validatePricing, validateUI, validateVariants } from './mappers/index.js';
 export const bb = Object.assign(bbProd, {
     dev: bbDev
 });
@@ -14,6 +14,7 @@ function bbFactory(environment, references = []) {
         validate: {
             builder: (input) => throwInProd(validateBuilder(input, references)),
             model: (input) => throwInProd(validateModel(input, references)),
+            pricing: (input) => throwInProd(validatePricing(input)),
             ui: (input) => throwInProd(validateUI(input, references)),
             instance: (model, instance) => throwInProd(validateInstance(model, instance)),
             variants: (model, input, variantOptions) => throwInProd(validateVariants(model, input, variantOptions))
@@ -33,6 +34,10 @@ function bbFactory(environment, references = []) {
             assertValidated(variants);
             return order(model, instance, variants, references);
         },
+        pricing: (builder, orderResult) => {
+            assertValidated(builder);
+            return pricing(builder.model, builder.pricing, orderResult, references);
+        },
         variants: (entity) => {
             assertValidated(entity);
             return createVariants(entity);

package/dist/check.d.ts

@@ -2,8 +2,8 @@ import * as v from 'valibot';
 declare class Check {
     truthy<Input>(input: Input, message?: `${string}! ❌`): asserts input is Exclude<Input, null | undefined | '' | 0 | false>;
     falsy(input: unknown, message?: `${string}! ❌`): void;
-    is<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown): input is v.InferInput<Schema>;
-    assert<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown, message?: `${string}! ❌`): asserts input is v.InferInput<Schema>;
+    is<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown): input is v.InferOutput<Schema>;
+    assert<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown, message?: `${string}! ❌`): asserts input is v.InferOutput<Schema>;
 }
 export declare const check: Check;
 export {};

package/dist/entities/builder/builder.d.ts

@@ -1,21 +1,31 @@
 import type { BuilderModelBindings, BuilderModelBoundState } from '../model/bind';
 import type { BuilderModelState } from '../model/state';
+import type { BuilderPricing } from '../pricing';
+import type { BuilderTags } from '../tags';
+import type { Paramable, ParamableSerialised } from '../../references';
 import type { BuilderBindings, BuilderBindingsSerialised } from './bind';
 import * as v from 'valibot';
 import { BuilderModel, BuilderModelSerialisedSchema } from '../model/index.js';
 import { BuilderUI, BuilderUISerialisedSchema } from '../ui/index.js';
 export declare class Builder<State extends BuilderModelState = BuilderModelState> {
+    #private;
     readonly type: 'builder';
     readonly model: BuilderModel<State>;
     readonly ui: BuilderUI;
     readonly bindings: BuilderBindings;
-    constructor(model?: BuilderModel<State>, ui?: BuilderUI<import("..").BuilderModelGeneric>, bindings?: BuilderBindings);
+    readonly tags?: BuilderTags;
+    readonly pricing?: Paramable<BuilderPricing>;
+    constructor(model?: BuilderModel<State>, ui?: BuilderUI<import("..").BuilderModelGeneric>, bindings?: BuilderBindings, tags?: BuilderTags, pricing?: Paramable<BuilderPricing>);
     bind<const Bindings extends BuilderBindings>(extra: Bindings): Bindings extends BuilderModelBindings<State> ? Builder<BuilderModelBoundState<State, Bindings>> : Builder<State>;
+    tag(...tags: Array<string>): Builder<State>;
+    priced(pricing: Paramable<BuilderPricing>): Builder<State>;
 }
 export declare const BuilderSchema: v.InstanceSchema<typeof Builder, undefined>;
 export interface BuilderSerialised {
     readonly model: v.InferOutput<typeof BuilderModelSerialisedSchema>;
     readonly ui: v.InferOutput<typeof BuilderUISerialisedSchema>;
     readonly bindings: BuilderBindingsSerialised;
+    readonly tags?: BuilderTags;
+    readonly pricing?: ParamableSerialised<BuilderPricing>;
 }
 export declare const BuilderSerialisedSchema: v.GenericSchema<BuilderSerialised>;

package/dist/entities/builder/builder.js

@@ -1,27 +1,43 @@
 import * as v from 'valibot';
-import { BuilderRefSerialisedSchema } from '../../references.js';
+import { BuilderRefSerialisedSchema, paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
 import { BuilderModel, BuilderModelSerialisedSchema } from '../model/index.js';
+import { BuilderPricingSchema } from '../pricing.js';
+import { BuilderTagsSchema } from '../tags.js';
 import { BuilderUI, BuilderUISerialisedSchema } from '../ui/index.js';
 export class Builder {
     model;
     ui;
     bindings;
-    constructor(model = new BuilderModel(), ui = new BuilderUI([], [], []), bindings = {}) {
+    tags;
+    pricing;
+    constructor(model = new BuilderModel(), ui = new BuilderUI([], [], []), bindings = {}, tags, pricing) {
         this.model = model;
         this.ui = ui;
         this.bindings = bindings;
+        this.tags = tags;
+        this.pricing = pricing;
+    }
+    #next(patch) {
+        return new Builder(this.model, this.ui, patch.bindings ?? this.bindings, patch.tags ?? this.tags, patch.pricing ?? this.pricing);
     }
     bind(extra) {
-        return new Builder(this.model, this.ui, {
-            ...this.bindings,
-            ...extra
+        return this.#next({
+            bindings: { ...this.bindings, ...extra }
         });
     }
+    tag(...tags) {
+        return this.#next({ tags });
+    }
+    priced(pricing) {
+        return this.#next({ pricing });
+    }
 }
 export const BuilderSchema = v.instance(Builder);
 export const BuilderSerialisedSchema = serialisable(v.object({
     model: BuilderModelSerialisedSchema,
     ui: BuilderUISerialisedSchema,
-    bindings: v.pipe(v.record(v.string(), v.union([BuilderRefSerialisedSchema, v.unknown()])), v.readonly())
+    bindings: v.pipe(v.record(v.string(), v.union([BuilderRefSerialisedSchema, v.unknown()])), v.readonly()),
+    tags: v.optional(BuilderTagsSchema),
+    pricing: v.optional(paramable(BuilderPricingSchema))
 }));

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

@@ -1,6 +1,7 @@
 import type { BuilderPaths } from '../../paths';
 import type { Paramable, ParamableSerialised } from '../../references';
 import type { BuilderModelState } from '../model/index';
+import type { BuilderTags } from '../tags';
 import type { BuilderWhenSerialised } from '../when';
 import type { BuilderCollectionConfig, BuilderCollectionConfigSerialised } from './config';
 import type { BuilderCollectionWhen } from './when';
@@ -11,7 +12,9 @@ export declare class BuilderCollection<const Name extends string = string, const
     readonly name: Name;
     readonly payload: Payload;
     readonly paths?: Paths;
-    constructor(name: Name, payload: Payload, paths?: Paths);
+    readonly tags?: BuilderTags;
+    constructor(name: Name, payload: Payload, paths?: Paths, tags?: BuilderTags);
+    tag(...tags: Array<string>): BuilderCollection<Name, Payload, Paths>;
 }
 export declare const BuilderCollectionSchema: v.InstanceSchema<typeof BuilderCollection, undefined>;
 export type BuilderCollections = ReadonlyArray<BuilderCollection>;
@@ -40,6 +43,7 @@ export declare const BuilderCollectionWhenSerialisedSchema: v.GenericSchema<Buil
         type: "ref";
         id: string;
     }>;
+    tags?: readonly string[] | undefined;
 }>>>;
 export type BuilderCollectionWhenSerialised = BuilderWhenSerialised<BuilderCollectionConfigSerialised>;
 export declare const BuilderCollectionSelectMapSerialisedSchema: v.GenericSchema<import("..").BuilderMatchSelectMap<Readonly<{
@@ -71,11 +75,13 @@ export declare const BuilderCollectionSelectMapSerialisedSchema: v.GenericSchema
         type: "ref";
         id: string;
     }>;
+    tags?: readonly string[] | undefined;
 }>>>;
 export type BuilderCollectionSerialised = {
     readonly name: string;
     readonly paths?: ParamableSerialised<BuilderPaths>;
     readonly payload: ParamableSerialised<BuilderCollectionConfigSerialised | BuilderCollectionWhenSerialised>;
+    readonly tags?: BuilderTags;
 };
 export declare const BuilderCollectionSerialisedSchema: v.GenericSchema<BuilderCollectionSerialised>;
 export declare const BuilderCollectionsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<BuilderCollectionSerialised>, undefined>, v.ReadonlyAction<BuilderCollectionSerialised[]>]>;

package/dist/entities/collection/collection.js

@@ -2,16 +2,22 @@ import * as v from 'valibot';
 import { BuilderPathsSchema } from '../../paths.js';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 import { createSelectMapSerialisedSchema, createWhenSerialisedSchema } from '../when.js';
 import { BuilderCollectionConfigSerialisedSchema } from './config.js';
 export class BuilderCollection {
     name;
     payload;
     paths;
-    constructor(name, payload, paths) {
+    tags;
+    constructor(name, payload, paths, tags) {
         this.name = name;
         this.payload = payload;
         this.paths = paths;
+        this.tags = tags;
+    }
+    tag(...tags) {
+        return new BuilderCollection(this.name, this.payload, this.paths, tags);
     }
 }
 export const BuilderCollectionSchema = v.instance(BuilderCollection);
@@ -20,6 +26,7 @@ export const BuilderCollectionSelectMapSerialisedSchema = createSelectMapSeriali
 export const BuilderCollectionSerialisedSchema = serialisable(v.object({
     name: v.string(),
     payload: paramable(v.union([BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema])),
-    paths: v.optional(paramable(BuilderPathsSchema))
+    paths: v.optional(paramable(BuilderPathsSchema)),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export const BuilderCollectionsSerialisedSchema = v.pipe(v.array(BuilderCollectionSerialisedSchema), v.readonly());

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

@@ -1,12 +1,15 @@
 import type { Paramable } from '../../references';
 import type { BuilderModelGeneric } from '../model/index';
+import type { BuilderTags } from '../tags';
 import * as v from 'valibot';
 export declare class BuilderCollectionConfig<Model extends Paramable<BuilderModelGeneric> = Paramable<BuilderModelGeneric>, Min extends Paramable<number> = Paramable<number>, Max extends Paramable<number> = Paramable<number>> {
     readonly type: 'collection-config';
     readonly model: Model;
     readonly min: Min;
     readonly max: Max;
-    constructor(model: Model, min: Min, max: Max);
+    readonly tags?: BuilderTags;
+    constructor(model: Model, min: Min, max: Max, tags?: BuilderTags);
+    tag(...tags: Array<string>): BuilderCollectionConfig<Model, Min, Max>;
 }
 export declare const BuilderCollectionConfigSchema: v.InstanceSchema<typeof BuilderCollectionConfig, undefined>;
 export declare const BuilderCollectionConfigSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
@@ -55,6 +58,7 @@ export declare const BuilderCollectionConfigSerialisedSchema: v.SchemaWithPipe<r
         type: "ref";
         id: string;
     }>]>, v.NumberSchema<undefined>], undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     model: Readonly<{
         type: "parameter";
@@ -80,6 +84,7 @@ export declare const BuilderCollectionConfigSerialisedSchema: v.SchemaWithPipe<r
         type: "ref";
         id: string;
     }>;
+    tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderCollectionConfigSerialised = v.InferOutput<typeof BuilderCollectionConfigSerialisedSchema>;
 export declare function collectionConfig<Model extends Paramable<BuilderModelGeneric> = Paramable<BuilderModelGeneric>, Min extends Paramable<number> = Paramable<number>, Max extends Paramable<number> = Paramable<number>>(model: Model, min: Min, max: Max): BuilderCollectionConfig<Model, Min, Max>;

package/dist/entities/collection/config.js

@@ -2,21 +2,28 @@ import * as v from 'valibot';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
 import { BuilderModelSerialisedSchema } from '../model/index.js';
+import { BuilderTagsSchema } from '../tags.js';
 export class BuilderCollectionConfig {
     model;
     min;
     max;
-    constructor(model, min, max) {
+    tags;
+    constructor(model, min, max, tags) {
         this.model = model;
         this.min = min;
         this.max = max;
+        this.tags = tags;
+    }
+    tag(...tags) {
+        return new BuilderCollectionConfig(this.model, this.min, this.max, tags);
     }
 }
 export const BuilderCollectionConfigSchema = v.instance(BuilderCollectionConfig);
 export const BuilderCollectionConfigSerialisedSchema = serialisable(v.object({
     model: paramable(v.lazy(() => BuilderModelSerialisedSchema)),
     min: paramable(v.number()),
-    max: paramable(v.number())
+    max: paramable(v.number()),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export function collectionConfig(model, min, max) {
     return new BuilderCollectionConfig(model, min, max);

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

@@ -1,5 +1,6 @@
 import type { BuilderPaths } from '../../paths';
 import type { Paramable } from '../../references';
+import type { BuilderTags } from '../tags';
 import type { BuilderWhenSerialised } from '../when';
 import type { BuilderComponentDetails, BuilderComponentDetailsSerialised } from './details';
 import type { BuilderComponentWhen } from './when';
@@ -10,7 +11,9 @@ export declare class BuilderComponent<const Name extends string = string, const
     readonly name: Name;
     readonly payload: Payload;
     readonly paths?: Paths;
-    constructor(name: Name, payload: Payload, paths?: Paths);
+    readonly tags?: BuilderTags;
+    constructor(name: Name, payload: Payload, paths?: Paths, tags?: BuilderTags);
+    tag(...tags: Array<string>): BuilderComponent<Name, Payload, Paths>;
 }
 export declare const BuilderComponentSchema: v.InstanceSchema<typeof BuilderComponent, undefined>;
 export type BuilderComponents = ReadonlyArray<BuilderComponent>;
@@ -27,7 +30,9 @@ export declare const BuilderComponentWhenSerialisedSchema: v.GenericSchema<Build
         name: string;
         valueType: "string" | "number" | "boolean";
         isOptional: boolean;
+        tags?: readonly string[] | undefined;
     }>[];
+    tags?: readonly string[] | undefined;
 }>>>;
 export type BuilderComponentWhenSerialised = BuilderWhenSerialised<BuilderComponentDetailsSerialised>;
 export declare const BuilderComponentSelectMapSerialisedSchema: v.GenericSchema<import("..").BuilderMatchSelectMap<Readonly<{
@@ -47,7 +52,9 @@ export declare const BuilderComponentSelectMapSerialisedSchema: v.GenericSchema<
         name: string;
         valueType: "string" | "number" | "boolean";
         isOptional: boolean;
+        tags?: readonly string[] | undefined;
     }>[];
+    tags?: readonly string[] | undefined;
 }>>>;
 export declare const BuilderComponentSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly name: v.StringSchema<undefined>;
@@ -85,17 +92,21 @@ export declare const BuilderComponentSerialisedSchema: v.SchemaWithPipe<readonly
             readonly name: v.StringSchema<undefined>;
             readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
             readonly isOptional: v.BooleanSchema<undefined>;
+            readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
         }, undefined>, v.ReadonlyAction<{
             type: "component-field";
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>]>, undefined>, v.ReadonlyAction<Readonly<{
             type: "component-field";
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            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<{
         fields: Readonly<{
             type: "parameter";
@@ -109,7 +120,9 @@ export declare const BuilderComponentSerialisedSchema: v.SchemaWithPipe<readonly
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>[];
+        tags?: readonly string[] | undefined;
     }>]>, v.GenericSchema<BuilderWhenSerialised<Readonly<{
         fields: Readonly<{
             type: "parameter";
@@ -123,7 +136,9 @@ export declare const BuilderComponentSerialisedSchema: v.SchemaWithPipe<readonly
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>[];
+        tags?: readonly string[] | undefined;
     }>>>], undefined>], undefined>;
     readonly paths: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly type: v.LiteralSchema<"parameter", undefined>;
@@ -140,6 +155,7 @@ export declare const BuilderComponentSerialisedSchema: v.SchemaWithPipe<readonly
         type: "ref";
         id: string;
     }>]>, 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>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     name: string;
     payload: Readonly<{
@@ -162,7 +178,9 @@ export declare const BuilderComponentSerialisedSchema: v.SchemaWithPipe<readonly
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>[];
+        tags?: readonly string[] | undefined;
     }> | BuilderWhenSerialised<Readonly<{
         fields: Readonly<{
             type: "parameter";
@@ -176,7 +194,9 @@ export declare const BuilderComponentSerialisedSchema: v.SchemaWithPipe<readonly
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>[];
+        tags?: readonly string[] | undefined;
     }>>;
     paths?: readonly (readonly (string | number)[])[] | Readonly<{
         type: "parameter";
@@ -186,6 +206,7 @@ export declare const BuilderComponentSerialisedSchema: v.SchemaWithPipe<readonly
         type: "ref";
         id: string;
     }> | undefined;
+    tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderComponentSerialised = v.InferOutput<typeof BuilderComponentSerialisedSchema>;
 export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
@@ -224,17 +245,21 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
             readonly name: v.StringSchema<undefined>;
             readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
             readonly isOptional: v.BooleanSchema<undefined>;
+            readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
         }, undefined>, v.ReadonlyAction<{
             type: "component-field";
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>]>, undefined>, v.ReadonlyAction<Readonly<{
             type: "component-field";
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            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<{
         fields: Readonly<{
             type: "parameter";
@@ -248,7 +273,9 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>[];
+        tags?: readonly string[] | undefined;
     }>]>, v.GenericSchema<BuilderWhenSerialised<Readonly<{
         fields: Readonly<{
             type: "parameter";
@@ -262,7 +289,9 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>[];
+        tags?: readonly string[] | undefined;
     }>>>], undefined>], undefined>;
     readonly paths: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly type: v.LiteralSchema<"parameter", undefined>;
@@ -279,6 +308,7 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
         type: "ref";
         id: string;
     }>]>, 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>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     name: string;
     payload: Readonly<{
@@ -301,7 +331,9 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>[];
+        tags?: readonly string[] | undefined;
     }> | BuilderWhenSerialised<Readonly<{
         fields: Readonly<{
             type: "parameter";
@@ -315,7 +347,9 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>[];
+        tags?: readonly string[] | undefined;
     }>>;
     paths?: readonly (readonly (string | number)[])[] | Readonly<{
         type: "parameter";
@@ -325,6 +359,7 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
         type: "ref";
         id: string;
     }> | undefined;
+    tags?: readonly string[] | undefined;
 }>]>, undefined>, v.ReadonlyAction<Readonly<{
     name: string;
     payload: Readonly<{
@@ -347,7 +382,9 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>[];
+        tags?: readonly string[] | undefined;
     }> | BuilderWhenSerialised<Readonly<{
         fields: Readonly<{
             type: "parameter";
@@ -361,7 +398,9 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
             name: string;
             valueType: "string" | "number" | "boolean";
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>[];
+        tags?: readonly string[] | undefined;
     }>>;
     paths?: readonly (readonly (string | number)[])[] | Readonly<{
         type: "parameter";
@@ -371,5 +410,6 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
         type: "ref";
         id: string;
     }> | undefined;
+    tags?: readonly string[] | undefined;
 }>[]>]>;
 export type BuilderComponentsSerialised = v.InferOutput<typeof BuilderComponentsSerialisedSchema>;

package/dist/entities/component/component.js

@@ -2,16 +2,22 @@ import * as v from 'valibot';
 import { BuilderPathsSchema } from '../../paths.js';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 import { createSelectMapSerialisedSchema, createWhenSerialisedSchema } from '../when.js';
 import { BuilderComponentDetailsSerialisedSchema } from './details.js';
 export class BuilderComponent {
     name;
     payload;
     paths;
-    constructor(name, payload, paths) {
+    tags;
+    constructor(name, payload, paths, tags) {
         this.name = name;
         this.payload = payload;
         this.paths = paths;
+        this.tags = tags;
+    }
+    tag(...tags) {
+        return new BuilderComponent(this.name, this.payload, this.paths, tags);
     }
 }
 export const BuilderComponentSchema = v.instance(BuilderComponent);
@@ -20,6 +26,7 @@ export const BuilderComponentSelectMapSerialisedSchema = createSelectMapSerialis
 export const BuilderComponentSerialisedSchema = serialisable(v.object({
     name: v.string(),
     payload: paramable(v.union([BuilderComponentDetailsSerialisedSchema, BuilderComponentWhenSerialisedSchema])),
-    paths: v.optional(paramable(BuilderPathsSchema))
+    paths: v.optional(paramable(BuilderPathsSchema)),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export const BuilderComponentsSerialisedSchema = v.pipe(v.array(BuilderComponentSerialisedSchema), v.readonly());

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

@@ -1,10 +1,13 @@
 import type { Paramable } from '../../references';
+import type { BuilderTags } from '../tags';
 import type { BuilderComponentFields } from './field';
 import * as v from 'valibot';
 export declare class BuilderComponentDetails<const Fields extends Paramable<BuilderComponentFields> = Paramable<BuilderComponentFields>> {
     readonly type: 'component-details';
-    fields: Fields;
-    constructor(fields: Fields);
+    readonly fields: Fields;
+    readonly tags?: BuilderTags;
+    constructor(fields: Fields, tags?: BuilderTags);
+    tag(...tags: Array<string>): BuilderComponentDetails<Fields>;
 }
 export declare const BuilderComponentDetailsSchema: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
 export declare const BuilderComponentDetailsSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
@@ -27,17 +30,21 @@ export declare const BuilderComponentDetailsSerialisedSchema: v.SchemaWithPipe<r
         readonly name: v.StringSchema<undefined>;
         readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
         readonly isOptional: v.BooleanSchema<undefined>;
+        readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
     }, undefined>, v.ReadonlyAction<{
         type: "component-field";
         name: string;
         valueType: "string" | "number" | "boolean";
         isOptional: boolean;
+        tags?: readonly string[] | undefined;
     }>]>, undefined>, v.ReadonlyAction<Readonly<{
         type: "component-field";
         name: string;
         valueType: "string" | "number" | "boolean";
         isOptional: boolean;
+        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<{
     fields: Readonly<{
         type: "parameter";
@@ -51,7 +58,9 @@ export declare const BuilderComponentDetailsSerialisedSchema: v.SchemaWithPipe<r
         name: string;
         valueType: "string" | "number" | "boolean";
         isOptional: boolean;
+        tags?: readonly string[] | undefined;
     }>[];
+    tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderComponentDetailsSerialised = v.InferOutput<typeof BuilderComponentDetailsSerialisedSchema>;
 export declare function componentDetails<const Fields extends BuilderComponentFields>(...fields: Fields): BuilderComponentDetails<Fields>;

package/dist/entities/component/details.js

@@ -1,16 +1,23 @@
 import * as v from 'valibot';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 import { BuilderComponentFieldsSerialisedSchema } from './field.js';
 export class BuilderComponentDetails {
     fields;
-    constructor(fields) {
+    tags;
+    constructor(fields, tags) {
         this.fields = fields;
+        this.tags = tags;
+    }
+    tag(...tags) {
+        return new BuilderComponentDetails(this.fields, tags);
     }
 }
 export const BuilderComponentDetailsSchema = v.instance(BuilderComponentDetails);
 export const BuilderComponentDetailsSerialisedSchema = serialisable(v.object({
-    fields: paramable(BuilderComponentFieldsSerialisedSchema)
+    fields: paramable(BuilderComponentFieldsSerialisedSchema),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export function componentDetails(...fields) {
     return new BuilderComponentDetails(fields);