@builder-builder/builder 0.0.1

package/dist/resolve/render.js

@@ -0,0 +1,182 @@
+import * as v from 'valibot';
+import { resolveCollectionModels } from '../core/index.js';
+import { readPath } from '../paths.js';
+import { BuilderUI } from '../ui.js';
+export function render(rootBuilder, rootModel, input) {
+    const items = v.is(v.instance(BuilderUI), input) ? input.items : input;
+    function walk(builder, model, collectionPath, labelContext, items) {
+        function composeLabel(label) {
+            if (labelContext.length === 0) {
+                return label;
+            }
+            const prefix = labelContext.join(', ');
+            if (label == null) {
+                return prefix;
+            }
+            return `${prefix}, ${label}`;
+        }
+        const layout = [];
+        const description = [];
+        items.forEach((item) => {
+            if (item.type === 'collection') {
+                const collection = findCollection(builder, model, item.name);
+                if (!collection) {
+                    return;
+                }
+                const models = resolveCollectionModels(model, collection.name);
+                models.forEach((collectionModel, itemIndex) => {
+                    const child = walk(collection.builder, collectionModel, [...collectionPath, item.name, itemIndex], [...labelContext, `${ordinal(itemIndex)} ${item.label}`], item.items);
+                    layout.push(...child.layout);
+                    description.push(...child.description);
+                });
+                return;
+            }
+            if (item.type === 'page') {
+                const resolvedOptions = item.paths.flatMap((path) => {
+                    const option = resolvePageOption(builder, model, path);
+                    if (!option) {
+                        return [];
+                    }
+                    const fullPath = [...collectionPath, ...path];
+                    return [
+                        {
+                            option,
+                            value: readPath(model, fullPath),
+                            update: (updateModel, updateValue) => setPath(updateModel, fullPath, updateValue)
+                        }
+                    ];
+                });
+                if (resolvedOptions.length === 0) {
+                    return;
+                }
+                layout.push({
+                    label: composeLabel(item.label),
+                    options: resolvedOptions
+                });
+                return;
+            }
+            if (item.type === 'describe') {
+                const composedLabel = composeLabel(item.label);
+                if (composedLabel == null) {
+                    return;
+                }
+                const values = item.paths.flatMap((path) => {
+                    const value = resolveOptionValue(builder, model, path);
+                    if (value === MISSING || value == null) {
+                        return [];
+                    }
+                    return [value];
+                });
+                if (values.length === 0) {
+                    return;
+                }
+                description.push([composedLabel, values.join(' ')]);
+            }
+        });
+        return { layout, description };
+    }
+    return walk(rootBuilder, rootModel, [], [], items);
+}
+export function ordinal(index) {
+    return ordinals[index] ?? `${index + 1}`;
+}
+const MISSING = {};
+function resolvePageOption(builder, model, path) {
+    const optionName = path[path.length - 1];
+    const prefix = path.slice(0, -1);
+    let currentBuilder = builder;
+    let currentModel = model;
+    for (let pathIndex = 0; pathIndex < prefix.length; pathIndex += 2) {
+        if (!currentModel) {
+            return null;
+        }
+        const collection = findCollection(currentBuilder, currentModel, prefix[pathIndex]);
+        if (!collection) {
+            return null;
+        }
+        currentBuilder = collection.builder;
+        const collectionModels = resolveCollectionModels(model, collection.name);
+        currentModel = collectionModels[prefix[pathIndex + 1]];
+    }
+    if (!currentModel) {
+        return null;
+    }
+    return currentBuilder.options.reduce((found, entry) => {
+        if (found) {
+            return found;
+        }
+        const resolved = entry.resolve(currentModel);
+        return resolved?.name === optionName ? resolved : null;
+    }, null);
+}
+function resolveOptionValue(builder, model, path) {
+    const optionName = path[path.length - 1];
+    const prefix = path.slice(0, -1);
+    let currentBuilder = builder;
+    let currentModel = model;
+    for (let pathIndex = 0; pathIndex < prefix.length; pathIndex += 2) {
+        if (!currentModel) {
+            return MISSING;
+        }
+        const collection = findCollection(currentBuilder, currentModel, prefix[pathIndex]);
+        if (!collection) {
+            return MISSING;
+        }
+        currentBuilder = collection.builder;
+        const collectionModels = resolveCollectionModels(model, collection.name);
+        currentModel = collectionModels[prefix[pathIndex + 1]];
+    }
+    if (!currentModel) {
+        return MISSING;
+    }
+    let found = false;
+    currentBuilder.options.forEach((entry) => {
+        const option = entry.resolve(currentModel);
+        if (option && option.name === optionName) {
+            found = true;
+        }
+    });
+    if (!found) {
+        return MISSING;
+    }
+    return currentModel[optionName];
+}
+function findCollection(builder, model, collectionName) {
+    return builder.collections.reduce((found, entry) => {
+        if (found) {
+            return found;
+        }
+        const collection = entry.resolve(model);
+        return collection?.name === collectionName ? collection : null;
+    }, null);
+}
+function setPath(container, path, value) {
+    const [head, ...tail] = path;
+    if (typeof head === 'number') {
+        const arrayContainer = container ? container : [];
+        arrayContainer[head] = tail.length === 0 ? value : setPath(arrayContainer[head], tail, value);
+        return arrayContainer;
+    }
+    const objectContainer = container ? container : {};
+    return {
+        ...objectContainer,
+        [head]: tail.length === 0 ? value : setPath(objectContainer[head], tail, value)
+    };
+}
+const ordinals = [
+    'First',
+    'Second',
+    'Third',
+    'Fourth',
+    'Fifth',
+    'Sixth',
+    'Seventh',
+    'Eighth',
+    'Ninth',
+    'Tenth',
+    'Eleventh',
+    'Twelfth',
+    'Thirteenth',
+    'Fourteenth',
+    'Fifteenth'
+];

