@builder-builder/builder 0.0.27 → 0.0.28

package/dist/entities/serialise.d.ts

@@ -33,13 +33,13 @@ export declare const entitiesMap: {
         readonly runtime: v.InstanceSchema<typeof import(".").BuilderToggleConfig, undefined>;
         readonly serialised: v.SchemaWithPipe<readonly [v.ObjectSchema<{
             readonly type: v.LiteralSchema<"toggle", undefined>;
-            readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+            readonly kind: v.PicklistSchema<["string", "boolean", "number"], undefined>;
             readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
             readonly isOptional: v.BooleanSchema<undefined>;
             readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
         }, undefined>, v.ReadonlyAction<{
             type: "toggle";
-            valueType: "string" | "number" | "boolean";
+            kind: "string" | "number" | "boolean";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
             tags?: readonly string[] | undefined;
@@ -61,7 +61,7 @@ export declare const entitiesMap: {
             tags?: readonly string[] | undefined;
         }>> | Readonly<Readonly<{
             type: "toggle";
-            valueType: "string" | "number" | "boolean";
+            kind: "string" | "number" | "boolean";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
             tags?: readonly string[] | undefined;
@@ -81,7 +81,7 @@ export declare const entitiesMap: {
             tags?: readonly string[] | undefined;
         }>> | Readonly<Readonly<{
             type: "toggle";
-            valueType: "string" | "number" | "boolean";
+            kind: "string" | "number" | "boolean";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
             tags?: readonly string[] | undefined;
@@ -99,7 +99,7 @@ export declare const entitiesMap: {
             tags?: readonly string[] | undefined;
         }>> | Readonly<Readonly<{
             type: "toggle";
-            valueType: "string" | "number" | "boolean";
+            kind: "string" | "number" | "boolean";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
             tags?: readonly string[] | undefined;
@@ -115,7 +115,7 @@ export declare const entitiesMap: {
             tags?: readonly string[] | undefined;
         }>> | Readonly<Readonly<{
             type: "toggle";
-            valueType: "string" | "number" | "boolean";
+            kind: "string" | "number" | "boolean";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
             tags?: readonly string[] | undefined;
@@ -124,7 +124,7 @@ export declare const entitiesMap: {
     readonly componentConfig: {
         readonly runtime: v.InstanceSchema<typeof import(".").BuilderComponentConfig, undefined>;
         readonly serialised: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly fields: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly details: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly type: v.LiteralSchema<"parameter", undefined>;
                 readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
                 readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -139,27 +139,27 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                readonly type: v.LiteralSchema<"component-field", undefined>;
+                readonly type: v.LiteralSchema<"component-detail", undefined>;
                 readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-                readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+                readonly kind: v.PicklistSchema<["string", "boolean", "number", "price", "image"], undefined>;
                 readonly isOptional: v.BooleanSchema<undefined>;
                 readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
             }, undefined>, v.ReadonlyAction<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>]>, undefined>, v.ReadonlyAction<Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>[]>]>], undefined>;
             readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
         }, undefined>, v.ReadonlyAction<{
-            fields: Readonly<{
+            details: Readonly<{
                 type: "parameter";
                 id: string;
                 name: string;
@@ -167,9 +167,9 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }> | readonly Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>[];
@@ -182,7 +182,7 @@ export declare const entitiesMap: {
             id: string;
             name: string;
         }> | Readonly<{
-            fields: Readonly<{
+            details: Readonly<{
                 type: "parameter";
                 id: string;
                 name: string;
@@ -190,9 +190,9 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }> | readonly Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>[];
@@ -203,7 +203,7 @@ export declare const entitiesMap: {
             id: string;
             name: string;
         }> | Readonly<{
-            fields: Readonly<{
+            details: Readonly<{
                 type: "parameter";
                 id: string;
                 name: string;
@@ -211,9 +211,9 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }> | readonly Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>[];
@@ -222,7 +222,7 @@ export declare const entitiesMap: {
     };
     readonly componentWhen: {
         readonly runtime: v.GenericSchema<import("./when").BuilderWhenSerialised<Readonly<{
-            fields: Readonly<{
+            details: Readonly<{
                 type: "parameter";
                 id: string;
                 name: string;
@@ -230,16 +230,16 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }> | readonly Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>[];
             tags?: readonly string[] | undefined;
         }>>>;
         readonly serialised: v.GenericSchema<import("./when").BuilderWhenSerialised<Readonly<{
-            fields: Readonly<{
+            details: Readonly<{
                 type: "parameter";
                 id: string;
                 name: string;
@@ -247,9 +247,9 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }> | readonly Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>[];
@@ -1422,9 +1422,9 @@ export declare const entitiesMap: {
         readonly serialised: v.BooleanSchema<undefined>;
     };
 };
-export declare const validateNumber: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../errors/errors").BuilderErrorsScope) => import("./validated").ValidationResult<number>;
-export declare const validateString: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../errors/errors").BuilderErrorsScope) => import("./validated").ValidationResult<string>;
-export declare const validateBoolean: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../errors/errors").BuilderErrorsScope) => import("./validated").ValidationResult<boolean>;
+export declare const validateNumber: (input: unknown, references?: import("./references").BuilderReferences, issues?: import("../errors/errors").BuilderIssuesScope) => import("./validated").ValidationResult<number>;
+export declare const validateString: (input: unknown, references?: import("./references").BuilderReferences, issues?: import("../errors/errors").BuilderIssuesScope) => import("./validated").ValidationResult<string>;
+export declare const validateBoolean: (input: unknown, references?: import("./references").BuilderReferences, issues?: import("../errors/errors").BuilderIssuesScope) => import("./validated").ValidationResult<boolean>;
 export type EntitiesMap = typeof entitiesMap;
 export type EntitiesSerialisedSchemas = EntitiesMap[BuilderEntityKind]['serialised'];
 export declare const BuilderEntityKindSchema: v.PicklistSchema<readonly ["builder", "model", "select", "toggle", "optionSelectMap", "optionWhen", "componentConfig", "componentSelectMap", "componentWhen", "collectionConfig", "collectionSelectMap", "collectionWhen", "ui", "uiDescribe", "uiItems", "uiPage", "uiPages", "uiInput", "pricing", "pricingRates", "expectations", "paths", "path", "number", "string", "boolean"], undefined>;
@@ -1433,5 +1433,4 @@ type SerialiseMap = {
     readonly [EntityKind in keyof EntitiesMap]: (input: v.InferOutput<EntitiesMap[EntityKind]['runtime']>) => v.InferOutput<EntitiesMap[EntityKind]['serialised']>;
 };
 export declare const serialise: SerialiseMap;
-export declare function serialiseValue(value: unknown): unknown;
 export {};

package/dist/entities/serialise.js

@@ -4,7 +4,7 @@ import { BooleanSchema, NumberSchema, StringSchema } from '../primitive.js';
 import { BuilderParameterSchema, BuilderRefSchema, isParamable } from '../references.js';
 import { BuilderSchema, BuilderSerialisedSchema } from './builder/index.js';
 import { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionWhenSerialisedSchema } from './collection/index.js';
-import { BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentWhenSerialisedSchema } from './component/index.js';
+import { BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentDetailSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentWhenSerialisedSchema } from './component/index.js';
 import { BuilderExpectationSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema } from './expectation.js';
 import { builderEntityKinds, createEntityValidator } from './kind.js';
 import { BuilderModelSchema, BuilderModelSerialisedSchema } from './model/index.js';
@@ -73,7 +73,7 @@ export const validateBoolean = createEntityValidator('boolean', entitiesMap.bool
 export const BuilderEntityKindSchema = v.picklist(builderEntityKinds);
 export const BuilderEntitySerialisedSchema = v.union(builderEntityKinds.map((kind) => entitiesMap[kind].serialised));
 export const serialise = Object.fromEntries(builderEntityKinds.map((kind) => [kind, serialiseValue]));
-export function serialiseValue(value) {
+function serialiseValue(value) {
     if (value == null || typeof value !== 'object') {
         return value;
     }
@@ -149,13 +149,13 @@ const serialiserMap = [
     serialiser(BuilderComponentSchema, serialiseNamedEntry),
     serialiser(BuilderCollectionSchema, serialiseNamedEntry),
     serialiser(BuilderComponentConfigSchema, (value) => ({
-        fields: serialiseValue(value.fields),
+        details: serialiseValue(value.details),
         tags: value.tags
     })),
-    serialiser(BuilderComponentFieldSchema, (value) => ({
-        type: 'component-field',
+    serialiser(BuilderComponentDetailSchema, (value) => ({
+        type: 'component-detail',
         name: value.name,
-        valueType: value.valueType,
+        kind: value.kind,
         isOptional: value.isOptional,
         tags: value.tags
     })),
@@ -175,7 +175,7 @@ const serialiserMap = [
     })),
     serialiser(BuilderToggleConfigSchema, (value) => ({
         type: 'toggle',
-        valueType: value.valueType,
+        kind: value.kind,
         defaultValue: value.defaultValue,
         isOptional: value.isOptional,
         tags: value.tags

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

@@ -378,7 +378,7 @@ export declare const BuilderUIDescribeSerialisedSchema: v.SchemaWithPipe<readonl
     tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderUIDescribeSerialised = v.InferOutput<typeof BuilderUIDescribeSerialisedSchema>;
-export declare const validateUIDescribe: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
+export declare const validateUIDescribe: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors").BuilderIssuesScope) => import("..").ValidationResult<{
     readonly type: "describe";
     readonly label: string;
     readonly inputs: readonly {

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

@@ -441,7 +441,7 @@ export declare const BuilderUIInputsSerialisedSchema: v.SchemaWithPipe<readonly
     tags?: readonly string[] | undefined;
 }>)[]>]>;
 export type BuilderUIInputsSerialised = v.InferOutput<typeof BuilderUIInputsSerialisedSchema>;
-export declare const validateUIInput: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
+export declare const validateUIInput: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors").BuilderIssuesScope) => import("..").ValidationResult<{
     readonly type: "input";
     readonly path: readonly (string | number)[];
     readonly displayName?: string | undefined;

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

@@ -374,7 +374,7 @@ export declare const BuilderUIPageSerialisedSchema: v.SchemaWithPipe<readonly [v
     tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderUIPageSerialised = v.InferOutput<typeof BuilderUIPageSerialisedSchema>;
-export declare const validateUIPage: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
+export declare const validateUIPage: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors").BuilderIssuesScope) => import("..").ValidationResult<{
     readonly type: "page";
     readonly label: string;
     readonly inputs: readonly {

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

@@ -48,7 +48,7 @@ export declare const BuilderUIItemsSerialisedSchema: v.SchemaWithPipe<readonly [
     type: "ref";
     id: string;
 }> | BuilderUIItemSerialised)[]>]>;
-export declare const validateUIPages: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
+export declare const validateUIPages: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors").BuilderIssuesScope) => import("..").ValidationResult<{
     readonly type: "pages";
     readonly name: string;
     readonly label: string;
@@ -121,7 +121,7 @@ export declare const validateUIPages: (input: unknown, references?: import("..")
     })[];
     readonly tags?: readonly string[] | undefined;
 }>;
-export declare const validateUIItems: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<readonly ({
+export declare const validateUIItems: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors").BuilderIssuesScope) => import("..").ValidationResult<readonly ({
     readonly type: "page";
     readonly label: string;
     readonly inputs: readonly {

package/dist/entities/validated.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderErrors } from '../errors/index';
+import type { BuilderIssues } from '../errors/index';
 import type { BuilderInstance, BuilderInstances, BuilderVariants } from '../instance';
 import type { Prettify } from '../prettify';
 import type { BuilderParameter, BuilderParameterSerialised, BuilderRef, BuilderRefSerialised } from '../references';
@@ -24,7 +24,7 @@ type ValidatedTuple<Input extends ReadonlyArray<unknown>> = Input extends readon
 export type BuilderValidatedMap = {
     readonly [Kind in BuilderEntityKind]: Prettify<Validated<v.InferOutput<(typeof entitiesMap)[Kind]['serialised']>>>;
 };
-export type ValidationResult<Entity> = readonly [Entity, BuilderErrors];
+export type ValidationResult<Entity> = readonly [Entity, BuilderIssues, BuilderIssues];
 export type BuilderValidated = BuilderValidatedMap['builder'];
 export type BuilderModelValidated = BuilderValidatedMap['model'];
 export type BuilderPricingValidated = BuilderValidatedMap['pricing'];

package/dist/entities/when.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderPrimitive, BuilderPrimitives } from '../primitive';
+import type { BuilderPrimitive, BuilderPrimitives, BuilderPrimitivesNonEmpty } from '../primitive';
 import type { BuilderParameter, BuilderParameterSerialised, Paramable } from '../references';
 import type { BuilderModelGeneric, BuilderModelState, BuilderModelStateOf } from './model/index';
 import type { BuilderPath, BuilderPaths } from './paths';
@@ -143,7 +143,7 @@ export declare function createWhenSerialisedSchema<Payload extends v.GenericSche
 export declare function createWhenFactories<Payload>(): {
     enable: <const Values extends Paramable<Payload>>(values: Values) => BuilderEnableConfig<Values>;
     match: <const MatchPayload extends Paramable<Payload>, const MatchPath extends Paramable<BuilderPath>, const SelectMap extends Paramable<BuilderMatchSelectMap<Paramable<Payload>>>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends Paramable<Payload>, const UnlessPath extends Paramable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: BuilderPrimitives, values: Values) => BuilderUnlessConfig<Values, UnlessPath>;
+    unless: <const Values extends Paramable<Payload>, const UnlessPath extends Paramable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: BuilderPrimitivesNonEmpty, values: Values) => BuilderUnlessConfig<Values, UnlessPath>;
 };
 export type BuilderValidPath<State extends BuilderModelState> = InstanceValidPath<State['instance']>;
 export type BuilderValidPaths<State extends BuilderModelState> = ReadonlyArray<BuilderValidPath<State>>;
@@ -167,15 +167,15 @@ export type WhenConfigNullable<Config extends BuilderWhenGeneric> = Config exten
     readonly type: 'match';
     readonly selectMap: infer SelectMap;
 } ? null extends SelectMap[keyof SelectMap] ? null : never : never;
-export type WhenNullability<State extends BuilderModelState, GatePaths extends Paramable<BuilderPaths>, Config extends Paramable<BuilderWhenGeneric>> = [GatePaths] extends [BuilderParameter] ? null : WhenNullabilityFromPaths<State['instance'], Extract<GatePaths, BuilderValidPaths<State>>, Config>;
+export type WhenNullability<State extends BuilderModelState, ConditionPaths extends Paramable<BuilderPaths>, Config extends Paramable<BuilderWhenGeneric>> = [ConditionPaths] extends [BuilderParameter] ? null : WhenNullabilityFromPaths<State['instance'], Extract<ConditionPaths, BuilderValidPaths<State>>, Config>;
 type BuilderResolvePath<Instance, Path extends BuilderPath> = Path extends readonly [
     infer Head extends keyof Instance & string
 ] ? Instance[Head] : Path extends readonly [
     infer Head extends keyof Instance & string,
     ...infer Tail extends BuilderPath
 ] ? Instance[Head] extends ReadonlyArray<infer Item> ? Tail extends readonly [number, ...infer Rest extends BuilderPath] ? BuilderResolvePath<Item, Rest> : never : BuilderResolvePath<Instance[Head], Tail> : never;
-type WhenNullabilityFromPaths<Instance, GatePaths extends BuilderPaths, Config extends Paramable<BuilderWhenGeneric>> = Config extends BuilderParameter ? WhenPathsNullable<Instance, GatePaths> : Config extends BuilderWhenGeneric ? WhenPathsNullable<Instance, GatePaths> | WhenConfigNullable<Config> : never;
-type WhenPathsNullable<Instance, GatePaths extends BuilderPaths> = GatePaths extends readonly [
+type WhenNullabilityFromPaths<Instance, ConditionPaths extends BuilderPaths, Config extends Paramable<BuilderWhenGeneric>> = Config extends BuilderParameter ? WhenPathsNullable<Instance, ConditionPaths> : Config extends BuilderWhenGeneric ? WhenPathsNullable<Instance, ConditionPaths> | WhenConfigNullable<Config> : never;
+type WhenPathsNullable<Instance, ConditionPaths extends BuilderPaths> = ConditionPaths extends readonly [
     infer Head extends BuilderPath,
     ...infer Tail extends BuilderPaths
 ] ? WhenPathNullable<Instance, Head> | WhenPathsNullable<Instance, Tail> : never;

package/dist/environment.d.ts

@@ -1,5 +1,5 @@
-import type { BuilderErrors } from './errors/index';
+import type { BuilderIssues } from './errors/index';
 import * as v from 'valibot';
 export declare const BuilderEnvironmentSchema: v.PicklistSchema<["development", "staging", "production"], undefined>;
 export type BuilderEnvironment = v.InferOutput<typeof BuilderEnvironmentSchema>;
-export type BuilderEnvironmentResult<EntityType, Env extends BuilderEnvironment = 'production'> = Env extends 'development' ? readonly [EntityType, BuilderErrors] : readonly [EntityType, ReadonlyArray<never>];
+export type BuilderEnvironmentResult<EntityType, Env extends BuilderEnvironment = 'production'> = Env extends 'development' ? readonly [EntityType, BuilderIssues, BuilderIssues] : readonly [EntityType, ReadonlyArray<never>, BuilderIssues];