@builder-builder/builder 0.0.17 → 0.0.19

package/dist/mappers/index.d.ts

@@ -8,4 +8,4 @@ export { createVariants, optionGraph, variantsFor } from './variants/index.js';
 export { order } from './order.js';
 export { price } from './price.js';
 export { ordinal, render } from './render/index.js';
-export { resolveCollection, resolveComponent, resolveOption } from './resolve.js';
+export { resolveCollection, resolveCollections, resolveComponent, resolveComponents, resolveOption, resolveOptions } from './resolve.js';

package/dist/mappers/index.js

@@ -4,4 +4,4 @@ export { createVariants, optionGraph, variantsFor } from './variants/index.js';
 export { order } from './order.js';
 export { price } from './price.js';
 export { ordinal, render } from './render/index.js';
-export { resolveCollection, resolveComponent, resolveOption } from './resolve.js';
+export { resolveCollection, resolveCollections, resolveComponent, resolveComponents, resolveOption, resolveOptions } from './resolve.js';

package/dist/mappers/resolve.d.ts

@@ -1,9 +1,12 @@
-import type { BuilderCollectionConfigValidated, BuilderCollectionValidated, BuilderComponentDetailsValidated, BuilderComponentValidated, BuilderModelValidated, BuilderOptionValidated, BuilderOptionValuesValidated, BuilderRefEntities } from '../entities/index';
+import type { BuilderCollectionConfigSerialised, BuilderCollectionConfigValidated, BuilderCollectionSerialised, BuilderCollectionValidated, BuilderComponentDetailsSerialised, BuilderComponentDetailsValidated, BuilderComponentSerialised, BuilderComponentValidated, BuilderModelValidated, BuilderOptionSerialised, BuilderOptionValidated, BuilderOptionValuesSerialised, BuilderOptionValuesValidated, BuilderRefEntities } from '../entities/index';
 import type { BuilderInstance } from '../instance';
 import type { BuilderPath } from '../paths';
 export declare function resolveOption(option: BuilderOptionValidated, model: BuilderModelValidated, instance: unknown, refs?: BuilderRefEntities): BuilderOptionValuesValidated | null;
+export declare function resolveOptions(option: BuilderOptionSerialised, refs?: BuilderRefEntities): ReadonlyArray<BuilderOptionValuesSerialised>;
 export declare function resolveComponent(component: BuilderComponentValidated, model: BuilderModelValidated, instance: unknown, refs?: BuilderRefEntities): BuilderComponentDetailsValidated | null;
+export declare function resolveComponents(component: BuilderComponentSerialised, refs?: BuilderRefEntities): ReadonlyArray<BuilderComponentDetailsSerialised>;
 export declare function resolveCollection(collection: BuilderCollectionValidated, model: BuilderModelValidated, instance: unknown, refs?: BuilderRefEntities): BuilderCollectionConfigValidated | null;
