@builder-builder/builder 0.0.25 → 0.0.26

package/dist/validate/resolve.js

@@ -1,97 +1,111 @@
-import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
+import * as v from 'valibot';
+import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderPathSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
 import { check } from '../errors/index.js';
+import { NumberSchema, StringSchema } from '../primitive.js';
 import { BuilderParameterSerialisedSchema, BuilderRefSerialisedSchema } from '../references.js';
 import { validateModelStructure } from './model.js';
 export function resolver(errors, references = [], bindings = {}) {
     const resolving = new Set();
-    function resolve(value) {
+    function resolve(value, schema = v.unknown()) {
+        const errorsBefore = errors.errors.length;
+        const resolved = dispatch(value, schema);
+        if (check.is(schema, resolved)) {
+            return resolved;
+        }
+        if (errors.errors.length === errorsBefore) {
+            errors.referenceInvalid();
+        }
+        return null;
+    }
+    function dispatch(value, schema) {
         if (check.is(BuilderParameterSerialisedSchema, value)) {
-            return resolveParameter(value);
+            return resolveParameter(value, schema);
         }
         if (check.is(BuilderRefSerialisedSchema, value)) {
-            return resolveReference(value);
+            return resolveReference(value, schema);
         }
         if (check.is(BuilderWhenSerialisedSchema, value)) {
-            return resolveWhen(value);
+            return resolveWhen(value, schema);
         }
         if (check.is(BuilderCollectionConfigSerialisedSchema, value)) {
             return resolveCollectionConfig(value);
         }
         return value;
-        function resolveReference(reference) {
-            if (resolving.has(reference.id)) {
-                errors.referenceCircular();
-                return reference;
-            }
-            const found = references.find((entry) => entry.id === reference.id);
-            if (found == null) {
-                errors.referenceMissing();
-                return reference;
-            }
-            resolving.add(reference.id);
-            try {
-                return resolve(found.serialised);
-            }
-            finally {
-                resolving.delete(reference.id);
-            }
+    }
+    function resolveReference(reference, schema) {
+        if (resolving.has(reference.id)) {
+            errors.referenceCircular();
+            return reference;
         }
-        function resolveParameter(parameter) {
-            if (!(parameter.name in bindings)) {
-                errors.referenceUnboundParameter();
-                return null;
-            }
-            const binding = bindings[parameter.name];
-            if (!check.is(BuilderRefSerialisedSchema, binding)) {
-                return binding;
-            }
-            return resolveReference(binding);
+        const found = references.find((entry) => entry.id === reference.id);
+        if (found == null) {
+            errors.referenceMissing();
+            return reference;
         }
-        function resolveWhen(when) {
-            if (when.type === 'enable') {
-                const payload = errors.scope('payload', () => resolve(when.payload));
-                return { ...when, payload: payload ?? when.payload };
-            }
-            if (when.type === 'unless') {
-                const unlessPath = errors.scope('unlessPath', () => resolve(when.unlessPath));
-                const payload = errors.scope('payload', () => resolve(when.payload));
-                return {
-                    ...when,
-                    unlessPath: unlessPath ?? when.unlessPath,
-                    payload: payload ?? when.payload
-                };
-            }
-            const matchPath = errors.scope('matchPath', () => resolve(when.matchPath));
-            const map = errors.scope('selectMap', () => resolve(when.selectMap));
-            if (map == null || typeof map !== 'object') {
-                return { ...when, matchPath: matchPath ?? when.matchPath };
-            }
-            const selectMap = errors.scope('selectMap', () => Object.entries(map).reduce((values, [key, entryValue]) => {
-                if (entryValue == null) {
-                    return { ...values, [key]: null };
-                }
-                const resolved = errors.scope(key, () => resolve(entryValue));
-                return { ...values, [key]: resolved ?? entryValue };
-            }, {}));
-            return { ...when, matchPath: matchPath ?? when.matchPath, selectMap };
+        resolving.add(reference.id);
+        try {
+            return dispatch(found.serialised, schema);
+        }
+        finally {
+            resolving.delete(reference.id);
+        }
+    }
+    function resolveParameter(parameter, schema) {
+        if (!(parameter.name in bindings)) {
+            errors.referenceUnboundParameter();
+            return null;
+        }
+        const binding = bindings[parameter.name];
+        if (!check.is(BuilderRefSerialisedSchema, binding)) {
+            return binding;
+        }
+        return resolveReference(binding, schema);
+    }
+    function resolveWhen(when, payloadSchema) {
+        if (when.type === 'enable') {
+            const payload = errors.scope('payload', () => resolve(when.payload, payloadSchema));
+            return { ...when, payload: payload ?? when.payload };
         }
-        function resolveCollectionConfig(config) {
-            const model = errors.scope('model', () => {
-                const resolved = resolve(config.model);
-                if (check.is(BuilderModelSerialisedSchema, resolved)) {
-                    return validateModelStructure(resolved, resolve, errors);
-                }
-                return resolved;
-            });
-            const min = errors.scope('min', () => resolve(config.min));
-            const max = errors.scope('max', () => resolve(config.max));
+        if (when.type === 'unless') {
+            const unlessPath = errors.scope('unlessPath', () => resolve(when.unlessPath, BuilderPathSchema));
+            const payload = errors.scope('payload', () => resolve(when.payload, payloadSchema));
             return {
-                ...config,
-                model: model ?? config.model,
-                min: min ?? config.min,
-                max: max ?? config.max
+                ...when,
+                unlessPath: unlessPath ?? when.unlessPath,
+                payload: payload ?? when.payload
             };
         }
+        const matchPath = errors.scope('matchPath', () => resolve(when.matchPath, BuilderPathSchema));
+        const selectMapSchema = v.record(StringSchema, v.nullable(v.unknown()));
+        const map = errors.scope('selectMap', () => resolve(when.selectMap, selectMapSchema));
+        if (map == null) {
+            return { ...when, matchPath: matchPath ?? when.matchPath };
+        }
+        const selectMap = errors.scope('selectMap', () => Object.entries(map).reduce((values, [key, entryValue]) => {
+            if (entryValue == null) {
+                return { ...values, [key]: null };
+            }
+            const resolved = errors.scope(key, () => resolve(entryValue, payloadSchema));
+            return { ...values, [key]: resolved ?? entryValue };
+        }, {}));
+        return { ...when, matchPath: matchPath ?? when.matchPath, selectMap };
+    }
+    function resolveCollectionConfig(config) {
+        const model = errors.scope('model', () => {
+            const resolved = resolve(config.model, BuilderModelSerialisedSchema);
+            if (resolved == null) {
+                return null;
+            }
+            return validateModelStructure(resolved, resolve, errors);
+        });
+        const min = errors.scope('min', () => resolve(config.min, NumberSchema));
+        const max = errors.scope('max', () => resolve(config.max, NumberSchema));
+        return {
+            ...config,
+            model: model ?? config.model,
+            min: min ?? config.min,
+            max: max ?? config.max
+        };
     }
     return resolve;
 }

package/dist/validate/ui.js

@@ -1,6 +1,7 @@
-import { BuilderModelSerialisedSchema, BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, modelsMerge, serialise, uis, validateUIDescribe, validateUIInput, validateUIPage, validateUIPages } from '../entities/index.js';
+import { BuilderModelSerialisedSchema, BuilderPathSchema, BuilderUIInputMetadataSchema, BuilderUIInputSerialisedSchema, BuilderUIInputsSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUISerialisedSchema, modelsMerge, serialise, uis, validateUIDescribe, validateUIInput, validateUIPage, validateUIPages } from '../entities/index.js';
 import { BuilderErrorsScope, check } from '../errors/index.js';
 import { resolveCollections } from '../mappers/index.js';
+import { StringSchema } from '../primitive.js';
 import { validate } from './brand.js';
 import { checkExpectations } from './expectations.js';
 import { checkPath } from './paths.js';
@@ -25,8 +26,8 @@ export function validateUIStructure(ui, resolve, errors) {
     return data;
     function walkChildUIs() {
         return errors.scope('uis', () => ui.uis.flatMap((part, partIndex) => errors.scope(partIndex, () => {
-            const resolved = resolve(part);
-            if (resolved == null || !check.is(BuilderUISerialisedSchema, resolved)) {
+            const resolved = resolve(part, BuilderUISerialisedSchema);
+            if (resolved == null) {
                 return [];
             }
             return [validateUIStructure(resolved, resolve, errors)];
@@ -34,7 +35,7 @@ export function validateUIStructure(ui, resolve, errors) {
     }
     function walkItems(parts) {
         return parts.map((item, itemIndex) => errors.scope(itemIndex, () => {
-            const resolved = resolve(item);
+            const resolved = resolve(item, BuilderUIItemSerialisedSchema);
             return walkUIItem((resolved ?? item));
         }));
     }
@@ -48,17 +49,17 @@ export function validateUIStructure(ui, resolve, errors) {
         else if (item.type === 'describe') {
             validateUIDescribe(item, [], errors);
         }
-        const label = errors.scope('label', () => resolve(item.label) ?? item.label);
+        const label = errors.scope('label', () => resolve(item.label, StringSchema) ?? item.label);
         if (item.type === 'pages') {
             const innerItems = errors.scope('items', () => {
-                const resolved = resolve(item.items);
+                const resolved = resolve(item.items, BuilderUIItemsSerialisedSchema);
                 const resolvedItems = (Array.isArray(resolved) ? resolved : item.items);
                 return walkItems(resolvedItems);
             });
             return { ...item, label, items: innerItems };
         }
         const inputs = errors.scope('inputs', () => {
-            const resolved = resolve(item.inputs);
+            const resolved = resolve(item.inputs, BuilderUIInputsSerialisedSchema);
             if (!Array.isArray(resolved)) {
                 return resolved ?? item.inputs;
             }
@@ -68,22 +69,22 @@ export function validateUIStructure(ui, resolve, errors) {
     }
     function walkInputs(inputs) {
         return inputs.map((entry, entryIndex) => errors.scope(entryIndex, () => {
-            const resolvedEntry = resolve(entry);
+            const resolvedEntry = resolve(entry, BuilderUIInputSerialisedSchema);
             return walkInput((resolvedEntry ?? entry));
         }));
     }
     function walkInput(value) {
         validateUIInput(value, [], errors);
-        const path = errors.scope('path', () => resolve(value.path) ?? value.path);
+        const path = errors.scope('path', () => resolve(value.path, BuilderPathSchema) ?? value.path);
         const displayName = value.displayName &&
-            errors.scope('displayName', () => resolve(value.displayName) ?? value.displayName);
-        const kind = value.kind && errors.scope('kind', () => resolve(value.kind) ?? value.kind);
+            errors.scope('displayName', () => resolve(value.displayName, StringSchema) ?? value.displayName);
+        const kind = value.kind && errors.scope('kind', () => resolve(value.kind, StringSchema) ?? value.kind);
         const metadata = value.metadata && errors.scope('metadata', () => walkMetadata(value.metadata));
         return { ...value, path, displayName, kind, metadata };
     }
     function walkMetadata(rawMetadata) {
-        const resolved = resolve(rawMetadata);
-        if (!check.is(BuilderUIInputMetadataSchema, resolved)) {
+        const resolved = resolve(rawMetadata, BuilderUIInputMetadataSchema);
+        if (resolved == null) {
             return rawMetadata;
         }
         return Object.entries(resolved).reduce((entries, [key, entryValue]) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "type": "module",
   "engines": {
     "node": ">=24"

package/dist/mappers/render/pages.d.ts

@@ -1,24 +0,0 @@
-import type { BuilderOptionConfigSerialised } from '../../entities/index';
-import type { BuilderPrimitive } from '../../primitive';
-import type { BuilderInstance } from '../../instance';
-import * as v from 'valibot';
-export type BuilderRenderUpdate = (model: BuilderInstance, primitive: BuilderPrimitive) => BuilderInstance;
-export declare const BuilderRenderMetadataSchema: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.ReadonlyAction<{
-    [x: string]: unknown;
-}>]>;
-export type BuilderRenderMetadata = v.InferOutput<typeof BuilderRenderMetadataSchema>;
-export type BuilderRenderOption = Readonly<{
-    name: string;
-    value: BuilderPrimitive;
-    update: BuilderRenderUpdate;
-    option: BuilderOptionConfigSerialised;
-    displayName?: string;
-    kind?: string;
-    metadata?: BuilderRenderMetadata;
-}>;
-export type BuilderRenderOptions = ReadonlyArray<BuilderRenderOption>;
-export type BuilderRenderPage = Readonly<{
-    label: string;
-    options: BuilderRenderOptions;
-}>;
-export type BuilderRenderPages = ReadonlyArray<BuilderRenderPage>;

package/dist/mappers/render/pages.js

@@ -1,2 +0,0 @@
-import * as v from 'valibot';
-export const BuilderRenderMetadataSchema = v.pipe(v.record(v.string(), v.unknown()), v.readonly());