package/dist/resolve/validate.d.ts

@@ -0,0 +1,32 @@
+import type { BuilderData, BuilderModel } from '../config';
+import type { BuilderGeneric } from '../core/index';
+declare const validated: unique symbol;
+export type BuilderDataValidated = BuilderData & {
+    readonly [validated]: true;
+};
+export type BuilderErrorComponentMissing = {
+    readonly type: 'missing-component';
+    readonly component: string;
+};
+export type BuilderErrorComponentUnexpected = {
+    readonly type: 'unexpected-component';
+    readonly component: string;
+};
+export type BuilderErrorVariantMissing = {
+    readonly type: 'missing-variant';
+    readonly component: string;
+    readonly model: BuilderModel;
+};
+export type BuilderErrorVariantInvalid = {
+    readonly type: 'invalid-variant';
+    readonly component: string;
+    readonly model: BuilderModel;
+};
+export type BuilderErrorValidate = BuilderErrorComponentMissing | BuilderErrorComponentUnexpected | BuilderErrorVariantMissing | BuilderErrorVariantInvalid;
+export type BuilderErrorsValidate = ReadonlyArray<BuilderErrorValidate>;
+export type BuilderValidateResult = readonly [BuilderDataValidated, BuilderErrorsValidate];
+export declare function validate(builder: BuilderGeneric, builderModels: BuilderData): BuilderValidateResult;
+export declare namespace validate {
+    var strict: (builder: BuilderGeneric, builderModels: BuilderData) => BuilderValidateResult;
+}
+export {};

package/dist/resolve/validate.js

@@ -0,0 +1,50 @@
+import { models } from './models.js';
+export function validate(builder, builderModels) {
+    const expected = models(builder);
+    let errors = [];
+    Object.entries(expected).forEach(([component, expectedModels]) => {
+        const componentModels = builderModels[component];
+        if (!componentModels) {
+            errors = [...errors, { type: 'missing-component', component }];
+            return;
+        }
+        const expectedKeys = new Map(expectedModels.map((variant) => [sortedKey(variant.model), variant.model]));
+        const actualKeys = new Set();
+        componentModels.forEach((variant) => {
+            const key = sortedKey(variant.model);
+            actualKeys.add(key);
+            if (!expectedKeys.has(key)) {
+                errors = [...errors, { type: 'invalid-variant', component, model: variant.model }];
+            }
+        });
+        expectedKeys.forEach((model, key) => {
+            if (!actualKeys.has(key)) {
+                errors = [...errors, { type: 'missing-variant', component, model }];
+            }
+        });
+    });
+    Object.keys(builderModels).forEach((component) => {
+        if (!expected[component]) {
+            errors = [...errors, { type: 'unexpected-component', component }];
+        }
+    });
+    return [builderModels, errors];
+}
+validate.strict = function strict(builder, builderModels) {
+    const [data, errors] = validate(builder, builderModels);
+    if (errors.length > 0) {
+        throw new ValidateException(errors);
+    }
+    return [data, []];
+};
+function sortedKey(model) {
+    const entries = Object.entries(model).filter(([, value]) => value != null);
+    return JSON.stringify(entries.sort(([keyA], [keyB]) => keyA.localeCompare(keyB)));
+}
+class ValidateException extends Error {
+    errors;
+    constructor(errors) {
+        super(`Builder validation failed with ${String(errors.length)} error(s)`);
+        this.errors = errors;
+    }
+}

