@builder-builder/builder 0.0.6 → 0.0.7

package/dist/core/builder.d.ts

@@ -4,6 +4,7 @@ import type { BuilderComponentEntries, BuilderComponentMethod } from './componen
 import type { BuilderOptionEntries, BuilderOptionMethod } from './option/index';
 import type { BuilderBindings, BuilderBoundState } from './parameter';
 import type { BuilderExpectationEntries, BuilderExpectations, ComponentAssert, ModelAssert } from './expectation';
+import { validateBuilder } from './validate.js';
 import { BuilderComponentGraph } from './component/index.js';
 import { BuilderOptionGraph } from './option/index.js';
 export type BuilderState = {
@@ -42,7 +43,7 @@ export declare class Builder<State extends BuilderState = BuilderStateEmpty> {
     readonly components: BuilderComponentEntries;
     readonly collections: BuilderCollectionEntries;
     readonly expectations: BuilderExpectationEntries;
-    constructor(options?: BuilderOptionEntries, collections?: BuilderCollectionEntries, components?: BuilderComponentEntries, expectations?: BuilderExpectationEntries);
+    constructor(options?: BuilderOptionEntries, components?: BuilderComponentEntries, collections?: BuilderCollectionEntries, expectations?: BuilderExpectationEntries);
     get optionGraph(): BuilderOptionGraph;
     get componentGraph(): BuilderComponentGraph;
     get option(): BuilderOptionMethod<State>;
@@ -55,7 +56,10 @@ export declare class Builder<State extends BuilderState = BuilderStateEmpty> {
     }>;
     bind<const Bindings extends BuilderBindings<State>>(bindings: Bindings): Builder<BuilderBoundState<State, Bindings>>;
 }
-export declare function builder<const BuildersToMerge extends Builders>(...buildersToMerge: BuildersToMerge): Builder<MergedPartsState<BuildersToMerge>>;
+declare function mergeBuilders<const BuildersToMerge extends Builders>(...buildersToMerge: BuildersToMerge): Builder<MergedPartsState<BuildersToMerge>>;
+export declare const builder: typeof mergeBuilders & {
+    validate: typeof validateBuilder;
+};
 type MergedPartsState<Parts extends ReadonlyArray<BuilderGeneric>> = Parts extends readonly [
     infer Head extends BuilderGeneric,
     ...infer Tail extends ReadonlyArray<BuilderGeneric>

package/dist/core/builder.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
-import { BuilderExpectation } from './expectation.js';
 import { check } from '../check.js';
+import { validateBuilder } from './validate.js';
 import { BuilderCollection, resolveCollectionNames } from './collection/index.js';
 import { BuilderComponent, BuilderComponentGraph } from './component/index.js';
 import { BuilderOption, BuilderOptionGraph } from './option/index.js';
@@ -12,10 +12,10 @@ export class Builder {
     expectations;
     #optionGraph = null;
     #componentGraph = null;
-    constructor(options = [], collections = [], components = [], expectations = []) {
+    constructor(options = [], components = [], collections = [], expectations = []) {
         this.options = options;
-        this.collections = collections;
         this.components = components;
+        this.collections = collections;
         this.expectations = expectations;
     }
     get optionGraph() {
@@ -39,16 +39,16 @@ export class Builder {
         const addOption = (name, values) => {
             check.falsy(existingNames.has(name), `Duplicate option name '${name}'! ❌`);
             const entry = new BuilderOption(name, values);
-            return this.#next([...this.options, entry], this.collections, this.components);
+            return this.#next([...this.options, entry], this.components, this.collections);
         };
         const addConditionalOption = (gatePaths, name, config) => {
             check.falsy(existingNames.has(name), `Duplicate option name '${name}'! ❌`);
             if (v.is(v.instance(BuilderParameter), config)) {
                 const entry = new BuilderOption(name, config, gatePaths, null);
-                return this.#next([...this.options, entry], this.collections, this.components);
+                return this.#next([...this.options, entry], this.components, this.collections);
             }
             const entry = new BuilderOption(name, extractValues(config), gatePaths, config);
-            return this.#next([...this.options, entry], this.collections, this.components);
+            return this.#next([...this.options, entry], this.components, this.collections);
         };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
         return Object.assign(addOption, { when: addConditionalOption });
@@ -58,12 +58,12 @@ export class Builder {
         const addComponent = (name, paths) => {
             check.falsy(existingNames.has(name), `Duplicate component name '${name}'! ❌`);
             const entry = new BuilderComponent(name, paths);
-            return this.#next(this.options, this.collections, [...this.components, entry]);
+            return this.#next(this.options, [...this.components, entry], this.collections);
         };
         const addConditionalComponent = (dependencies, name, paths) => {
             check.falsy(existingNames.has(name), `Duplicate component name '${name}'! ❌`);
             const entry = new BuilderComponent(name, paths, dependencies);
-            return this.#next(this.options, this.collections, [...this.components, entry]);
+            return this.#next(this.options, [...this.components, entry], this.collections);
         };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
         return Object.assign(addComponent, { when: addConditionalComponent });
@@ -74,7 +74,7 @@ export class Builder {
             check.falsy(existing.has(name), `Duplicate collection name '${name}'! ❌`);
             check.assert(v.instance(Builder), collectionRecipe);
             const entry = new BuilderCollection(name, collectionRecipe, min, max);
-            return this.#next(this.options, [...this.collections, entry], this.components);
+            return this.#next(this.options, this.components, [...this.collections, entry]);
         };
         const addConditionalCollection = (gatePaths, name, config) => {
             const existing = resolveCollectionNames(this.collections);
@@ -83,13 +83,13 @@ export class Builder {
                 ? Object.values(config.selectMap).find((value) => value !== null)
                 : config;
             const entry = new BuilderCollection(name, defaultEntry.builder, defaultEntry.min, defaultEntry.max, gatePaths, config);
-            return this.#next(this.options, [...this.collections, entry], this.components);
+            return this.#next(this.options, this.components, [...this.collections, entry]);
         };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
         return Object.assign(addCollection, { when: addConditionalCollection });
     }
     expect(...expectations) {
-        return new Builder(this.options, this.collections, this.components, [
+        return new Builder(this.options, this.components, this.collections, [
             ...this.expectations,
             ...expectations
             // eslint-disable-next-line @typescript-eslint/no-explicit-any -- type narrowing cast, validated at merge time
@@ -97,28 +97,13 @@ export class Builder {
     }
     bind(bindings) {
         const boundOptions = bindOptions(this.options, bindings);
-        return new Builder(boundOptions, this.collections, this.components, this.expectations);
+        return new Builder(boundOptions, this.components, this.collections, this.expectations);
     }
-    #next(options, collections, components) {
-        return new Builder(options, collections, components, this.expectations);
+    #next(options, components, collections) {
+        return new Builder(options, components, collections, this.expectations);
     }
 }
-export function builder(...buildersToMerge) {
-    const merged = new Builder(buildersToMerge.flatMap((builder) => builder.options), buildersToMerge.flatMap((builder) => builder.collections), buildersToMerge.flatMap((builder) => builder.components));
-    buildersToMerge
-        .flatMap((builder) => builder.expectations)
-        .forEach((expectation) => {
-        if (v.is(v.instance(BuilderExpectation), expectation)) {
-            if (expectation.kind === 'option') {
-                expectation.validate(merged.options);
-            }
-            else if (expectation.kind === 'component') {
-                expectation.validate(merged.components);
-            }
-            else if (expectation.kind === 'collection') {
-                expectation.validate(merged.collections);
-            }
-        }
-    });
-    return merged;
+function mergeBuilders(...buildersToMerge) {
+    return new Builder(buildersToMerge.flatMap((builder) => builder.options), buildersToMerge.flatMap((builder) => builder.components), buildersToMerge.flatMap((builder) => builder.collections), buildersToMerge.flatMap((builder) => builder.expectations));
 }
+export const builder = Object.assign(mergeBuilders, { validate: validateBuilder });

package/dist/core/expectation.d.ts

@@ -1,5 +1,5 @@
-import type { BuilderGeneric, BuilderMerge, BuilderStateOf } from './builder';
 import type { Prettify } from '../prettify';
+import type { BuilderGeneric, BuilderMerge, BuilderStateOf } from './builder';
 import { BuilderCollection } from './collection/index.js';
 import { BuilderComponent } from './component/index.js';
 export type BuilderExpectationKind = 'option' | 'component' | 'collection';
@@ -21,9 +21,6 @@ export declare class BuilderExpectation<Name extends string = string, Value = un
     readonly kind: Kind;
     constructor(name: Name, kind: Kind);
     optional(): BuilderExpectation<Name, Value | null, Kind>;
-    validate(entries: ReadonlyArray<{
-        readonly name: string;
-    }>): void;
 }
 export declare const has: {
     option: <const Name extends string>(name: Name) => BuilderExpectation<Name, string, "option">;
@@ -33,7 +30,7 @@ export declare const has: {
 type ExpectedModel<Items extends ReadonlyArray<BuilderExpectation>> = Items extends readonly [
     infer Head,
     ...infer Tail extends ReadonlyArray<BuilderExpectation>
-] ? (Head extends BuilderExpectation<infer Name, infer Value, 'option'> ? Record<Name, Value> : unknown) & ExpectedModel<Tail> : unknown;
+] ? (Head extends BuilderExpectation<infer Name, infer Value, 'option'> ? Record<Name, Value> : Head extends BuilderExpectation<infer Name, any, 'collection'> ? Record<Name, ReadonlyArray<unknown>> : unknown) & ExpectedModel<Tail> : unknown;
 type ExpectedComponents<Items extends ReadonlyArray<BuilderExpectation>> = Items extends readonly [
     infer Head,
     ...infer Tail extends ReadonlyArray<BuilderExpectation>

package/dist/core/expectation.js

@@ -1,6 +1,5 @@
 import { BuilderCollection } from './collection/index.js';
 import { BuilderComponent } from './component/index.js';
-import { check } from '../check.js';
 export class BuilderExpectation {
     name;
     kind;
@@ -11,9 +10,6 @@ export class BuilderExpectation {
     optional() {
         return new BuilderExpectation(this.name, this.kind);
     }
-    validate(entries) {
-        check.truthy(entries.some((entry) => entry.name === this.name), `assert: no \`${this.kind}\` named '${this.name}' exists in the builder config! ❌`);
-    }
 }
 export const has = {
     option: (name) => new BuilderExpectation(name, 'option'),

package/dist/core/index.d.ts

@@ -4,9 +4,11 @@ export type { BuilderExpectationEntries, BuilderExpectations, BuilderModelAssert
 export type { BuilderOptionEnableConfig, BuilderOptionEntries, BuilderOptionMatchConfig, BuilderOptionMethod, BuilderOptionUnlessConfig, BuilderOptionValues, BuilderOptionValuesMap, BuilderOptionWhenConfig, BuilderSelectTypeLabels, BuilderSelectTypeValues } from './option/index';
 export type { BuilderWhenEnableConfig, BuilderWhenMatchConfig, BuilderWhenUnlessConfig } from './when/index';
 export type { BuilderMerge, BuilderGeneric, BuilderModelOf, Builders, BuilderState, BuilderStateEmpty, BuilderStateOf } from './builder';
+export type { BuilderValidated, BuilderValidateError, BuilderValidateErrors, BuilderValidateErrorUnboundParameter, BuilderValidateErrorUnmetExpectation, BuilderValidateOptions, BuilderValidateResult } from './validate';
 export { Builder, builder } from './builder.js';
 export { BuilderCollection, collection, resolveCollectionModels, resolveCollectionNames } from './collection/index.js';
 export { BuilderComponent, BuilderComponentGraph } from './component/index.js';
 export { BuilderExpectation, has } from './expectation.js';
 export { BuilderOption, BuilderOptionGraph, select, BuilderSelectType, BuilderToggleType, toggleBoolean, toggleNumber, toggleString, enable, match, unless } from './option/index.js';
 export { BuilderParameter, BuilderParameterSchema } from './parameter.js';
+export { BuilderValidateException } from './validate.js';

package/dist/core/index.js

@@ -4,3 +4,4 @@ export { BuilderComponent, BuilderComponentGraph } from './component/index.js';
 export { BuilderExpectation, has } from './expectation.js';
 export { BuilderOption, BuilderOptionGraph, select, BuilderSelectType, BuilderToggleType, toggleBoolean, toggleNumber, toggleString, enable, match, unless } from './option/index.js';
 export { BuilderParameter, BuilderParameterSchema } from './parameter.js';
+export { BuilderValidateException } from './validate.js';

package/dist/core/option/index.d.ts

@@ -2,6 +2,7 @@ export type { BuilderOptionEnableConfig, BuilderOptionMatchConfig, BuilderOption
 export type { BuilderOptionGraphs } from './graph';
 export type { BuilderOptionEntries, BuilderOptionValues, BuilderOptionValuesMap, BuilderSelectTypeGeneric, BuilderToggleTypeGeneric, BuilderOptionValueSchema } from './option';
 export type { BuilderSelectTypeLabels, BuilderSelectTypeValues } from './select';
+export type { BuilderToggleValueType } from './toggle';
 export { enable, match, unless } from './method.js';
 export { BuilderOptionGraph } from './graph.js';
 export { BuilderOption } from './option.js';

package/dist/core/option/toggle.d.ts

@@ -1,11 +1,13 @@
 import type { BuilderOptionValueSchema } from './option';
 import * as v from 'valibot';
+export type BuilderToggleValueType = 'string' | 'boolean' | 'number';
 export declare class BuilderToggleType<const ValueSchema extends BuilderOptionValueSchema = BuilderOptionValueSchema> {
     readonly value: v.InferOutput<ValueSchema>;
+    readonly valueType: BuilderToggleValueType;
     readonly valueSchema: ValueSchema;
     readonly defaultValue: v.InferOutput<ValueSchema>;
     readonly isOptional: boolean;
-    constructor(valueSchema: ValueSchema, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean);
+    constructor(valueType: BuilderToggleValueType, valueSchema: ValueSchema, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean);
     default(newDefault: v.InferOutput<ValueSchema>): BuilderToggleType<ValueSchema>;
     optional(): BuilderToggleType<v.NullableSchema<ValueSchema, undefined>>;
 }

package/dist/core/option/toggle.js

@@ -1,27 +1,29 @@
 import * as v from 'valibot';
 export class BuilderToggleType {
+    valueType;
     valueSchema;
     defaultValue;
     isOptional;
-    constructor(valueSchema, defaultValue, optional) {
+    constructor(valueType, valueSchema, defaultValue, optional) {
+        this.valueType = valueType;
         this.valueSchema = valueSchema;
         this.defaultValue = defaultValue;
         this.isOptional = optional || false;
     }
     default(newDefault) {
-        return new BuilderToggleType(this.valueSchema, newDefault, this.isOptional);
+        return new BuilderToggleType(this.valueType, this.valueSchema, newDefault, this.isOptional);
     }
     optional() {
-        const { valueSchema, defaultValue } = this;
-        return new BuilderToggleType(v.nullable(valueSchema), defaultValue, true);
+        const { valueType, valueSchema, defaultValue } = this;
+        return new BuilderToggleType(valueType, v.nullable(valueSchema), defaultValue, true);
     }
 }
 export function toggleString() {
-    return new BuilderToggleType(v.string(), '');
+    return new BuilderToggleType('string', v.string(), '');
 }
 export function toggleBoolean() {
-    return new BuilderToggleType(v.boolean(), false);
+    return new BuilderToggleType('boolean', v.boolean(), false);
 }
 export function toggleNumber() {
-    return new BuilderToggleType(v.number(), 0);
+    return new BuilderToggleType('number', v.number(), 0);
 }

package/dist/core/validate.d.ts

@@ -0,0 +1,26 @@
+import type { BuilderGeneric } from './builder';
+declare const validated: unique symbol;
+export type BuilderValidated = BuilderGeneric & {
+    readonly [validated]: true;
+};
+export type BuilderValidateErrorUnmetExpectation = {
+    readonly kind: 'unmet-expectation';
+    readonly expectationKind: 'option' | 'component' | 'collection';
+    readonly name: string;
+};
+export type BuilderValidateErrorUnboundParameter = {
+    readonly kind: 'unbound-parameter';
+    readonly name: string;
+};
+export type BuilderValidateError = BuilderValidateErrorUnmetExpectation | BuilderValidateErrorUnboundParameter;
+export type BuilderValidateErrors = ReadonlyArray<BuilderValidateError>;
+export type BuilderValidateResult = readonly [BuilderValidated, BuilderValidateErrors];
+export type BuilderValidateOptions = {
+    readonly strict: true;
+};
+export declare class BuilderValidateException extends Error {
+    readonly errors: BuilderValidateErrors;
+    constructor(errors: BuilderValidateErrors);
+}
+export declare function validateBuilder(builder: BuilderGeneric, options?: BuilderValidateOptions): BuilderValidateResult;
+export {};

package/dist/core/validate.js

@@ -0,0 +1,43 @@
+import * as v from 'valibot';
+import { BuilderParameterSchema } from './parameter.js';
+export class BuilderValidateException extends Error {
+    errors;
+    constructor(errors) {
+        super('builder validation failed');
+        this.errors = errors;
+    }
+}
+export function validateBuilder(builder, options) {
+    const expectationErrors = validateExpectations(builder.expectations, builder);
+    const parameterErrors = validateParameters(builder.options);
+    const errors = [...expectationErrors, ...parameterErrors];
+    if (options?.strict && errors.length > 0) {
+        throw new BuilderValidateException(errors);
+    }
+    return [builder, errors];
+}
+function validateExpectations(expectations, entries) {
+    return expectations.flatMap((expectation) => {
+        const lookup = expectation.kind === 'option'
+            ? entries.options
+            : expectation.kind === 'component'
+                ? entries.components
+                : entries.collections;
+        const exists = lookup.some((entry) => entry.name === expectation.name);
+        if (exists) {
+            return [];
+        }
+        return [
+            {
+                kind: 'unmet-expectation',
+                expectationKind: expectation.kind,
+                name: expectation.name
+            }
+        ];
+    });
+}
+function validateParameters(options) {
+    return options
+        .filter((option) => v.is(BuilderParameterSchema, option.values))
+        .map((option) => ({ kind: 'unbound-parameter', name: option.name }));
+}

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 export type { BuilderData, BuilderModel, BuilderModels, BuilderPrimitive, BuilderPrimitives, BuilderVariant, BuilderVariants } from './model';
-export type { Builder, Builders, BuilderCollectionEntries, BuilderComponentEntries, BuilderGeneric, BuilderModelOf, BuilderOptionEntries } from './core/index';
+export type { Builder, Builders, BuilderCollectionEntries, BuilderComponentEntries, BuilderGeneric, BuilderModelOf, BuilderOptionEntries, BuilderValidated, BuilderValidateError, BuilderValidateErrors, BuilderValidateErrorUnboundParameter, BuilderValidateErrorUnmetExpectation, BuilderValidateOptions, BuilderValidateResult } from './core/index';
 export type { BuilderModelPaths, BuilderResolvePath, BuilderValidPath } from './paths';
 export type { BuilderPath, BuilderPaths } from './schemas/index';
-export type { BuilderDataValidated, BuilderDescription, BuilderDescriptionItem, BuilderErrorComponentMissing, BuilderErrorComponentUnexpected, BuilderErrorsValidate, BuilderErrorValidate, BuilderErrorVariantInvalid, BuilderErrorVariantMissing, BuilderOrder, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderValidateResult } from './resolve/index';
+export type { BuilderDataValidated, BuilderDataError, BuilderDataErrors, BuilderDataErrorComponentMissing, BuilderDataErrorComponentUnexpected, BuilderDataErrorVariantInvalid, BuilderDataErrorVariantMissing, BuilderDataValidateResult, BuilderDescription, BuilderDescriptionItem, BuilderModelValidated, BuilderModelValidateError, BuilderModelValidateErrors, BuilderModelValidateErrorInvalidCollection, BuilderModelValidateErrorInvalidOption, BuilderModelValidateOptions, BuilderModelValidateResult, BuilderOrder, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } from './resolve/index';
 export type { BuilderUICollection, BuilderUIDescribe, BuilderUIItem, BuilderUIItems, BuilderUIPage } from './schemas/index';
 export type { BuilderUI, BuilderUIs } from './ui';
-export type { BuilderCollectionSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderOptionSerialised, BuilderOptionWhenConfigSerialised, BuilderParameterSerialised, BuilderSelectTypeSerialised, BuilderSerialised, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderValuesSerialised } from './serialise/index';
-export { BuilderExpectation, has } from './core/index.js';
+export type { BuilderCollectionSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderOptionSerialised, BuilderOptionWhenConfigSerialised, BuilderParameterSerialised, BuilderSelectTypeSerialised, BuilderSerialised, BuilderSerialisedValidated, BuilderSerialisedError, BuilderSerialisedErrors, BuilderSerialisedValidateOptions, BuilderSerialisedValidateResult, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderValuesSerialised } from './serialise/index';
+export { BuilderExpectation, BuilderValidateException, has } from './core/index.js';
 export { builder, BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderSelectType, BuilderToggleType, collection, enable, match, select, toggleBoolean, toggleNumber, toggleString, unless } from './core/index.js';
-export { instance, models, order, ordinal, render, validate } from './resolve/index.js';
-export { deserialise, serialise } from './serialise/index.js';
+export { instance, BuilderModelValidateException, models, order, ordinal, render, validate, BuilderDataValidateError } from './resolve/index.js';
+export { BuilderSerialisedValidateError, deserialise, serialise } from './serialise/index.js';
 export { ui } from './ui.js';

package/dist/index.js

@@ -1,5 +1,5 @@
-export { BuilderExpectation, has } from './core/index.js';
+export { BuilderExpectation, BuilderValidateException, has } from './core/index.js';
 export { builder, BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderSelectType, BuilderToggleType, collection, enable, match, select, toggleBoolean, toggleNumber, toggleString, unless } from './core/index.js';
-export { instance, models, order, ordinal, render, validate } from './resolve/index.js';
-export { deserialise, serialise } from './serialise/index.js';
+export { instance, BuilderModelValidateException, models, order, ordinal, render, validate, BuilderDataValidateError } from './resolve/index.js';
+export { BuilderSerialisedValidateError, deserialise, serialise } from './serialise/index.js';
 export { ui } from './ui.js';

package/dist/resolve/index.d.ts

@@ -1,9 +1,10 @@
 export type { BuilderOrder } from './order';
 export type { BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } from './render';
-export type { BuilderDataValidated, BuilderErrorVariantInvalid, BuilderErrorComponentMissing, BuilderErrorVariantMissing, BuilderErrorComponentUnexpected, BuilderErrorValidate, BuilderErrorsValidate, BuilderValidateResult } from './validate';
+export type { BuilderDataValidated, BuilderDataError, BuilderDataErrors, BuilderDataErrorComponentMissing, BuilderDataErrorComponentUnexpected, BuilderDataErrorVariantInvalid, BuilderDataErrorVariantMissing, BuilderDataValidateResult } from './validate';
+export type { BuilderModelValidated, BuilderModelValidateError, BuilderModelValidateErrors, BuilderModelValidateErrorInvalidCollection, BuilderModelValidateErrorInvalidOption, BuilderModelValidateOptions, BuilderModelValidateResult } from './instance';
 export type { BuilderDescription, BuilderDescriptionItem } from '../schemas/index';
-export { instance } from './instance.js';
+export { instance, BuilderModelValidateException } from './instance.js';
 export { models } from './models.js';
 export { order } from './order.js';
 export { ordinal, render } from './render.js';
-export { validate } from './validate.js';
+export { validate, BuilderDataValidateError } from './validate.js';

package/dist/resolve/index.js

@@ -1,5 +1,5 @@
-export { instance } from './instance.js';
+export { instance, BuilderModelValidateException } from './instance.js';
 export { models } from './models.js';
 export { order } from './order.js';
 export { ordinal, render } from './render.js';
-export { validate } from './validate.js';
+export { validate, BuilderDataValidateError } from './validate.js';

package/dist/resolve/instance.d.ts

@@ -1,3 +1,35 @@
 import type { BuilderGeneric, BuilderModelOf } from '../core/index';
-import type { BuilderModelInput } from '../model';
-export declare function instance<const Builder extends BuilderGeneric>(builder: Builder, partial?: BuilderModelInput): BuilderModelOf<Builder>;
+import type { BuilderModel, BuilderModelInput } from '../model';
+declare const modelValidated: unique symbol;
+export type BuilderModelValidated = BuilderModel & {
+    readonly [modelValidated]: true;
+};
+export type BuilderModelValidateErrorInvalidOption = {
+    readonly kind: 'invalid-option';
+    readonly name: string;
+    readonly value: unknown;
+};
+export type BuilderModelValidateErrorInvalidCollection = {
+    readonly kind: 'invalid-collection';
+    readonly name: string;
+    readonly detail: string;
+};
+export type BuilderModelValidateError = BuilderModelValidateErrorInvalidOption | BuilderModelValidateErrorInvalidCollection;
+export type BuilderModelValidateErrors = ReadonlyArray<BuilderModelValidateError>;
+export type BuilderModelValidateResult = readonly [
+    BuilderModelValidated,
+    BuilderModelValidateErrors
+];
+export type BuilderModelValidateOptions = {
+    readonly strict: true;
+};
+export declare class BuilderModelValidateException extends Error {
+    readonly errors: BuilderModelValidateErrors;
+    constructor(errors: BuilderModelValidateErrors);
+}
+export declare function validateInstance(builder: BuilderGeneric, model: BuilderModel, options?: BuilderModelValidateOptions): BuilderModelValidateResult;
+export declare const instance: typeof createInstance & {
+    validate: typeof validateInstance;
+};
+declare function createInstance<const Builder extends BuilderGeneric>(builder: Builder, partial?: BuilderModelInput): BuilderModelOf<Builder> & BuilderModelValidated;
+export {};

package/dist/resolve/instance.js

@@ -1,6 +1,60 @@
 import * as v from 'valibot';
 import { resolveCollectionModels } from '../core/index.js';
-export function instance(builder, partial = {}) {
+export class BuilderModelValidateException extends Error {
+    errors;
+    constructor(errors) {
+        super('model validation failed');
+        this.errors = errors;
+    }
+}
+export function validateInstance(builder, model, options) {
+    const errors = validateModel(builder, model);
+    if (options?.strict && errors.length > 0) {
+        throw new BuilderModelValidateException(errors);
+    }
+    return [model, errors];
+}
+export const instance = Object.assign(createInstance, { validate: validateInstance });
+function validateModel(builder, model) {
+    let errors = [];
+    builder.options.forEach((entry) => {
+        const option = entry.resolve(model);
+        if (!option) {
+            return;
+        }
+        const value = model[option.name];
+        if (!v.is(option.values.valueSchema, value)) {
+            errors = [...errors, { kind: 'invalid-option', name: option.name, value }];
+        }
+    });
+    builder.collections.forEach((entry) => {
+        const collection = entry.resolve(model);
+        if (!collection) {
+            return;
+        }
+        const existing = model[collection.name];
+        if (!Array.isArray(existing)) {
+            errors = [
+                ...errors,
+                { kind: 'invalid-collection', name: collection.name, detail: 'expected an array' }
+            ];
+            return;
+        }
+        const collectionModels = resolveCollectionModels(model, collection.name);
+        collectionModels.forEach((itemModel, index) => {
+            const nestedErrors = validateModel(collection.builder, itemModel);
+            errors = [
+                ...errors,
+                ...nestedErrors.map((error) => ({
+                    ...error,
+                    name: `${collection.name}[${String(index)}].${error.name}`
+                }))
+            ];
+        });
+    });
+    return errors;
+}
+function createInstance(builder, partial = {}) {
     const model = partial;
     builder.options.forEach((entry) => {
         const option = entry.resolve(model);
@@ -20,7 +74,7 @@ export function instance(builder, partial = {}) {
         const collectionModels = existing != null ? resolveCollectionModels(model, collection.name) : [];
         model[collection.name] = Array.from({
             length: Math.max(collectionModels.length, collection.min)
-        }).map((_, index) => instance(collection.builder, collectionModels[index] || {}));
+        }).map((_, index) => createInstance(collection.builder, collectionModels[index] || {}));
     });
     return model;
 }

package/dist/resolve/models.d.ts

@@ -1,3 +1,3 @@
 import type { BuilderData } from '../model';
-import type { BuilderGeneric } from '../core/index';
-export declare function models(builder: BuilderGeneric): BuilderData;
+import type { BuilderValidated } from '../core/validate';
+export declare function models(builder: BuilderValidated): BuilderData;

package/dist/resolve/models.js

@@ -1,6 +1,9 @@
 export function models(builder) {
+    return modelsRecursive(builder);
+}
+function modelsRecursive(builder) {
     const collectionModels = builder.collections.flatMap((entry) => {
-        return [models(entry.builder)];
+        return collectionBuilders(entry).map((collectionBuilder) => modelsRecursive(collectionBuilder));
     });
     const wrapped = Object.fromEntries(builder.componentGraph.paths.map((path) => [path.name, path.models.map((model) => ({ model }))]));
     return {
@@ -8,3 +11,10 @@ export function models(builder) {
         ...wrapped
     };
 }
+function collectionBuilders(entry) {
+    if (entry.config?.type === 'match') {
+        const selectMap = entry.config.selectMap;
+        return Object.values(selectMap).flatMap((value) => (value ? [value.builder] : []));
+    }
+    return [entry.builder];
+}

package/dist/resolve/order.d.ts

@@ -1,13 +1,15 @@
 import type { Prettify } from '../prettify';
-import type { BuilderModel, BuilderVariant } from '../model';
+import type { BuilderVariant } from '../model';
 import type { CollectionShape } from '../core/collection/index';
 import type { BuilderCollection, BuilderCollectionEntries, BuilderComponentEntries, BuilderComponentNamesOf, BuilderGeneric } from '../core/index';
+import type { BuilderValidated } from '../core/validate';
+import type { BuilderModelValidated } from './instance';
 import type { BuilderDataValidated } from './validate';
 export type BuilderOrder<Builder extends BuilderGeneric> = Builder extends {
     readonly _components: infer Components extends BuilderComponentEntries;
     readonly _collections: infer Collections extends BuilderCollectionEntries;
 } ? Prettify<ComponentsOrder<Components> & CollectionsOrder<Collections>> : Record<string, unknown>;
-export declare function order<const Builder extends BuilderGeneric>(builder: Builder, model: BuilderModel, componentModels: BuilderDataValidated): BuilderOrder<Builder>;
+export declare function order<const Builder extends BuilderGeneric>(builder: Builder & BuilderValidated, model: BuilderModelValidated, componentModels: BuilderDataValidated): BuilderOrder<Builder>;
 type ComponentsOrder<Components extends BuilderComponentEntries> = {
     readonly [Name in BuilderComponentNamesOf<Components>]: BuilderVariant | null;
 };

package/dist/resolve/order.js

@@ -1,6 +1,6 @@
 import { resolveCollectionModels } from '../core/index.js';
 import { check } from '../check.js';
-export function order(builder, model, componentModels) {
+function orderInternal(builder, model, componentModels) {
     const result = {};
     const resolved = new Set();
     builder.components.forEach((component) => {
@@ -18,7 +18,10 @@ export function order(builder, model, componentModels) {
             return;
         }
         const itemModels = resolveCollectionModels(model, collection.name);
-        result[collection.name] = itemModels.map((itemModel) => order(collection.builder, itemModel, componentModels));
+        result[collection.name] = itemModels.map((itemModel) => orderInternal(collection.builder, itemModel, componentModels));
     });
     return result;
 }
+export function order(builder, model, componentModels) {
+    return orderInternal(builder, model, componentModels);
+}

package/dist/resolve/render.d.ts

@@ -1,5 +1,7 @@
-import type { BuilderGeneric, BuilderOption } from '../core/index';
+import type { BuilderOption } from '../core/index';
+import type { BuilderValidated } from '../core/validate';
 import type { BuilderModel } from '../model';
+import type { BuilderModelValidated } from './instance';
 import type { BuilderDescription, BuilderUIItems, BuilderPrimitive } from '../schemas/index';
 import { BuilderUI } from '../ui.js';
 export type BuilderRenderOption = {
@@ -17,5 +19,5 @@ export type BuilderRenderResult = {
     readonly layout: BuilderRenderPages;
     readonly description: BuilderDescription;
 };
-export declare function render(rootBuilder: BuilderGeneric, rootModel: BuilderModel, input: BuilderUI | BuilderUIItems): BuilderRenderResult;
+export declare function render(rootBuilder: BuilderValidated, rootModel: BuilderModelValidated, input: BuilderUI | BuilderUIItems): BuilderRenderResult;
 export declare function ordinal(index: number): string;