@builder-builder/builder 0.0.18 → 0.0.20

package/dist/validate/model.js

@@ -1,9 +1,10 @@
 import { check } from '../check.js';
 import { BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema, model, modelsMerge, serialise } from '../entities/index.js';
+import { resolveCollections } from '../mappers/index.js';
 import { validate } from './brand.js';
 import { BuilderValidateErrors } from './errors.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/pricing.d.ts

@@ -1,8 +1,8 @@
-import type { BuilderModelSerialised, BuilderPricingSerialised, BuilderPricingValidated, BuilderRefEntities } from '../entities/index';
+import type { BuilderModelSerialised, BuilderPricingSerialised, BuilderPricingValidated, BuilderReferences } from '../entities/index';
 import type { BuilderResolve } from './resolve';
 import type { ValidationResult } from './result';
 import { BuilderValidateErrors } from './errors.js';
 export type BuilderPricingValidationResult = ValidationResult<BuilderPricingValidated>;
-export declare function validatePricing(input: unknown, references?: BuilderRefEntities, errors?: BuilderValidateErrors): BuilderPricingValidationResult;
+export declare function validatePricing(input: unknown, references?: BuilderReferences, errors?: BuilderValidateErrors): BuilderPricingValidationResult;
 export declare function validatePricingStructure(input: BuilderPricingSerialised, resolve: BuilderResolve, errors: BuilderValidateErrors): BuilderPricingSerialised;
 export declare function checkPricingExpectations(model: BuilderModelSerialised, pricing: BuilderPricingSerialised, errors: BuilderValidateErrors): void;

package/dist/validate/resolve.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderBindings, BuilderRefEntities } from '../entities/index';
+import type { BuilderBindings, BuilderReferences } from '../entities/index';
 import type { BuilderValidateErrors } from './errors';
 export type BuilderResolve = (value: unknown) => unknown;
-export declare function resolver(errors: BuilderValidateErrors, references?: BuilderRefEntities, bindings?: BuilderBindings): BuilderResolve;
+export declare function resolver(errors: BuilderValidateErrors, references?: BuilderReferences, bindings?: BuilderBindings): BuilderResolve;

package/dist/validate/ui.d.ts

@@ -1,8 +1,8 @@
-import type { BuilderModelSerialised, BuilderRefEntities, BuilderUISerialised, BuilderUIValidated } from '../entities/index';
+import type { BuilderModelSerialised, BuilderReferences, BuilderUISerialised, BuilderUIValidated } from '../entities/index';
 import type { BuilderResolve } from './resolve';
 import type { ValidationResult } from './result';
 import { BuilderValidateErrors } from './errors.js';
 export type BuilderUIValidationResult = ValidationResult<BuilderUIValidated>;
-export declare function validateUI(input: unknown, references?: BuilderRefEntities, errors?: BuilderValidateErrors): BuilderUIValidationResult;
+export declare function validateUI(input: unknown, references?: BuilderReferences, errors?: BuilderValidateErrors): BuilderUIValidationResult;
 export declare function validateUIStructure(ui: BuilderUISerialised, resolve: BuilderResolve, errors: BuilderValidateErrors): BuilderUIValidated;
 export declare function checkUIExpectations(mergedModel: BuilderModelSerialised, ui: BuilderUIValidated, errors: BuilderValidateErrors): void;

package/dist/validate/ui.js

@@ -1,9 +1,10 @@
 import { check } from '../check.js';
 import { BuilderModelSerialisedSchema, BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, modelsMerge, serialise, uis } from '../entities/index.js';
+import { resolveCollections } from '../mappers/index.js';
 import { validate } from './brand.js';
 import { BuilderValidateErrors } from './errors.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 { BuilderComponentConfigSerialisedSchema, 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(BuilderComponentConfigSerialisedSchema, 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.18",
