@builder-builder/builder 0.0.9 → 0.0.11

package/dist/validate/model.js

@@ -0,0 +1,196 @@
+import { check } from '../check.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema, model, modelsMerge, serialise } from '../entities/index.js';
+import { builderError } from '../exception.js';
+import { validate } from './brand.js';
+import { checkExpectations } from './expectations.js';
+import { resolver } from './resolve.js';
+import { builderErrorInvalidInput } from './result.js';
+export function builderErrorDuplicateName(name, location = []) {
+    return { ...builderError('duplicate-name', location), name };
+}
+export function builderErrorInvalidCollectionBounds(name, min, max, location = []) {
+    return { ...builderError('invalid-collection-bounds', location), name, min, max };
+}
+export function builderErrorInvalidPath(reason, location = []) {
+    return { ...builderError('invalid-path', location), reason };
+}
+export function builderErrorInvalidSelectMapKey(key, location = []) {
+    return { ...builderError('invalid-select-map-key', location), key };
+}
+const EMPTY_MODEL = validate(serialise.model(model()));
+export function validateModel(input, references = []) {
+    if (!check.is(BuilderModelSerialisedSchema, input)) {
+        return [EMPTY_MODEL, [builderErrorInvalidInput('model')]];
+    }
+    const resolve = resolver(references);
+    const [structure, structureErrors] = validateModelStructure(input, resolve, []);
+    const data = validate(modelsMerge(structure));
+    const expectationErrors = checkModelExpectations(data, structure, []);
+    return [data, [...expectationErrors, ...structureErrors]];
+}
+export function checkModelExpectations(mergedModel, model, location) {
+    return [
+        ...checkExpectations(mergedModel, model.expectations, [...location, 'expectations']),
+        ...model.models.flatMap((nested, nestedIndex) => checkModelExpectations(mergedModel, nested, [
+            ...location,
+            'models',
+            nestedIndex
+        ]))
+    ];
+}
+export function validateModelStructure(input, resolve, location) {
+    const [resolved, resolveErrors] = resolve(input, location);
+    if (!check.is(BuilderModelSerialisedSchema, resolved)) {
+        return [validate(serialise.model(model())), resolveErrors];
+    }
+    const errors = [...resolveErrors];
+    const modelInput = resolved;
+    const childModels = modelInput.models.flatMap((part, partIndex) => {
+        const partLocation = [...location, 'models', partIndex];
+        const [child, childErrors] = validateModelStructure(part, resolve, partLocation);
+        errors.push(...childErrors);
+        return [child];
+    });
+    const [options, optionErrors] = walkEntries(modelInput.options, 'option', resolve, location);
+    const [components, componentErrors] = walkEntries(modelInput.components, 'component', resolve, location);
+    const [collections, collectionErrors] = walkEntries(modelInput.collections, 'collection', resolve, location);
+    errors.push(...optionErrors, ...componentErrors, ...collectionErrors);
+    const skipPathValidation = modelInput.expectations.length > 0;
+    const checkPaths = (entry, entryLocation) => (skipPathValidation ? [] : checkEntryPaths(modelInput, entry, entryLocation));
+    options.forEach((entry, entryIndex) => errors.push(...checkPaths(entry, [...location, 'options', entryIndex])));
+    components.forEach((entry, entryIndex) => errors.push(...checkPaths(entry, [...location, 'components', entryIndex])));
+    collections.forEach((entry, entryIndex) => {
+        const collectionLocation = [...location, 'collections', entryIndex];
+        errors.push(...checkPaths(entry, collectionLocation), ...checkCollectionBounds(entry, collectionLocation));
+        collectionNestedModels(entry, collectionLocation).forEach(([nested, nestedLocation]) => {
+            const [, nestedErrors] = validateModelStructure(nested, resolve, nestedLocation);
+            errors.push(...nestedErrors);
+        });
+    });
+    const data = {
+        ...modelInput,
+        models: childModels,
+        options,
+        components,
+        collections
+    };
+    return [data, errors];
+}
+function walkEntries(entries, entryKind, resolve, location) {
+    const seen = new Set();
+    const items = [];
+    const errors = [];
+    const arrayKey = `${entryKind}s`;
+    entries.forEach((entry, entryIndex) => {
+        const entryLocation = [...location, arrayKey, entryIndex];
+        let paths = entry.paths;
+        if (entry.paths != null) {
+            const [resolvedPaths, pathErrors] = resolve(entry.paths, [...entryLocation, 'paths']);
+            paths = resolvedPaths ?? entry.paths;
+            errors.push(...pathErrors);
+        }
+        const [payload, payloadErrors] = resolve(entry.payload, [...entryLocation, 'payload']);
+        errors.push(...payloadErrors);
+        const resolved = { ...entry, paths, payload: payload ?? entry.payload };
+        if (seen.has(resolved.name)) {
+            errors.push(builderErrorDuplicateName(resolved.name, entryLocation));
+            return;
+        }
+        seen.add(resolved.name);
+        items.push(resolved);
+    });
+    return [items, errors];
+}
+function checkEntryPaths(modelInput, entry, location) {
+    const { name, paths, payload } = entry;
+    const directPaths = Array.isArray(paths)
+        ? paths.map((path, pathIndex) => [path, [...location, 'paths', pathIndex]])
+        : [];
+    const extractWhenPathsList = extractWhenPaths(payload, location);
+    return [...directPaths, ...extractWhenPathsList].flatMap(([path, pathLocation]) => {
+        const [reached, walkErrors] = walkPath([modelInput], path.slice(0, -1), name, path, pathLocation);
+        if (walkErrors.length > 0) {
+            return walkErrors;
+        }
+        const optionName = path.at(-1);
+        if (!reached.some((candidate) => candidate.options.some((option) => option.name === optionName))) {
+            return [builderErrorInvalidPath('option-not-found', pathLocation)];
+        }
+        return [];
+    });
+}
+function checkCollectionBounds(collection, location) {
+    return collectionConfigs(collection, location).flatMap(([{ min, max }]) => {
+        if (typeof min !== 'number' || typeof max !== 'number') {
+            return [];
+        }
+        if (min < 0 || max <= 0 || max < min) {
+            return [builderErrorInvalidCollectionBounds(collection.name, min, max, location)];
+        }
+        return [];
+    });
+}
+function collectionNestedModels(collection, location) {
+    return collectionConfigs(collection, location).flatMap(([config, configLocation]) => check.is(BuilderModelSerialisedSchema, config.model)
+        ? [[config.model, [...configLocation, 'model']]]
+        : []);
+}
+function collectionConfigs(collection, location) {
+    const { payload } = collection;
+    const payloadLocation = [...location, 'payload'];
+    if (check.is(BuilderCollectionConfigSerialisedSchema, payload)) {
+        return [[payload, payloadLocation]];
+    }
+    if (!check.is(BuilderWhenSerialisedSchema, payload)) {
+        return [];
+    }
+    if (payload.type === 'match') {
+        return Object.entries(payload.selectMap).flatMap(([key, value]) => check.is(BuilderCollectionConfigSerialisedSchema, value)
+            ? [[value, [...payloadLocation, 'selectMap', key]]]
+            : []);
+    }
+    return check.is(BuilderCollectionConfigSerialisedSchema, payload.payload)
+        ? [[payload.payload, [...payloadLocation, 'payload']]]
+        : [];
+}
+function extractWhenPaths(payload, location) {
+    if (!check.is(BuilderWhenSerialisedSchema, payload)) {
+        return [];
+    }
+    if (payload.type === 'match' && Array.isArray(payload.matchPath)) {
+        return [[payload.matchPath, [...location, 'payload', 'matchPath']]];
+    }
+    if (payload.type === 'unless' && Array.isArray(payload.unlessPath)) {
+        return [[payload.unlessPath, [...location, 'payload', 'unlessPath']]];
+    }
+    return [];
+}
+function walkPath(candidates, remaining, entryName, fullPath, location) {
+    if (remaining.length === 0) {
+        return [candidates, []];
+    }
+    const [collectionName, indexValue, ...rest] = remaining;
+    if (typeof collectionName !== 'string' || typeof indexValue !== 'number') {
+        return [[], [builderErrorInvalidPath('shape', location)]];
+    }
+    const [next, anyOutOfBounds] = candidates.reduce(([accumulator, anyOutOfBoundsAccumulator], current) => {
+        const collection = current.collections.find(({ name }) => name === collectionName);
+        if (collection == null) {
+            return [accumulator, anyOutOfBoundsAccumulator];
+        }
+        const configs = collectionConfigs(collection, []);
+        const withinBounds = configs.filter(([{ max }]) => typeof max !== 'number' || indexValue < max);
+        if (withinBounds.length === 0 && configs.length > 0) {
+            return [accumulator, true];
+        }
+        const reached = withinBounds.flatMap(([{ model: configModel }]) => check.is(BuilderModelSerialisedSchema, configModel) ? [configModel] : []);
+        return [[...accumulator, ...reached], anyOutOfBoundsAccumulator];
+    }, [[], false]);
+    if (anyOutOfBounds) {
+        return [[], [builderErrorInvalidPath('out-of-bounds', location)]];
+    }
+    if (next.length === 0) {
+        return [[], [builderErrorInvalidPath('missing-collection', location)]];
+    }
+    return walkPath(next, rest, entryName, fullPath, location);
+}

