@builder-builder/builder 0.0.7 → 0.0.8

package/dist/resolve/instance.js

@@ -1,80 +0,0 @@
-import * as v from 'valibot';
-import { resolveCollectionModels } from '../core/index.js';
-export class BuilderModelValidateException extends Error {
-    errors;
-    constructor(errors) {
-        super('model validation failed');
-        this.errors = errors;
-    }
-}
-export function validateInstance(builder, model, options) {
-    const errors = validateModel(builder, model);
-    if (options?.strict && errors.length > 0) {
-        throw new BuilderModelValidateException(errors);
-    }
-    return [model, errors];
-}
-export const instance = Object.assign(createInstance, { validate: validateInstance });
-function validateModel(builder, model) {
-    let errors = [];
-    builder.options.forEach((entry) => {
-        const option = entry.resolve(model);
-        if (!option) {
-            return;
-        }
-        const value = model[option.name];
-        if (!v.is(option.values.valueSchema, value)) {
-            errors = [...errors, { kind: 'invalid-option', name: option.name, value }];
-        }
-    });
-    builder.collections.forEach((entry) => {
-        const collection = entry.resolve(model);
-        if (!collection) {
-            return;
-        }
-        const existing = model[collection.name];
-        if (!Array.isArray(existing)) {
-            errors = [
-                ...errors,
-                { kind: 'invalid-collection', name: collection.name, detail: 'expected an array' }
-            ];
-            return;
-        }
-        const collectionModels = resolveCollectionModels(model, collection.name);
-        collectionModels.forEach((itemModel, index) => {
-            const nestedErrors = validateModel(collection.builder, itemModel);
-            errors = [
-                ...errors,
-                ...nestedErrors.map((error) => ({
-                    ...error,
-                    name: `${collection.name}[${String(index)}].${error.name}`
-                }))
-            ];
-        });
-    });
-    return errors;
-}
-function createInstance(builder, partial = {}) {
-    const model = partial;
-    builder.options.forEach((entry) => {
-        const option = entry.resolve(model);
-        if (!option) {
-            return;
-        }
-        if (!v.is(option.values.valueSchema, model[option.name])) {
-            model[option.name] = option.values.defaultValue;
-        }
-    });
-    builder.collections.forEach((entry) => {
-        const collection = entry.resolve(model);
-        if (!collection) {
-            return;
-        }
-        const existing = model[collection.name];
-        const collectionModels = existing != null ? resolveCollectionModels(model, collection.name) : [];
-        model[collection.name] = Array.from({
-            length: Math.max(collectionModels.length, collection.min)
-        }).map((_, index) => createInstance(collection.builder, collectionModels[index] || {}));
-    });
-    return model;
-}

package/dist/resolve/models.d.ts

@@ -1,3 +0,0 @@
-import type { BuilderData } from '../model';
-import type { BuilderValidated } from '../core/validate';
-export declare function models(builder: BuilderValidated): BuilderData;

package/dist/resolve/models.js

@@ -1,20 +0,0 @@
-export function models(builder) {
-    return modelsRecursive(builder);
-}
-function modelsRecursive(builder) {
-    const collectionModels = builder.collections.flatMap((entry) => {
-        return collectionBuilders(entry).map((collectionBuilder) => modelsRecursive(collectionBuilder));
-    });
-    const wrapped = Object.fromEntries(builder.componentGraph.paths.map((path) => [path.name, path.models.map((model) => ({ model }))]));
-    return {
-        ...collectionModels.reduce((merged, component) => ({ ...merged, ...component }), {}),
-        ...wrapped
-    };
-}
-function collectionBuilders(entry) {
-    if (entry.config?.type === 'match') {
-        const selectMap = entry.config.selectMap;
-        return Object.values(selectMap).flatMap((value) => (value ? [value.builder] : []));
-    }
-    return [entry.builder];
-}

package/dist/resolve/order.d.ts

