@builder-builder/builder 0.0.20 → 0.0.21

package/dist/bb.d.ts

@@ -1,25 +1,24 @@
-import type { BuilderComponentVariantsValidated, BuilderInstanceValidated, BuilderModelValidated, BuilderPricingValidated, BuilderReferences, BuilderUIValidated, BuilderValidated } from './entities/index';
+import type { BuilderEntityKind, BuilderInstanceValidated, BuilderModelValidated, BuilderReferences, BuilderValidated, BuilderValidatedMap, BuilderVariantsValidated } from './entities/index';
 import type { BuilderEnvironment, BuilderEnvironmentResult } from './environment';
-import type { BuilderComponentVariants, BuilderInstance, BuilderInstanceInput } from './instance';
+import type { BuilderInstance, BuilderInstanceInput, BuilderVariants } from './instance';
 import type { BuilderOrder, BuilderRenderResult } from './mappers/index';
 import type { BuilderVariantsValidationOptions } from './validate/index';
 export type BBOptions = {
     readonly references?: BuilderReferences;
 };
+export type BuilderEntityValidators<Env extends BuilderEnvironment> = {
+    readonly [Kind in BuilderEntityKind]: (input: unknown) => BuilderEnvironmentResult<BuilderValidatedMap[Kind], Env>;
+};
 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>;
+    readonly validate: BuilderEntityValidators<Env> & {
         instance(model: BuilderModelValidated, instance: BuilderInstance): BuilderEnvironmentResult<BuilderInstanceValidated, Env>;
-        variants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions): BuilderEnvironmentResult<BuilderComponentVariantsValidated, Env>;
+        variants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions): BuilderEnvironmentResult<BuilderVariantsValidated, Env>;
     };
     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;
+    order(model: BuilderModelValidated, instance: BuilderInstanceValidated, variants: BuilderVariantsValidated): BuilderOrder;
+    price(pricing: BuilderValidatedMap['pricing'], order: BuilderOrder): number | null;
+    variants(entity: BuilderValidated | BuilderModelValidated): BuilderVariants;
 };
 export declare const bb: typeof bbProduction & {
     development: typeof bbDevelopment;

package/dist/bb.js

@@ -1,4 +1,5 @@
-import { BuilderException } from './exception.js';
+import { validateBoolean, validateCollectionConfig, validateCollectionSelectMap, validateCollectionWhen, validateComponentConfig, validateComponentSelectMap, validateComponentWhen, validateExpectations, validateNumber, validateOptionSelectMap, validateOptionWhen, validatePath, validatePaths, validatePricingRates, validateSelect, validateString, validateToggle, validateUIDescribe, validateUIInput, validateUIItems, validateUIPage, validateUIPages } from './entities/index.js';
+import { BuilderException } from './errors/index.js';
 import { createInstance, createVariants, order, price, render } from './mappers/index.js';
 import { assertValidated, validateBuilder, validateInstance, validateModel, validatePricing, validateUI, validateVariants } from './validate/index.js';
 export const bb = Object.assign(bbProduction, {
@@ -17,8 +18,30 @@ function bbFactory(environment, references = []) {
         validate: {
             builder: (input) => throwInProd(validateBuilder(input, references)),
             model: (input) => throwInProd(validateModel(input, references)),
-            pricing: (input) => throwInProd(validatePricing(input, references)),
+            select: (input) => throwInProd(validateSelect(input, references)),
+            toggle: (input) => throwInProd(validateToggle(input, references)),
+            optionSelectMap: (input) => throwInProd(validateOptionSelectMap(input, references)),
+            optionWhen: (input) => throwInProd(validateOptionWhen(input, references)),
+            componentConfig: (input) => throwInProd(validateComponentConfig(input, references)),
+            componentSelectMap: (input) => throwInProd(validateComponentSelectMap(input, references)),
+            componentWhen: (input) => throwInProd(validateComponentWhen(input, references)),
+            collectionConfig: (input) => throwInProd(validateCollectionConfig(input, references)),
+            collectionSelectMap: (input) => throwInProd(validateCollectionSelectMap(input, references)),
+            collectionWhen: (input) => throwInProd(validateCollectionWhen(input, references)),
             ui: (input) => throwInProd(validateUI(input, references)),
+            uiDescribe: (input) => throwInProd(validateUIDescribe(input, references)),
+            uiItems: (input) => throwInProd(validateUIItems(input, references)),
+            uiPage: (input) => throwInProd(validateUIPage(input, references)),
+            uiPages: (input) => throwInProd(validateUIPages(input, references)),
+            uiInput: (input) => throwInProd(validateUIInput(input, references)),
+            pricing: (input) => throwInProd(validatePricing(input, references)),
+            pricingRates: (input) => throwInProd(validatePricingRates(input, references)),
+            expectations: (input) => throwInProd(validateExpectations(input, references)),
+            paths: (input) => throwInProd(validatePaths(input, references)),
+            path: (input) => throwInProd(validatePath(input, references)),
+            number: (input) => throwInProd(validateNumber(input, references)),
+            string: (input) => throwInProd(validateString(input, references)),
+            boolean: (input) => throwInProd(validateBoolean(input, references)),
             instance: (model, instance) => throwInProd(validateInstance(model, instance)),
             variants: (model, input, variantOptions) => throwInProd(validateVariants(model, input, variantOptions))
         },

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

@@ -1,4 +1,4 @@
-import type { BuilderEntitySerialised } from '../kind';
 import type { BuilderRefSerialised } from '../../references';
+import type { BuilderEntitySerialised } from '../kind';
 export type BuilderBindings = Readonly<Record<string, unknown>>;
 export type BuilderBindingsSerialised = Readonly<Record<string, BuilderEntitySerialised | BuilderRefSerialised>>;

package/dist/entities/builder/builder.js

@@ -1,8 +1,8 @@
 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 { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
 import { BuilderUI, BuilderUISerialisedSchema } from '../ui/index.js';
 export class Builder {