package/dist/validate/resolve.d.ts

@@ -0,0 +1,16 @@
+import type { BuilderBindings, BuilderRefEntities } from '../entities/index';
+import type { BuilderErrorLocation, BuilderErrors } from '../exception';
+export declare function builderErrorUnboundParameter(name: string, location?: BuilderErrorLocation): {
+    name: string;
+    kind: "unbound-parameter";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorUnboundParameter = ReturnType<typeof builderErrorUnboundParameter>;
+export declare function builderErrorMissingReference(id: string, location?: BuilderErrorLocation): {
+    id: string;
+    kind: "missing-reference";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorMissingReference = ReturnType<typeof builderErrorMissingReference>;
+export type BuilderResolve = (value: unknown, location: BuilderErrorLocation) => readonly [unknown, BuilderErrors];
+export declare function resolver(references?: BuilderRefEntities, bindings?: BuilderBindings): BuilderResolve;

package/dist/validate/resolve.js

@@ -0,0 +1,91 @@
+import { check } from '../check.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
+import { builderError } from '../exception.js';
+import { BuilderParameterSerialisedSchema, BuilderRefSerialisedSchema } from '../references.js';
+export function builderErrorUnboundParameter(name, location = []) {
+    return { ...builderError('unbound-parameter', location), name };
+}
+export function builderErrorMissingReference(id, location = []) {
+    return { ...builderError('missing-reference', location), id };
+}
+export function resolver(references = [], bindings = {}) {
+    function resolve(value, location) {
+        if (check.is(BuilderParameterSerialisedSchema, value)) {
+            return resolveParameter(value, location);
+        }
+        if (check.is(BuilderRefSerialisedSchema, value)) {
+            return resolveReference(value, location);
+        }
+        if (check.is(BuilderWhenSerialisedSchema, value)) {
+            return resolveWhen(value, location);
+        }
+        if (check.is(BuilderCollectionConfigSerialisedSchema, value)) {
+            return resolveCollectionConfig(value, location);
+        }
+        return [value, []];
+    }
+    function resolveReference(reference, location) {
+        const found = references.find((entry) => entry.id === reference.id);
+        if (found == null) {
+            return [reference, [builderErrorMissingReference(reference.id, location)]];
+        }
+        return [reference, []];
+    }
+    function resolveParameter(parameter, location) {
+        if (!(parameter.name in bindings)) {
+            return [null, [builderErrorUnboundParameter(parameter.name, location)]];
+        }
+        const binding = bindings[parameter.name];
+        if (!check.is(BuilderRefSerialisedSchema, binding)) {
+            return [binding, []];
+        }
+        const refTarget = references.find((entry) => entry.id === binding.id);
+        const errors = refTarget == null ? [builderErrorMissingReference(binding.id, location)] : [];
+        return [binding, errors];
+    }
+    function resolveWhen(when, location) {
+        if (when.type === 'enable') {
+            const [payload, errors] = resolve(when.payload, [...location, 'payload']);
+            return [{ ...when, payload: payload ?? when.payload }, errors];
+        }
+        if (when.type === 'unless') {
+            const [unlessPath, unlessErrors] = resolve(when.unlessPath, [...location, 'unlessPath']);
+            const [payload, payloadErrors] = resolve(when.payload, [...location, 'payload']);
+            return [
+                { ...when, unlessPath: unlessPath ?? when.unlessPath, payload: payload ?? when.payload },
+                [...unlessErrors, ...payloadErrors]
+            ];
+        }
+        const [matchPath, matchErrors] = resolve(when.matchPath, [...location, 'matchPath']);
+        const [map, mapErrors] = resolve(when.selectMap, [...location, 'selectMap']);
+        if (map == null || typeof map !== 'object') {
+            return [{ ...when, matchPath: matchPath ?? when.matchPath }, [...matchErrors, ...mapErrors]];
+        }
+        const [selectMap, entryErrors] = Object.entries(map).reduce(([values, errors], [key, entryValue]) => {
+            if (entryValue == null) {
+                return [{ ...values, [key]: null }, errors];
+            }
+            const [resolved, resolvedErrors] = resolve(entryValue, [...location, 'selectMap', key]);
+            return [{ ...values, [key]: resolved ?? entryValue }, [...errors, ...resolvedErrors]];
+        }, [{}, []]);
+        return [
+            { ...when, matchPath: matchPath ?? when.matchPath, selectMap },
+            [...matchErrors, ...mapErrors, ...entryErrors]
+        ];
+    }
+    function resolveCollectionConfig(config, location) {
+        const [model, modelErrors] = resolve(config.model, [...location, 'model']);
+        const [min, minErrors] = resolve(config.min, [...location, 'min']);
+        const [max, maxErrors] = resolve(config.max, [...location, 'max']);
+        return [
+            {
+                ...config,
+                model: model ?? config.model,
+                min: min ?? config.min,
+                max: max ?? config.max
+            },
+            [...modelErrors, ...minErrors, ...maxErrors]
+        ];
+    }
+    return resolve;
+}

package/dist/validate/result.d.ts

@@ -0,0 +1,8 @@
+import type { BuilderErrorLocation, BuilderErrors } from '../exception';
+export type ValidationResult<Entity> = readonly [Entity, BuilderErrors];
+export declare function builderErrorInvalidInput(target: 'builder' | 'model' | 'ui' | 'variants', location?: BuilderErrorLocation): {
+    target: "builder" | "model" | "ui" | "variants";
+    kind: "invalid-input";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidInput = ReturnType<typeof builderErrorInvalidInput>;

package/dist/validate/result.js

@@ -0,0 +1,4 @@
+import { builderError } from '../exception.js';
+export function builderErrorInvalidInput(target, location = []) {
+    return { ...builderError('invalid-input', location), target };
+}

package/dist/validate/ui.d.ts

@@ -0,0 +1,8 @@
+import type { BuilderModelSerialised, BuilderRefEntities, BuilderUISerialised, BuilderUIValidated } from '../entities/index';
+import type { BuilderErrorLocation, BuilderErrors } from '../exception';
+import type { BuilderResolve } from './resolve';
+import type { ValidationResult } from './result';
+export type BuilderUIValidationResult = ValidationResult<BuilderUIValidated>;
+export declare function validateUI(input: unknown, references?: BuilderRefEntities): BuilderUIValidationResult;
+export declare function validateUIStructure(ui: BuilderUISerialised, resolve: BuilderResolve, location: BuilderErrorLocation): readonly [BuilderUIValidated, BuilderErrors];
+export declare function checkUIExpectations(mergedModel: BuilderModelSerialised, ui: BuilderUIValidated, location: BuilderErrorLocation): BuilderErrors;

package/dist/validate/ui.js

@@ -0,0 +1,77 @@
+import { check } from '../check.js';
+import { BuilderUISerialisedSchema, serialise, uis } from '../entities/index.js';
+import { validate } from './brand.js';
+import { checkExpectations } from './expectations.js';
+import { resolver } from './resolve.js';
+import { builderErrorInvalidInput } from './result.js';
+export function validateUI(input, references = []) {
+    if (!check.is(BuilderUISerialisedSchema, input)) {
+        const errors = [builderErrorInvalidInput('ui')];
+        return [validate(serialise.ui(uis())), errors];
+    }
+    const resolve = resolver(references);
+    const [structure, errors] = validateUIStructure(input, resolve, []);
+    return [validate(structure), errors];
+}
+export function validateUIStructure(ui, resolve, location) {
+    const errors = [];
+    const childUIs = ui.uis.flatMap((part, partIndex) => {
+        const partLocation = [...location, 'uis', partIndex];
+        const [resolved, partErrors] = resolve(part, partLocation);
+        errors.push(...partErrors);
+        if (resolved == null || !check.is(BuilderUISerialisedSchema, resolved)) {
+            return [];
+        }
+        const [child, childErrors] = validateUIStructure(resolved, resolve, partLocation);
+        errors.push(...childErrors);
+        return [child];
+    });
+    const [items, itemErrors] = walkItems(ui.items, resolve, [...location, 'items']);
+    errors.push(...itemErrors);
+    const data = {
+        ...ui,
+        uis: childUIs,
+        items
+    };
+    return [data, errors];
+}
+export function checkUIExpectations(mergedModel, ui, location) {
+    return [
+        ...checkExpectations(mergedModel, ui.expectations, [...location, 'expectations']),
+        ...ui.uis.flatMap((nested, nestedIndex) => checkUIExpectations(mergedModel, nested, [
+            ...location,
+            'uis',
+            nestedIndex
+        ]))
+    ];
+}
+function walkItems(items, resolve, location) {
+    const errors = [];
+    const result = items.map((item, itemIndex) => {
+        const itemLocation = [...location, itemIndex];
+        const [resolved, resolveErrors] = resolve(item, itemLocation);
+        errors.push(...resolveErrors);
+        const [walked, walkErrors] = walkUIItem((resolved ?? item), resolve, itemLocation);
+        errors.push(...walkErrors);
+        return walked;
+    });
+    return [result, errors];
+}
+function walkUIItem(item, resolve, location) {
+    const errors = [];
+    const [labelValue, labelErrors] = resolve(item.label, [...location, 'label']);
+    errors.push(...labelErrors);
+    const label = labelValue ?? item.label;
+    if (item.type === 'pages') {
+        const [itemsResolved, itemsErrors] = resolve(item.items, [...location, 'items']);
+        errors.push(...itemsErrors);
+        const resolvedItems = (Array.isArray(itemsResolved) ? itemsResolved : item.items);
+        const [innerItems, innerErrors] = walkItems(resolvedItems, resolve, [...location, 'items']);
+        errors.push(...innerErrors);
+        return [{ ...item, label, items: innerItems }, errors];
+    }
+    const [pathsValue, pathsErrors] = resolve(item.paths, [...location, 'paths']);
+    errors.push(...pathsErrors);
+    const paths = pathsValue ?? item.paths;
+    return [{ ...item, label, paths }, errors];
+}

package/dist/validate/variants.d.ts

@@ -0,0 +1,59 @@
+import type { BuilderComponentVariantsValidated, BuilderModelValidated } from '../entities/index';
+import type { BuilderErrorLocation } from '../exception';
+import type { BuilderInstance } from '../instance';
+import type { ValidationResult } from './result';
+export declare function builderErrorMissingComponent(component: string, location?: BuilderErrorLocation): {
+    component: string;
+    kind: "missing-component";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorMissingComponent = ReturnType<typeof builderErrorMissingComponent>;
+export declare function builderErrorUnexpectedComponent(component: string, location?: BuilderErrorLocation): {
+    component: string;
+    kind: "unexpected-component";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorUnexpectedComponent = ReturnType<typeof builderErrorUnexpectedComponent>;
+export declare function builderErrorMissingVariant(component: string, instance: BuilderInstance, location?: BuilderErrorLocation): {
+    component: string;
+    instance: BuilderInstance;
+    kind: "missing-variant";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorMissingVariant = ReturnType<typeof builderErrorMissingVariant>;
+export declare function builderErrorInvalidVariant(component: string, instance: BuilderInstance, location?: BuilderErrorLocation): {
+    component: string;
+    instance: BuilderInstance;
+    kind: "invalid-variant";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidVariant = ReturnType<typeof builderErrorInvalidVariant>;
+export declare function builderErrorMissingDetail(component: string, detail: string, instance: BuilderInstance, location?: BuilderErrorLocation): {
+    component: string;
+    detail: string;
+    instance: BuilderInstance;
+    kind: "missing-detail";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorMissingDetail = ReturnType<typeof builderErrorMissingDetail>;
+export declare function builderErrorUnexpectedDetail(component: string, detail: string, instance: BuilderInstance, location?: BuilderErrorLocation): {
+    component: string;
+    detail: string;
+    instance: BuilderInstance;
+    kind: "unexpected-detail";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorUnexpectedDetail = ReturnType<typeof builderErrorUnexpectedDetail>;
+export declare function builderErrorInvalidDetail(component: string, detail: string, instance: BuilderInstance, location?: BuilderErrorLocation): {
+    component: string;
+    detail: string;
+    instance: BuilderInstance;
+    kind: "invalid-detail";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidDetail = ReturnType<typeof builderErrorInvalidDetail>;
+export type BuilderVariantsValidationOptions = {
+    readonly partial?: boolean;
+};
+export type BuilderComponentVariantsValidationResult = ValidationResult<BuilderComponentVariantsValidated>;
+export declare function validateVariants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions): BuilderComponentVariantsValidationResult;

package/dist/validate/variants.js

@@ -0,0 +1,102 @@
+import { check } from '../check.js';
+import { detailValueSchema } from '../entities/index.js';
+import { builderError } from '../exception.js';
+import { createVariants, resolveComponent } from '../mappers/index.js';
+import { BuilderComponentVariantsSchema } from '../instance.js';
+import { validate } from './brand.js';
+import { builderErrorInvalidInput } from './result.js';
+export function builderErrorMissingComponent(component, location = []) {
+    return { ...builderError('missing-component', location), component };
+}
+export function builderErrorUnexpectedComponent(component, location = []) {
+    return { ...builderError('unexpected-component', location), component };
+}
+export function builderErrorMissingVariant(component, instance, location = []) {
+    return { ...builderError('missing-variant', location), component, instance };
+}
+export function builderErrorInvalidVariant(component, instance, location = []) {
+    return { ...builderError('invalid-variant', location), component, instance };
+}
+export function builderErrorMissingDetail(component, detail, instance, location = []) {
+    return { ...builderError('missing-detail', location), component, detail, instance };
+}
+export function builderErrorUnexpectedDetail(component, detail, instance, location = []) {
+    return { ...builderError('unexpected-detail', location), component, detail, instance };
+}
+export function builderErrorInvalidDetail(component, detail, instance, location = []) {
+    return { ...builderError('invalid-detail', location), component, detail, instance };
+}
+export function validateVariants(model, input, options = {}) {
+    if (!check.is(BuilderComponentVariantsSchema, input)) {
+        const errors = [builderErrorInvalidInput('variants')];
+        return [validate({}), errors];
+    }
+    const expected = createVariants(model);
+    const errors = [
+        ...checkVariants(expected, input, options.partial ?? false),
+        ...checkUnexpectedComponents(expected, input),
+        ...checkInvalidDetails(input, model.components)
+    ];
+    return [validate(input), errors];
+}
+function checkVariants(expected, variants, partial) {
+    return Object.entries(expected).flatMap(([component, expectedVariants]) => {
+        const componentVariants = variants[component];
+        if (componentVariants == null) {
+            return partial ? [] : [builderErrorMissingComponent(component, ['variants'])];
+        }
+        const expectedKeys = new Map(expectedVariants.map(({ instance }) => [sortedKey(instance), instance]));
+        const actualKeys = new Set(componentVariants.map(({ instance }) => sortedKey(instance)));
+        return [
+            ...componentVariants
+                .filter(({ instance }) => !expectedKeys.has(sortedKey(instance)))
+                .map((variant) => builderErrorInvalidVariant(component, variant.instance, [
+                'variants',
+                component,
+                componentVariants.indexOf(variant)
+            ])),
+            ...[...expectedKeys]
+                .filter(([key]) => !actualKeys.has(key))
+                .map(([, instance]) => builderErrorMissingVariant(component, instance, ['variants', component]))
+        ];
+    });
+}
+function checkUnexpectedComponents(expected, variants) {
+    return Object.keys(variants)
+        .filter((component) => expected[component] == null)
+        .map((component) => builderErrorUnexpectedComponent(component, ['variants', component]));
+}
+function checkInvalidDetails(variants, components) {
+    const componentByName = new Map(components.map((entry) => [entry.name, entry]));
+    return Object.entries(variants).flatMap(([component, componentVariants]) => {
+        const entry = componentByName.get(component);
+        if (entry == null) {
+            return [];
+        }
+        return componentVariants.flatMap(({ instance, details }, index) => {
+            const resolved = resolveComponent(entry, instance);
+            const fields = (resolved?.fields ?? []);
+            const expectedNames = new Set(fields.map(({ name }) => name));
+            const actualDetails = details ?? {};
+            const detailsLocation = ['variants', component, index, 'details'];
+            const missingOrInvalid = fields.flatMap(({ name, valueType, isOptional }) => {
+                const detailLocation = [...detailsLocation, name];
+                if (!(name in actualDetails)) {
+                    return [builderErrorMissingDetail(component, name, instance, detailLocation)];
+                }
+                if (!check.is(detailValueSchema(valueType, isOptional), actualDetails[name])) {
+                    return [builderErrorInvalidDetail(component, name, instance, detailLocation)];
+                }
+                return [];
+            });
+            const unexpected = Object.keys(actualDetails)
+                .filter((detail) => !expectedNames.has(detail))
+                .map((detail) => builderErrorUnexpectedDetail(component, detail, instance, [...detailsLocation, detail]));
+            return [...missingOrInvalid, ...unexpected];
+        });
+    });
+}
+function sortedKey(instance) {
+    const entries = Object.entries(instance).filter(([, value]) => value != null);
+    return JSON.stringify(entries.sort(([keyA], [keyB]) => keyA.localeCompare(keyB)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "type": "module",
   "exports": {
     ".": {
@@ -23,20 +23,23 @@
     "build": "vite build",
     "package": "svelte-kit sync && svelte-package --input src/lib/builder",
     "preview": "vite preview",
-    "prepare": "svelte-kit sync || echo ''",
+    "prepare": "svelte-kit sync && npm run messages || echo ''",
     "prepublishOnly": "npm run test && npm run package",
-    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "messages": "paraglide-js compile --project ./project.inlang --outdir ./src/lib/i18n",
+    "check": "npm run messages && svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "npm run messages && svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
     "format": "prettier --write .",
     "lint": "prettier --check . && eslint .",
-    "test:unit": "vitest",
     "test": "npm run test:unit -- --run",
+    "test:unit": "npm run messages && vitest --project client --project server",
+    "test:integration": "npm run messages && vitest run --project integration",
     "verify": "npm run test && npm run check && npm run format && npm run lint",
     "types:db": "dotenv -e .env.development.local -- supabase gen types typescript --project-id \"$SUPABASE_PROJECT_ID\" --schema public > ./src/lib/db/database.types.ts"
   },
   "devDependencies": {
     "@eslint/compat": "^1.2.5",
     "@eslint/js": "^9.18.0",
+    "@inlang/paraglide-js": "^2.16.0",
     "@sveltejs/adapter-auto": "^6.0.0",
     "@sveltejs/adapter-vercel": "^5.7.2",
     "@sveltejs/kit": "^2.16.0",
@@ -44,7 +47,7 @@
     "@sveltejs/vite-plugin-svelte": "^5.0.0",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/svelte": "^5.2.4",
-    "@vitest/coverage-v8": "^3.1.4",
+    "@vitest/coverage-v8": "^4.1.5",
     "dotenv-cli": "^8.0.0",
     "eslint": "^9.18.0",
     "eslint-config-prettier": "^10.0.1",
@@ -54,18 +57,18 @@
     "jsdom": "^26.0.0",
     "prettier": "^3.4.2",
     "prettier-plugin-svelte": "^3.3.3",
-    "supabase": "^2.33.9",
+    "supabase": "^2.93.0",
     "svelte": "^5.0.0",
     "svelte-check": "^4.0.0",
     "typescript": "^5.0.0",
     "typescript-eslint": "^8.58.2",
     "vite": "^6.2.6",
-    "vitest": "^3.0.0"
+    "vitest": "^4.1.5"
   },
   "dependencies": {
     "@floating-ui/dom": "^1.7.2",
     "@lucide/svelte": "^0.525.0",
-    "@supabase/supabase-js": "^2.49.8",
+    "@supabase/supabase-js": "^2.104.0",
     "@upstash/ratelimit": "^2.0.5",
     "@upstash/redis": "^1.35.0",
     "@vercel/kv": "^3.0.0",

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

@@ -1,20 +0,0 @@
-import type { BuilderGeneric, BuilderReferences, BuilderStateOf } from './builder';
-import type { BuilderState, BuilderStateEmpty } from './state';
-import { Builder } from './builder.js';
-export declare function builders<const References extends BuilderReferences>(...builders: References): Builder<BuilderBuildersMerge<References>>;
-export declare function mergeBuilderParts(parts: ReadonlyArray<unknown>): {
-    references: import("../..").BuilderRef[];
-    options: import("..").BuilderOption<string, import("../..").Refable<import("..").BuilderOptionPayload>, import("../..").Refable<readonly (readonly (string | number)[])[]>>[];
-    components: import("..").BuilderComponent<string, import("../..").Refable<import("..").BuilderComponentPayload>, import("../..").Refable<readonly (readonly (string | number)[])[]>>[];
-    collections: import("..").BuilderCollection<string, import("../..").Refable<import("..").BuilderCollectionPayload>, import("../..").Refable<readonly (readonly (string | number)[])[]>>[];
-    expectations: import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[];
-};
-export type BuilderBuildersMerge<References extends BuilderReferences> = References extends readonly [infer Head, ...infer Tail extends BuilderReferences] ? Head extends BuilderGeneric ? BuilderStateMerge<BuilderStateOf<Head>, BuilderBuildersMerge<Tail>> : BuilderBuildersMerge<Tail> : BuilderStateEmpty;
-type BuilderStateMerge<Left extends BuilderState, Right extends BuilderState> = {
-    model: Left['model'] & Right['model'];
-    references: Left['references'] & Right['references'];
-    options: [...Left['options'], ...Right['options']];
-    components: [...Left['components'], ...Right['components']];
-    collections: [...Left['collections'], ...Right['collections']];
-};
-export {};