+export declare function resolveCollections(collection: BuilderCollectionSerialised, refs?: BuilderRefEntities): ReadonlyArray<BuilderCollectionConfigSerialised>;
 export declare function resolveRef(value: unknown, refs: BuilderRefEntities): unknown;
 export type ResolvedPath = {
     readonly name: string;

package/dist/mappers/resolve.js

@@ -6,13 +6,22 @@ import { BuilderPathsSchema } from '../paths.js';
 import { BuilderPrimitiveSchema } from '../primitive.js';
 import { BuilderRefSerialisedSchema } from '../references.js';
 export function resolveOption(option, model, instance, refs = []) {
-    return resolveEntry(option, BuilderOptionValuesSerialisedSchema, model, instance, refs);
+    return resolveEntryInstance(option, BuilderOptionValuesSerialisedSchema, model, instance, refs);
+}
+export function resolveOptions(option, refs = []) {
+    return resolveEntryExhaustive(option, BuilderOptionValuesSerialisedSchema, refs);
 }
 export function resolveComponent(component, model, instance, refs = []) {
-    return resolveEntry(component, BuilderComponentDetailsSerialisedSchema, model, instance, refs);
+    return resolveEntryInstance(component, BuilderComponentDetailsSerialisedSchema, model, instance, refs);
+}
+export function resolveComponents(component, refs = []) {
+    return resolveEntryExhaustive(component, BuilderComponentDetailsSerialisedSchema, refs);
 }
 export function resolveCollection(collection, model, instance, refs = []) {
-    return resolveEntry(collection, BuilderCollectionConfigSerialisedSchema, model, instance, refs);
+    return resolveEntryInstance(collection, BuilderCollectionConfigSerialisedSchema, model, instance, refs);
+}
+export function resolveCollections(collection, refs = []) {
+    return resolveEntryExhaustive(collection, BuilderCollectionConfigSerialisedSchema, refs);
 }
 export function resolveRef(value, refs) {
     if (!check.is(BuilderRefSerialisedSchema, value)) {
@@ -62,7 +71,7 @@ export function resolveItems(model, instance, pairs, refs = []) {
     }
     return resolveItems(resolved.model, item, rest, refs);
 }
-function resolveEntry(entry, schema, model, instance, refs = []) {
+function resolveEntryInstance(entry, schema, model, instance, refs) {
     const payload = resolveRef(entry.payload, refs);
     if (check.is(schema, payload)) {
         return payload;
@@ -70,7 +79,7 @@ function resolveEntry(entry, schema, model, instance, refs = []) {
     check.assert(BuilderWhenSerialisedSchema, payload);
     check.assert(BuilderPathsSchema, entry.paths);
     const config = payload;
-    if (!entry.paths.every((path) => isPresent(resolvePath(model, instance, path, refs)?.value))) {
+    if (!entry.paths.every((path) => Boolean(resolvePath(model, instance, path, refs)?.value))) {
         return null;
     }
     switch (config.type) {
@@ -84,7 +93,7 @@ function resolveEntry(entry, schema, model, instance, refs = []) {
         }
         case 'unless': {
             const value = resolvePath(model, instance, config.unlessPath, refs)?.value;
-            if (!isPresent(value)) {
+            if (!value) {
                 return null;
             }
             check.assert(BuilderPrimitiveSchema, value);
@@ -95,12 +104,22 @@ function resolveEntry(entry, schema, model, instance, refs = []) {
         }
     }
 }
-function isPresent(value) {
-    if (value == null) {
-        return false;
+function resolveEntryExhaustive(entry, schema, refs) {
+    const payload = resolveRef(entry.payload, refs);
+    if (check.is(schema, payload)) {
+        return [payload];
     }
-    if (typeof value === 'string' && value === '') {
-        return false;
+    if (!check.is(BuilderWhenSerialisedSchema, payload)) {
+        return [];
+    }
+    const when = payload;
+    switch (when.type) {
+        case 'enable':
+        case 'unless': {
+            return [when.payload];
+        }
+        case 'match': {
+            return Object.values(when.selectMap).filter((branch) => branch != null);
+        }
     }
-    return true;
 }

package/dist/validate/brand.js

@@ -1,21 +1,12 @@
 import { BuilderException } from '../exception.js';
 import { BuilderValidateErrors } from './errors.js';
-const VALIDATED = Symbol('builder.validated');
+const VALIDATED_ENTITIES = new WeakSet();
 export function validate(value) {
-    // Descriptor flags chosen for Svelte 5 `$state` proxy compatibility — `$state`
-    // rejects any property that isn't writable, configurable, and enumerable.
-    // Symbol keys are skipped by `JSON.stringify` regardless of enumerability,
-    // so the brand never leaks through a serialise round-trip.
-    Object.defineProperty(value, VALIDATED, {
-        value: true,
-        writable: true,
-        enumerable: true,
-        configurable: true
-    });
+    VALIDATED_ENTITIES.add(value);
     return value;
 }
 export function assertValidated(value) {
-    if (typeof value !== 'object' || value === null || !(VALIDATED in value)) {
+    if (typeof value !== 'object' || value === null || !VALIDATED_ENTITIES.has(value)) {
         const errors = new BuilderValidateErrors();
         errors.unvalidated(value);
         throw new BuilderException(errors.errors);

package/dist/validate/model.js

@@ -2,8 +2,9 @@ import { check } from '../check.js';
 import { BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema, model, modelsMerge, serialise } from '../entities/index.js';
 import { validate } from './brand.js';
 import { BuilderValidateErrors } from './errors.js';
+import { resolveCollections } from '../mappers/index.js';
 import { checkExpectations } from './expectations.js';
-import { checkPath, collectionConfigs } from './paths.js';
+import { checkPath } from './paths.js';
 import { resolver } from './resolve.js';
 const EMPTY_MODEL = validate(serialise.model(model()));
 export function validateModel(input, references = [], errors = new BuilderValidateErrors()) {
@@ -135,7 +136,7 @@ export function validateModelStructure(input, resolve, errors) {
         }
     }
     function checkCollectionBounds(collection) {
-        collectionConfigs(collection).forEach(({ min, max }) => {
+        resolveCollections(collection).forEach(({ min, max }) => {
             if (typeof min !== 'number' || typeof max !== 'number') {
                 return;
             }

package/dist/validate/paths.d.ts

@@ -1,5 +1,4 @@
-import type { BuilderCollectionConfigSerialised, BuilderCollectionSerialised, BuilderModelSerialised } from '../entities/index';
+import type { BuilderModelSerialised } from '../entities/index';
 import type { BuilderPath } from '../paths';
 import type { BuilderValidateErrors } from './errors';
 export declare function checkPath(model: BuilderModelSerialised, path: BuilderPath, errors: BuilderValidateErrors): void;
-export declare function collectionConfigs(collection: BuilderCollectionSerialised): ReadonlyArray<BuilderCollectionConfigSerialised>;

package/dist/validate/paths.js

@@ -1,6 +1,7 @@
 import * as v from 'valibot';
 import { check } from '../check.js';
-import { BuilderCollectionConfigSerialisedSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
+import { BuilderModelSerialisedSchema } from '../entities/index.js';
+import { resolveCollections } from '../mappers/index.js';
 const NumberSchema = v.number();
 const StringSchema = v.string();
 export function checkPath(model, path, errors) {
@@ -17,24 +18,6 @@ export function checkPath(model, path, errors) {
         errors.invalidPath('option-not-found');
     }
 }
-export function collectionConfigs(collection) {
-    const { payload } = collection;
-    if (check.is(BuilderCollectionConfigSerialisedSchema, payload)) {
-        return [payload];
-    }
-    if (!check.is(BuilderWhenSerialisedSchema, payload)) {
-        return [];
-    }
-    if (payload.type === 'match') {
-        if (!check.is(BuilderCollectionSelectMapSerialisedSchema, payload.selectMap)) {
-            return [];
-        }
-        return Object.values(payload.selectMap).flatMap((value) => check.is(BuilderCollectionConfigSerialisedSchema, value) ? [value] : []);
-    }
-    return check.is(BuilderCollectionConfigSerialisedSchema, payload.payload)
-        ? [payload.payload]
-        : [];
-}
 function walkPath(candidates, remaining, errors) {
     if (remaining.length === 0) {
         return candidates;
@@ -46,7 +29,7 @@ function walkPath(candidates, remaining, errors) {
     }
     const matchedConfigs = candidates.flatMap((current) => {
         const collection = current.collections.find((entry) => entry.name === collectionName);
-        return collection == null ? [] : [collectionConfigs(collection)];
+        return collection == null ? [] : [resolveCollections(collection)];
     });
     if (matchedConfigs.length === 0) {
         errors.invalidPath('missing-collection');

package/dist/validate/ui.js

@@ -2,8 +2,9 @@ import { check } from '../check.js';
 import { BuilderModelSerialisedSchema, BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, modelsMerge, serialise, uis } from '../entities/index.js';
 import { validate } from './brand.js';
 import { BuilderValidateErrors } from './errors.js';
+import { resolveCollections } from '../mappers/index.js';
 import { checkExpectations } from './expectations.js';
-import { checkPath, collectionConfigs } from './paths.js';
+import { checkPath } from './paths.js';
 import { resolver } from './resolve.js';
 export function validateUI(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderUISerialisedSchema, input)) {
@@ -118,7 +119,7 @@ export function checkUIExpectations(mergedModel, ui, errors) {
         if (collection == null) {
             return;
         }
-        const innerModels = collectionConfigs(collection).flatMap(({ model: configModel }) => check.is(BuilderModelSerialisedSchema, configModel) ? [configModel] : []);
+        const innerModels = resolveCollections(collection).flatMap(({ model: configModel }) => check.is(BuilderModelSerialisedSchema, configModel) ? [configModel] : []);
         innerModels.forEach((innerModel) => {
             const mergedInnerModel = modelsMerge(innerModel);
             errors.scope('items', () => walkItems(mergedInnerModel, pages.items));

package/dist/validate/variants.js

@@ -1,7 +1,7 @@
 import { check } from '../check.js';
-import { detailValueSchema } from '../entities/index.js';
+import { BuilderComponentDetailsSerialisedSchema, detailValueSchema } from '../entities/index.js';
 import { BuilderComponentVariantsSchema } from '../instance.js';
-import { createVariants, resolveComponent } from '../mappers/index.js';
+import { createVariants } from '../mappers/index.js';
 import { validate } from './brand.js';
 import { BuilderValidateErrors } from './errors.js';
 export function validateVariants(model, input, options = {}, errors = new BuilderValidateErrors()) {
@@ -66,7 +66,7 @@ export function validateVariants(model, input, options = {}, errors = new Builde
                     }
                     componentVariants.forEach(({ instance, details = {} }, index) => {
                         errors.scope(index, () => {
-                            const resolved = resolveComponent(entry, model, instance);
+                            const resolved = variantDetails(entry, instance);
                             const fields = resolved?.fields ?? [];
                             const expectedNames = new Set(fields.map(({ name }) => name));
                             errors.scope('details', () => {
@@ -97,6 +97,17 @@ export function validateVariants(model, input, options = {}, errors = new Builde
     });
     return [validate(variants), errors.errors];
 }
+function variantDetails(component, variantInstance) {
+    const { payload } = component;
+    if (check.is(BuilderComponentDetailsSerialisedSchema, payload)) {
+        return payload;
+    }
+    if (payload.type === 'match') {
+        const value = variantInstance[String(payload.matchPath.at(-1))];
+        return payload.selectMap[String(value)] ?? null;
+    }
+    return payload.payload;
+}
 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.17",
+  "version": "0.0.19",
   "type": "module",
   "exports": {
     ".": {