+  "version": "0.0.20",
   "type": "module",
   "exports": {
     ".": {

package/dist/entities/component/details.d.ts

@@ -1,66 +0,0 @@
-import type { Paramable } from '../../references';
-import type { BuilderTags } from '../tags';
-import type { BuilderComponentFields } from './field';
-import * as v from 'valibot';
-export declare class BuilderComponentDetails<const Fields extends Paramable<BuilderComponentFields> = Paramable<BuilderComponentFields>> {
-    readonly type: 'component-details';
-    readonly fields: Fields;
-    readonly tags?: BuilderTags;
-    constructor(fields: Fields, tags?: BuilderTags);
-    tag(...tags: Array<string>): BuilderComponentDetails<Fields>;
-}
-export declare const BuilderComponentDetailsSchema: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
-export declare const BuilderComponentDetailsSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly fields: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"parameter", undefined>;
-        readonly id: v.StringSchema<undefined>;
-        readonly name: v.StringSchema<undefined>;
-    }, undefined>, v.ReadonlyAction<{
-        type: "parameter";
-        id: string;
-        name: string;
-    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
-        readonly id: v.StringSchema<undefined>;
-    }, undefined>, v.ReadonlyAction<{
-        type: "ref";
-        id: string;
-    }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"component-field", undefined>;
-        readonly name: v.StringSchema<undefined>;
-        readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
-        readonly isOptional: v.BooleanSchema<undefined>;
-        readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
-    }, undefined>, v.ReadonlyAction<{
-        type: "component-field";
-        name: string;
-        valueType: "string" | "number" | "boolean";
-        isOptional: boolean;
-        tags?: readonly string[] | undefined;
-    }>]>, undefined>, v.ReadonlyAction<Readonly<{
-        type: "component-field";
-        name: string;
-        valueType: "string" | "number" | "boolean";
-        isOptional: boolean;
-        tags?: readonly string[] | undefined;
-    }>[]>]>], undefined>;
-    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
-}, undefined>, v.ReadonlyAction<{
-    fields: Readonly<{
-        type: "parameter";
-        id: string;
-        name: string;
-    }> | Readonly<{
-        type: "ref";
-        id: string;
-    }> | readonly Readonly<{
-        type: "component-field";
-        name: string;
-        valueType: "string" | "number" | "boolean";
-        isOptional: boolean;
-        tags?: readonly string[] | undefined;
-    }>[];
-    tags?: readonly string[] | undefined;
-}>]>;
-export type BuilderComponentDetailsSerialised = v.InferOutput<typeof BuilderComponentDetailsSerialisedSchema>;
-export declare function componentDetails<const Fields extends BuilderComponentFields>(...fields: Fields): BuilderComponentDetails<Fields>;

package/dist/entities/entry.d.ts

@@ -1,4 +0,0 @@
-import type { BuilderCollectionSerialised } from './collection/index';
-import type { BuilderComponentSerialised } from './component/index';
-import type { BuilderOptionSerialised } from './option/index';
-export type BuilderModelEntrySerialised = BuilderOptionSerialised | BuilderComponentSerialised | BuilderCollectionSerialised;

package/dist/entities/option/values.d.ts

@@ -1,49 +0,0 @@
-import * as v from 'valibot';
-export declare const BuilderOptionValuesSchema: v.UnionSchema<[v.InstanceSchema<typeof import("./select.js").BuilderSelectType, undefined>, v.InstanceSchema<typeof import("./toggle.js").BuilderToggleType, undefined>], undefined>;
-export type BuilderOptionValues = v.InferOutput<typeof BuilderOptionValuesSchema>;
-export declare const BuilderOptionValuesSerialisedSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"select", undefined>;
-    readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
-    readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    readonly isOptional: v.BooleanSchema<undefined>;
-    readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
-    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
-}, undefined>, v.ReadonlyAction<{
-    type: "select";
-    readonly options: readonly [string, ...string[]];
-    defaultValue: string | null;
-    isOptional: boolean;
-    optionLabels: {
-        [x: string]: string;
-    };
-    tags?: readonly string[] | undefined;
-}>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"toggle", undefined>;
-    readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
-    readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
-    readonly isOptional: v.BooleanSchema<undefined>;
-    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
-}, undefined>, v.ReadonlyAction<{
-    type: "toggle";
-    valueType: "string" | "number" | "boolean";
-    defaultValue: string | number | boolean | null;
-    isOptional: boolean;
-    tags?: readonly string[] | undefined;
-}>]>], undefined>, v.ReadonlyAction<Readonly<{
-    type: "select";
-    readonly options: readonly [string, ...string[]];
-    defaultValue: string | null;
-    isOptional: boolean;
-    optionLabels: {
-        [x: string]: string;
-    };
-    tags?: readonly string[] | undefined;
-}> | Readonly<{
-    type: "toggle";
-    valueType: "string" | "number" | "boolean";
-    defaultValue: string | number | boolean | null;
-    isOptional: boolean;
-    tags?: readonly string[] | undefined;
-}>>]>;
-export type BuilderOptionValuesSerialised = v.InferOutput<typeof BuilderOptionValuesSerialisedSchema>;
-export declare function optionValueSchema(payload: BuilderOptionValuesSerialised): v.GenericSchema;

package/dist/entities/option/values.js

@@ -1,14 +0,0 @@
-import * as v from 'valibot';
-import { BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, selectValueSchema } from './select.js';
-import { BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema, toggleValueSchema } from './toggle.js';
-export const BuilderOptionValuesSchema = v.union([
-    BuilderSelectTypeSchema,
-    BuilderToggleTypeSchema
-]);
-export const BuilderOptionValuesSerialisedSchema = v.pipe(v.variant('type', [BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSerialisedSchema]), v.readonly());
-export function optionValueSchema(payload) {
-    if (payload.type === 'select') {
-        return selectValueSchema(payload.options, payload.isOptional);
-    }
-    return toggleValueSchema(payload.valueType, payload.isOptional);
-}

package/dist/entities/refs.js

@@ -1 +0,0 @@
-export {};