@@ -1,21 +0,0 @@
-import type { Prettify } from '../prettify';
-import type { BuilderVariant } from '../model';
-import type { CollectionShape } from '../core/collection/index';
-import type { BuilderCollection, BuilderCollectionEntries, BuilderComponentEntries, BuilderComponentNamesOf, BuilderGeneric } from '../core/index';
-import type { BuilderValidated } from '../core/validate';
-import type { BuilderModelValidated } from './instance';
-import type { BuilderDataValidated } from './validate';
-export type BuilderOrder<Builder extends BuilderGeneric> = Builder extends {
-    readonly _components: infer Components extends BuilderComponentEntries;
-    readonly _collections: infer Collections extends BuilderCollectionEntries;
-} ? Prettify<ComponentsOrder<Components> & CollectionsOrder<Collections>> : Record<string, unknown>;
-export declare function order<const Builder extends BuilderGeneric>(builder: Builder & BuilderValidated, model: BuilderModelValidated, componentModels: BuilderDataValidated): BuilderOrder<Builder>;
-type ComponentsOrder<Components extends BuilderComponentEntries> = {
-    readonly [Name in BuilderComponentNamesOf<Components>]: BuilderVariant | null;
-};
-type CollectionsOrder<Collections extends BuilderCollectionEntries> = Collections extends readonly [
-    infer Head extends BuilderCollection,
-    ...infer Tail extends BuilderCollectionEntries
-] ? Record<Head['name'], CollectionOrderOf<Head>> & CollectionsOrder<Tail> : {};
-type CollectionOrderOf<Input extends BuilderCollection> = Input extends BuilderCollection<any, infer CollectionRecipe extends BuilderGeneric, infer Min, infer Max> ? CollectionShape<BuilderOrder<CollectionRecipe>, Min, Max> : ReadonlyArray<Record<string, unknown>>;
-export {};

package/dist/resolve/order.js

@@ -1,27 +0,0 @@
-import { resolveCollectionModels } from '../core/index.js';
-import { check } from '../check.js';
-function orderInternal(builder, model, componentModels) {
-    const result = {};
-    const resolved = new Set();
-    builder.components.forEach((component) => {
-        component.dependencies.forEach((dependency) => {
-            check.truthy(resolved.has(dependency), `Component '${component.name}' depends on '${dependency}' which has not been resolved! ❌`);
-        });
-        resolved.add(component.name);
-        const variants = componentModels[component.name] ?? [];
-        result[component.name] =
-            variants.find((variant) => Object.entries(variant.model).every(([key, value]) => model[key] === value)) ?? null;
-    });
-    builder.collections.forEach((entry) => {
-        const collection = entry.resolve(model);
-        if (!collection) {
-            return;
-        }
-        const itemModels = resolveCollectionModels(model, collection.name);
-        result[collection.name] = itemModels.map((itemModel) => orderInternal(collection.builder, itemModel, componentModels));
-    });
-    return result;
-}
-export function order(builder, model, componentModels) {
-    return orderInternal(builder, model, componentModels);
-}

package/dist/resolve/render.d.ts

@@ -1,23 +0,0 @@
-import type { BuilderOption } from '../core/index';
-import type { BuilderValidated } from '../core/validate';
-import type { BuilderModel } from '../model';
-import type { BuilderModelValidated } from './instance';
-import type { BuilderDescription, BuilderUIItems, BuilderPrimitive } from '../schemas/index';
-import { BuilderUI } from '../ui.js';
-export type BuilderRenderOption = {
-    readonly value: BuilderPrimitive | null;
-    update(model: BuilderModel, value: BuilderPrimitive | null): BuilderModel;
-    readonly option: BuilderOption;
-};
-export type BuilderRenderOptions = ReadonlyArray<BuilderRenderOption>;
-export type BuilderRenderPage = {
-    readonly label: string | null;
-    readonly options: BuilderRenderOptions;
-};
-export type BuilderRenderPages = ReadonlyArray<BuilderRenderPage>;
-export type BuilderRenderResult = {
-    readonly layout: BuilderRenderPages;
-    readonly description: BuilderDescription;
-};
-export declare function render(rootBuilder: BuilderValidated, rootModel: BuilderModelValidated, input: BuilderUI | BuilderUIItems): BuilderRenderResult;
-export declare function ordinal(index: number): string;

package/dist/resolve/render.js