package/dist/schemas/description.d.ts

@@ -0,0 +1,5 @@
+import * as v from 'valibot';
+export declare const BuilderDescriptionItemSchema: v.SchemaWithPipe<readonly [v.TupleSchema<[v.StringSchema<undefined>, v.StringSchema<undefined>], undefined>, v.ReadonlyAction<[string, string]>]>;
+export type BuilderDescriptionItem = v.InferOutput<typeof BuilderDescriptionItemSchema>;
+export declare const BuilderDescriptionSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.TupleSchema<[v.StringSchema<undefined>, v.StringSchema<undefined>], undefined>, v.ReadonlyAction<[string, string]>]>, undefined>, v.ReadonlyAction<(readonly [string, string])[]>]>;
+export type BuilderDescription = v.InferOutput<typeof BuilderDescriptionSchema>;

package/dist/schemas/description.js

@@ -0,0 +1,3 @@
+import * as v from 'valibot';
+export const BuilderDescriptionItemSchema = v.pipe(v.tuple([v.string(), v.string()]), v.readonly());
+export const BuilderDescriptionSchema = v.pipe(v.array(BuilderDescriptionItemSchema), v.readonly());

package/dist/schemas/index.d.ts

@@ -0,0 +1,10 @@
+export type { BuilderDescription, BuilderDescriptionItem } from './description';
+export { BuilderDescriptionItemSchema, BuilderDescriptionSchema } from './description.js';
+export type { BuilderLayout, BuilderLayoutOption, BuilderLayoutOptions, BuilderLayoutPage } from './layout';
+export { BuilderLayoutOptionSchema, BuilderLayoutOptionsSchema, BuilderLayoutPageSchema, BuilderLayoutSchema } from './layout.js';
+export type { BuilderPath, BuilderPaths, BuilderPrimitive, BuilderPrimitives } from './primitives';
+export { BuilderPathSchema, BuilderPathsSchema, BuilderPrimitiveSchema, BuilderPrimitivesSchema } from './primitives.js';
+export type { BuilderCollectionSerialised, BuilderCollectionConfigSerialised, BuilderCollectionEnableConfigSerialised, BuilderCollectionMatchConfigSerialised, BuilderCollectionUnlessConfigSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderValuesSerialised, BuilderOptionSerialised, BuilderOptionEnableConfigSerialised, BuilderOptionMatchConfigSerialised, BuilderOptionUnlessConfigSerialised, BuilderOptionWhenConfigSerialised, BuilderSerialised, BuilderSelectTypeSerialised, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderUIDescribeSerialised, BuilderUICollectionSerialised, BuilderUIItemSerialised, BuilderUIItemsSerialised, BuilderUIPageSerialised } from './serialise';
+export { BuilderCollectionConfigSerialisedSchema, BuilderCollectionEnableConfigSerialisedSchema, BuilderCollectionMatchConfigSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionUnlessConfigSerialisedSchema, BuilderCollectionWhenConfigSerialisedSchema, BuilderComponentSerialisedSchema, BuilderValuesSerialisedSchema, BuilderOptionEnableConfigSerialisedSchema, BuilderOptionMatchConfigSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionUnlessConfigSerialisedSchema, BuilderOptionWhenConfigSerialisedSchema, BuilderSerialisedSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSerialisedSchema, BuilderUIDescribeSerialisedSchema, BuilderUICollectionSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSerialisedSchema } from './serialise.js';
+export type { BuilderUIDescribe, BuilderUICollection, BuilderUIItem, BuilderUIItems, BuilderUIPage } from './ui';
+export { BuilderUIDescribeSchema, BuilderUICollectionSchema, BuilderUIItemSchema, BuilderUIItemsSchema, BuilderUIPageSchema } from './ui.js';

package/dist/schemas/index.js

@@ -0,0 +1,5 @@
+export { BuilderDescriptionItemSchema, BuilderDescriptionSchema } from './description.js';
+export { BuilderLayoutOptionSchema, BuilderLayoutOptionsSchema, BuilderLayoutPageSchema, BuilderLayoutSchema } from './layout.js';
+export { BuilderPathSchema, BuilderPathsSchema, BuilderPrimitiveSchema, BuilderPrimitivesSchema } from './primitives.js';
+export { BuilderCollectionConfigSerialisedSchema, BuilderCollectionEnableConfigSerialisedSchema, BuilderCollectionMatchConfigSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionUnlessConfigSerialisedSchema, BuilderCollectionWhenConfigSerialisedSchema, BuilderComponentSerialisedSchema, BuilderValuesSerialisedSchema, BuilderOptionEnableConfigSerialisedSchema, BuilderOptionMatchConfigSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionUnlessConfigSerialisedSchema, BuilderOptionWhenConfigSerialisedSchema, BuilderSerialisedSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSerialisedSchema, BuilderUIDescribeSerialisedSchema, BuilderUICollectionSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSerialisedSchema } from './serialise.js';
+export { BuilderUIDescribeSchema, BuilderUICollectionSchema, BuilderUIItemSchema, BuilderUIItemsSchema, BuilderUIPageSchema } from './ui.js';

