@builder-builder/builder 0.0.14 → 0.0.16

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,11 +19,14 @@ 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;
+    price(pricing: BuilderPricingValidated, order: BuilderOrder): number | null;
     variants(entity: BuilderValidated | BuilderModelValidated): BuilderComponentVariants;
 };
-export declare const bb: typeof bbProd & {
-    dev: typeof bbDev;
+export declare const bb: typeof bbProduction & {
+    development: typeof bbDevelopment;
+    staging: typeof bbProduction;
+    production: typeof bbProduction;
 };
-declare function bbProd(options?: BBOptions): BB<'production'>;
-declare function bbDev(options?: BBOptions): BB<'development'>;
+declare function bbProduction(options?: BBOptions): BB<'production'>;
+declare function bbDevelopment(options?: BBOptions): BB<'development'>;
 export {};

package/dist/bb.js

@@ -1,12 +1,14 @@
 import { BuilderException } from './exception.js';
-import { assertValidated, createInstance, createVariants, order, render, validateBuilder, validateInstance, validateModel, validateUI, validateVariants } from './mappers/index.js';
-export const bb = Object.assign(bbProd, {
-    dev: bbDev
+import { assertValidated, createInstance, createVariants, order, price, render, validateBuilder, validateInstance, validateModel, validatePricing, validateUI, validateVariants } from './mappers/index.js';
+export const bb = Object.assign(bbProduction, {
+    development: bbDevelopment,
+    staging: bbProduction,
+    production: bbProduction
 });
-function bbProd(options = {}) {
+function bbProduction(options = {}) {
     return bbFactory('production', options.references);
 }
-function bbDev(options = {}) {
+function bbDevelopment(options = {}) {
     return bbFactory('development', options.references);
 }
 function bbFactory(environment, references = []) {
@@ -14,6 +16,7 @@ function bbFactory(environment, references = []) {
         validate: {
             builder: (input) => throwInProd(validateBuilder(input, references)),
             model: (input) => throwInProd(validateModel(input, references)),
+            pricing: (input) => throwInProd(validatePricing(input, references)),
             ui: (input) => throwInProd(validateUI(input, references)),
             instance: (model, instance) => throwInProd(validateInstance(model, instance)),
             variants: (model, input, variantOptions) => throwInProd(validateVariants(model, input, variantOptions))
@@ -33,6 +36,10 @@ function bbFactory(environment, references = []) {
             assertValidated(variants);
             return order(model, instance, variants, references);
         },
+        price: (pricing, order) => {
+            assertValidated(pricing);
+            return price(pricing, order);
+        },
         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,35 @@
+import type { BuilderModelSerialised } from '../model/model';
 import type { BuilderModelBindings, BuilderModelBoundState } from '../model/bind';
 import type { BuilderModelState } from '../model/state';
+import type { BuilderPricingSerialised } from '../pricing/index';
+import type { BuilderTags } from '../tags';
+import type { BuilderUISerialised } from '../ui/ui';
 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';
+import { BuilderModel } from '../model/index.js';
+import { BuilderPricing } from '../pricing/index.js';
+import { BuilderUI } 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: BuilderPricing;
+    constructor(model?: BuilderModel<State>, ui?: BuilderUI<import("..").BuilderModelGeneric>, pricing?: BuilderPricing, bindings?: BuilderBindings, tags?: BuilderTags);
     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: BuilderPricing): Builder<State>;
 }
 export declare const BuilderSchema: v.InstanceSchema<typeof Builder, undefined>;
+export declare function builder(): Builder<BuilderModelState>;
+export declare function builder<const State extends BuilderModelState>(model: BuilderModel<State>, ui?: BuilderUI, pricing?: BuilderPricing): Builder<State>;
 export interface BuilderSerialised {
-    readonly model: v.InferOutput<typeof BuilderModelSerialisedSchema>;
-    readonly ui: v.InferOutput<typeof BuilderUISerialisedSchema>;
+    readonly model: BuilderModelSerialised;
+    readonly ui: BuilderUISerialised;
     readonly bindings: BuilderBindingsSerialised;
+    readonly tags?: BuilderTags;
+    readonly pricing: BuilderPricingSerialised;
 }
 export declare const BuilderSerialisedSchema: v.GenericSchema<BuilderSerialised>;

package/dist/entities/builder/builder.js

@@ -2,26 +2,45 @@ import * as v from 'valibot';
 import { BuilderRefSerialisedSchema } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
 import { BuilderModel, BuilderModelSerialisedSchema } from '../model/index.js';
+import { BuilderPricing, BuilderPricingSerialisedSchema } from '../pricing/index.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([], [], []), pricing = new BuilderPricing(), bindings = {}, tags) {
         this.model = model;
         this.ui = ui;
+        this.pricing = pricing;
         this.bindings = bindings;
+        this.tags = tags;
+    }
+    #next(patch) {
+        return new Builder(this.model, this.ui, patch.pricing ?? this.pricing, patch.bindings ?? this.bindings, patch.tags ?? this.tags);
     }
     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 function builder(model, ui, pricing) {
+    return new Builder(model, ui, pricing);
+}
 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: BuilderPricingSerialisedSchema
 }));

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

@@ -1,4 +1,3 @@
 export type { BuilderBindings, BuilderBindingsSerialised } from './bind';
 export type { BuilderSerialised } from './builder';
-export { Builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';
-export { builder } from './factory.js';
+export { Builder, builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';

package/dist/entities/builder/index.js

@@ -1,2 +1 @@
-export { Builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';
-export { builder } from './factory.js';
+export { Builder, builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';

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>;