@@ -1,171 +0,0 @@
-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 = findPageOption(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 = findOptionValue(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 = {};
-const ordinals = [
-    'First',
-    'Second',
-    'Third',
-    'Fourth',
-    'Fifth',
-    'Sixth',
-    'Seventh',
-    'Eighth',
-    'Ninth',
-    'Tenth',
-    'Eleventh',
-    'Twelfth',
-    'Thirteenth',
-    'Fourteenth',
-    'Fifteenth'
-];
-function findPageOption(builder, model, path) {
-    const resolved = walkCollectionPath(builder, model, path);
-    if (!resolved) {
-        return null;
-    }
-    return resolved.builder.options.reduce((found, entry) => {
-        if (found) {
-            return found;
-        }
-        const option = entry.resolve(resolved.model);
-        return option?.name === resolved.optionName ? option : null;
-    }, null);
-}
-function findOptionValue(builder, model, path) {
-    const resolved = walkCollectionPath(builder, model, path);
-    if (!resolved) {
-        return MISSING;
-    }
-    const hasOption = resolved.builder.options.some((entry) => {
-        const option = entry.resolve(resolved.model);
-        return option?.name === resolved.optionName;
-    });
-    if (!hasOption) {
-        return MISSING;
-    }
-    return resolved.model[resolved.optionName];
-}
-function walkCollectionPath(builder, model, path) {
-    const optionName = path[path.length - 1];
-    const collectionPairs = path.slice(0, -1);
-    let currentBuilder = builder;
-    let currentModel = model;
-    for (let pairIndex = 0; pairIndex < collectionPairs.length; pairIndex += 2) {
-        if (!currentModel) {
-            return null;
-        }
-        const collection = findCollection(currentBuilder, currentModel, collectionPairs[pairIndex]);
-        if (!collection) {
-            return null;
-        }
-        currentBuilder = collection.builder;
-        const collectionModels = resolveCollectionModels(model, collection.name);
-        currentModel = collectionModels[collectionPairs[pairIndex + 1]];
-    }
-    if (!currentModel) {
-        return null;
-    }
-    return { builder: currentBuilder, model: 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)
-    };
-}

package/dist/resolve/validate.d.ts

@@ -1,37 +0,0 @@
-import type { BuilderData, BuilderModel } from '../model';
-import type { BuilderValidated } from '../core/validate';
-declare const validated: unique symbol;
-export type BuilderDataValidated = BuilderData & {
-    readonly [validated]: true;
-};
-export type BuilderDataErrorComponentMissing = {
-    readonly kind: 'missing-component';
-    readonly component: string;
-};
-export type BuilderDataErrorComponentUnexpected = {
-    readonly kind: 'unexpected-component';
-    readonly component: string;
-};
-export type BuilderDataErrorVariantMissing = {
-    readonly kind: 'missing-variant';
-    readonly component: string;
-    readonly model: BuilderModel;
-};
-export type BuilderDataErrorVariantInvalid = {
-    readonly kind: 'invalid-variant';
-    readonly component: string;
-    readonly model: BuilderModel;
-};
-export type BuilderDataError = BuilderDataErrorComponentMissing | BuilderDataErrorComponentUnexpected | BuilderDataErrorVariantMissing | BuilderDataErrorVariantInvalid;
-export type BuilderDataErrors = ReadonlyArray<BuilderDataError>;
-export type BuilderDataValidateResult = readonly [BuilderDataValidated, BuilderDataErrors];
-export type BuilderDataValidateOptions = {
-    readonly strict: true;
-};
-export declare class BuilderDataValidateError extends Error {
-    readonly errors: BuilderDataErrors;
-    constructor(errors: BuilderDataErrors);
-}
-export declare const validate: typeof validateData;
-declare function validateData(builder: BuilderValidated, builderData: BuilderData, options?: BuilderDataValidateOptions): BuilderDataValidateResult;
-export {};

package/dist/resolve/validate.js

@@ -1,47 +0,0 @@
-import { models } from './models.js';
-export class BuilderDataValidateError extends Error {
-    errors;
-    constructor(errors) {
-        super('data validation failed');
-        this.errors = errors;
-    }
-}
-export const validate = validateData;
-function validateData(builder, builderData, options) {
-    const expected = models(builder);
-    let errors = [];
-    Object.entries(expected).forEach(([component, expectedModels]) => {
-        const componentModels = builderData[component];
-        if (!componentModels) {
-            errors = [...errors, { kind: '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, { kind: 'invalid-variant', component, model: variant.model }];
-            }
-        });
-        expectedKeys.forEach((model, key) => {
-            if (!actualKeys.has(key)) {
-                errors = [...errors, { kind: 'missing-variant', component, model }];
-            }
-        });
-    });
-    Object.keys(builderData).forEach((component) => {
-        if (!expected[component]) {
-            errors = [...errors, { kind: 'unexpected-component', component }];
-        }
-    });
-    if (options?.strict && errors.length > 0) {
-        throw new BuilderDataValidateError(errors);
-    }
-    return [builderData, errors];
-}
-function sortedKey(model) {
-    const entries = Object.entries(model).filter(([, value]) => value != null);
-    return JSON.stringify(entries.sort(([keyA], [keyB]) => keyA.localeCompare(keyB)));
-}

package/dist/schemas/description.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,6 +0,0 @@
-export type { BuilderDescription, BuilderDescriptionItem } from './description';
-export { BuilderDescriptionItemSchema, BuilderDescriptionSchema } from './description.js';
-export type { BuilderPath, BuilderPaths, BuilderPrimitive, BuilderPrimitives } from './primitives';
-export { BuilderPathSchema, BuilderPathsSchema, BuilderPrimitiveSchema, BuilderPrimitivesSchema } from './primitives.js';
-export type { BuilderUICollection, BuilderUIDescribe, BuilderUIItem, BuilderUIItems, BuilderUIPage } from './ui';
-export { BuilderUICollectionSchema, BuilderUIDescribeSchema, BuilderUIItemSchema, BuilderUIItemsSchema, BuilderUIPageSchema } from './ui.js';

package/dist/schemas/index.js

@@ -1,3 +0,0 @@
-export { BuilderDescriptionItemSchema, BuilderDescriptionSchema } from './description.js';
-export { BuilderPathSchema, BuilderPathsSchema, BuilderPrimitiveSchema, BuilderPrimitivesSchema } from './primitives.js';
-export { BuilderUICollectionSchema, BuilderUIDescribeSchema, BuilderUIItemSchema, BuilderUIItemsSchema, BuilderUIPageSchema } from './ui.js';

package/dist/schemas/primitives.d.ts

@@ -1,9 +0,0 @@
-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/ui.d.ts

@@ -1,96 +0,0 @@
-import * as v from 'valibot';
-export declare const BuilderUIPageSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"page", undefined>;
-    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    readonly paths: 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)[])[]>]>;
-}, undefined>, v.ReadonlyAction<{
-    type: "page";
-    label: string | null;
-    readonly paths: readonly (readonly (string | number)[])[];
-}>]>;
-export type BuilderUIPage = v.InferOutput<typeof BuilderUIPageSchema>;
-export declare const BuilderUIDescribeSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"describe", undefined>;
-    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    readonly paths: 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)[])[]>]>;
-}, undefined>, v.ReadonlyAction<{
-    type: "describe";
-    label: string | null;
-    readonly paths: readonly (readonly (string | number)[])[];
-}>]>;
-export type BuilderUIDescribe = v.InferOutput<typeof BuilderUIDescribeSchema>;
-export type BuilderUICollection = {
-    readonly type: 'collection';
-    readonly name: string;
-    readonly label: string;
-    readonly items: BuilderUIItems;
-};
-export type BuilderUIItem = BuilderUIPage | BuilderUIDescribe | BuilderUICollection;
-export type BuilderUIItems = ReadonlyArray<BuilderUIItem>;
-type UIItemsSchemaType = v.GenericSchema<BuilderUIItems>;
-export declare const BuilderUICollectionSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"collection", undefined>;
-    readonly name: v.StringSchema<undefined>;
-    readonly label: v.StringSchema<undefined>;
-    readonly items: v.LazySchema<UIItemsSchemaType>;
-}, undefined>, v.ReadonlyAction<{
-    type: "collection";
-    name: string;
-    label: string;
-    items: BuilderUIItems;
-}>]>;
-export declare const BuilderUIItemSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"page", undefined>;
-    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    readonly paths: 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)[])[]>]>;
-}, undefined>, v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"describe", undefined>;
-    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    readonly paths: 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)[])[]>]>;
-}, undefined>, v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"collection", undefined>;
-    readonly name: v.StringSchema<undefined>;
-    readonly label: v.StringSchema<undefined>;
-    readonly items: v.LazySchema<UIItemsSchemaType>;
-}, undefined>], undefined>, v.ReadonlyAction<{
-    type: "page";
-    label: string | null;
-    readonly paths: readonly (readonly (string | number)[])[];
-} | {
-    type: "describe";
-    label: string | null;
-    readonly paths: readonly (readonly (string | number)[])[];
-} | {
-    type: "collection";
-    name: string;
-    label: string;
-    items: BuilderUIItems;
-}>]>;
-export declare const BuilderUIItemsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"page", undefined>;
-    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    readonly paths: 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)[])[]>]>;
-}, undefined>, v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"describe", undefined>;
-    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    readonly paths: 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)[])[]>]>;
-}, undefined>, v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"collection", undefined>;
-    readonly name: v.StringSchema<undefined>;
-    readonly label: v.StringSchema<undefined>;
-    readonly items: v.LazySchema<UIItemsSchemaType>;
-}, undefined>], undefined>, undefined>, v.ReadonlyAction<({
-    type: "page";
-    label: string | null;
-    readonly paths: readonly (readonly (string | number)[])[];
-} | {
-    type: "describe";
-    label: string | null;
-    readonly paths: readonly (readonly (string | number)[])[];
-} | {
-    type: "collection";
-    name: string;
-    label: string;
-    items: BuilderUIItems;
-})[]>]>;
-export {};