package/dist/schemas/layout.d.ts

@@ -0,0 +1,52 @@
+import * as v from 'valibot';
+export declare const BuilderLayoutOptionSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly path: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+}, undefined>, v.ReadonlyAction<{
+    readonly path: readonly (string | number)[];
+}>]>;
+export type BuilderLayoutOption = v.InferOutput<typeof BuilderLayoutOptionSchema>;
+export declare const BuilderLayoutOptionsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly path: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+}, undefined>, v.ReadonlyAction<{
+    readonly path: readonly (string | number)[];
+}>]>, undefined>, v.ReadonlyAction<Readonly<{
+    readonly path: readonly (string | number)[];
+}>[]>]>;
+export type BuilderLayoutOptions = v.InferOutput<typeof BuilderLayoutOptionsSchema>;
+export declare const BuilderLayoutPageSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly options: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly path: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+    }, undefined>, v.ReadonlyAction<{
+        readonly path: readonly (string | number)[];
+    }>]>, undefined>, v.ReadonlyAction<Readonly<{
+        readonly path: readonly (string | number)[];
+    }>[]>]>;
+}, undefined>, v.ReadonlyAction<{
+    label: string | null;
+    readonly options: readonly Readonly<{
+        readonly path: readonly (string | number)[];
+    }>[];
+}>]>;
+export type BuilderLayoutPage = v.InferOutput<typeof BuilderLayoutPageSchema>;
+export declare const BuilderLayoutSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly options: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly path: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+    }, undefined>, v.ReadonlyAction<{
+        readonly path: readonly (string | number)[];
+    }>]>, undefined>, v.ReadonlyAction<Readonly<{
+        readonly path: readonly (string | number)[];
+    }>[]>]>;
+}, undefined>, v.ReadonlyAction<{
+    label: string | null;
+    readonly options: readonly Readonly<{
+        readonly path: readonly (string | number)[];
+    }>[];
+}>]>, undefined>, v.ReadonlyAction<Readonly<{
+    label: string | null;
+    readonly options: readonly Readonly<{
+        readonly path: readonly (string | number)[];
+    }>[];
+}>[]>]>;
+export type BuilderLayout = v.InferOutput<typeof BuilderLayoutSchema>;

package/dist/schemas/layout.js

@@ -0,0 +1,6 @@
+import * as v from 'valibot';
+import { BuilderPathSchema } from './primitives.js';
+export const BuilderLayoutOptionSchema = v.pipe(v.object({ path: BuilderPathSchema }), v.readonly());
+export const BuilderLayoutOptionsSchema = v.pipe(v.array(BuilderLayoutOptionSchema), v.readonly());
+export const BuilderLayoutPageSchema = v.pipe(v.object({ label: v.nullable(v.string()), options: BuilderLayoutOptionsSchema }), v.readonly());
+export const BuilderLayoutSchema = v.pipe(v.array(BuilderLayoutPageSchema), v.readonly());

package/dist/schemas/primitives.d.ts

@@ -0,0 +1,9 @@
+import * as v from 'valibot';
+export declare const BuilderPrimitiveSchema: v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+export type BuilderPrimitive = v.InferOutput<typeof BuilderPrimitiveSchema>;
+export declare const BuilderPrimitivesSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, v.ReadonlyAction<(string | number | boolean | null)[]>]>;
+export type BuilderPrimitives = v.InferOutput<typeof BuilderPrimitivesSchema>;
+export declare const BuilderPathSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+export type BuilderPath = v.InferOutput<typeof BuilderPathSchema>;
+export declare const BuilderPathsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+export type BuilderPaths = v.InferOutput<typeof BuilderPathsSchema>;

package/dist/schemas/primitives.js

@@ -0,0 +1,5 @@
+import * as v from 'valibot';
+export const BuilderPrimitiveSchema = v.nullable(v.union([v.string(), v.boolean(), v.number()]));
+export const BuilderPrimitivesSchema = v.pipe(v.array(BuilderPrimitiveSchema), v.readonly());
+export const BuilderPathSchema = v.pipe(v.array(v.union([v.string(), v.number()])), v.readonly());
+export const BuilderPathsSchema = v.pipe(v.array(BuilderPathSchema), v.readonly());