package/dist/schemas/ui.js

@@ -1,23 +0,0 @@
-import * as v from 'valibot';
-import { BuilderPathsSchema } from './primitives.js';
-const BuilderUIPageObject = v.object({
-    type: v.literal('page'),
-    label: v.nullable(v.string()),
-    paths: BuilderPathsSchema
-});
-const BuilderUIDescribeObject = v.object({
-    type: v.literal('describe'),
-    label: v.nullable(v.string()),
-    paths: BuilderPathsSchema
-});
-export const BuilderUIPageSchema = v.pipe(BuilderUIPageObject, v.readonly());
-export const BuilderUIDescribeSchema = v.pipe(BuilderUIDescribeObject, v.readonly());
-const BuilderUICollectionObject = v.object({
-    type: v.literal('collection'),
-    name: v.string(),
-    label: v.string(),
-    items: v.lazy(() => BuilderUIItemsSchema)
-});
-export const BuilderUICollectionSchema = v.pipe(BuilderUICollectionObject, v.readonly());
-export const BuilderUIItemSchema = v.pipe(v.variant('type', [BuilderUIPageObject, BuilderUIDescribeObject, BuilderUICollectionObject]), v.readonly());
-export const BuilderUIItemsSchema = v.pipe(v.array(v.variant('type', [BuilderUIPageObject, BuilderUIDescribeObject, BuilderUICollectionObject])), v.readonly());

package/dist/serialise/deserialise.d.ts

@@ -1,14 +0,0 @@
-import type { BuilderGeneric } from '../core/index';
-import type { BuilderUIGeneric } from '../ui';
-import type { BuilderSelectTypeSerialised } from './schemas';
-import { Builder, BuilderSelectType } from '../core/index.js';
-export declare const deserialise: {
-    builder: typeof deserialiseBuilder;
-    select: typeof deserialiseSelect;
-    ui: typeof deserialiseUI;
-    validate: (data: unknown, options?: import("./validate.js").BuilderSerialisedValidateOptions) => import("./validate.js").BuilderSerialisedValidateResult;
-};
-declare function deserialiseBuilder(data: unknown): Builder;
-declare function deserialiseUI(builder: BuilderGeneric, data: unknown): BuilderUIGeneric;
-declare function deserialiseSelect(data: BuilderSelectTypeSerialised): BuilderSelectType;
-export {};