@builder-builder/builder 0.0.9 → 0.0.11

package/dist/entities/builder/builders.js

@@ -1,18 +0,0 @@
-import * as v from 'valibot';
-import { isRef } from '../../references.js';
-import { Builder, BuilderSchema } from './builder.js';
-export function builders(...builders) {
-    const references = builders.filter((payload) => isRef(payload));
-    const merged = mergeBuilderParts(builders);
-    return new Builder([...references, ...merged.references], merged.options, merged.components, merged.collections, merged.expectations);
-}
-export function mergeBuilderParts(parts) {
-    const instances = parts.filter((part) => v.is(BuilderSchema, part));
-    return {
-        references: instances.flatMap((builder) => [...builder.references]),
-        options: instances.flatMap((builder) => [...builder.options]),
-        components: instances.flatMap((builder) => [...builder.components]),
-        collections: instances.flatMap((builder) => [...builder.collections]),
-        expectations: instances.flatMap((builder) => [...builder.expectations])
-    };
-}

package/dist/entities/builder/expectation.d.ts

@@ -1,12 +0,0 @@
-import type { Prettify } from '../../prettify';
-import type { CollectionsAsserted } from '../collection/index';
-import type { ComponentAsserted } from '../component/index';
-import type { BuilderExpectation, BuilderExpectations } from '../expectation';
-import type { BuilderState, BuilderStateAppend } from './state';
-export type BuilderStateAsserted<State extends BuilderState, Expectations extends BuilderExpectations> = BuilderStateAppend<State, {
-    model: ModelAsserted<State, Expectations>;
-    components: ComponentAsserted<State, Expectations>;
-    collections: CollectionsAsserted<State, Expectations>;
-}>;
-export type ModelExpected<Expectations extends BuilderExpectations> = Expectations extends readonly [infer Head, ...infer Tail extends BuilderExpectations] ? (Head extends BuilderExpectation<infer Name, infer Value, 'option'> ? Record<Name, Value> : Head extends BuilderExpectation<infer Name, any, 'collection'> ? Record<Name, ReadonlyArray<unknown>> : unknown) & ModelExpected<Tail> : unknown;
-export type ModelAsserted<State extends BuilderState, Expectations extends BuilderExpectations, Current extends State['model'] = State['model'], Asserted extends ModelExpected<Expectations> = ModelExpected<Expectations>> = unknown extends Current ? Prettify<Asserted> : Prettify<Current & Asserted>;

package/dist/entities/builder/methods.d.ts

@@ -1,58 +0,0 @@
-import type { BuilderPaths } from '../../paths';
-import type { BuilderRef, Refable } from '../../references';
-import type { WhenConfigPayload } from '../when';
-import type { BuilderCollectionConfig, BuilderCollectionWhen } from '../collection/index';
-import type { BuilderComponentDetails, BuilderComponentWhen } from '../component/index';
-import type { BuilderOptionValues, BuilderOptionWhen } from '../option/index';
-import type { BuilderValidPaths, BuilderWhenConstrained, WhenNullability } from '../when';
-import type { Builder } from './builder';
-import type { BuilderState, BuilderStateAppend } from './state';
-import { BuilderCollection } from '../collection/index.js';
-import { BuilderComponent } from '../component/index.js';
-import { BuilderOption } from '../option/index.js';
-export type BuilderOptionMethod<State extends BuilderState> = {
-    <const Name extends string, const Payload extends Refable<BuilderOptionValues>>(name: Name, payload: Payload): OptionStateAppend<State, BuilderOption<Name, Payload>>;
-    when: <const GatePaths extends Refable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Refable<BuilderOptionWhen>>(gatePaths: GatePaths, name: Name, payload: Payload & BuilderWhenConstrained<State, Payload>) => OptionStateAppend<State, OptionWhenResolver<Name, Payload>, OptionModelOf<OptionWhenResolver<Name, Payload>> | WhenNullability<State, GatePaths, Payload>>;
-};
-export type BuilderComponentMethod<State extends BuilderState> = {
-    <const Name extends string, const Payload extends Refable<BuilderComponentDetails>>(name: Name, payload?: Payload): ComponentStateAppend<State, BuilderComponent<Name, Payload>>;
-    when: <const GatePaths extends Refable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Refable<BuilderComponentWhen>>(gatePaths: GatePaths, name: Name, payload?: Payload & BuilderWhenConstrained<State, Payload>) => ComponentStateAppend<State, ComponentWhenResolver<Name, Payload>>;
-};
-export type BuilderCollectionMethod<State extends BuilderState> = {
-    <const Name extends string, const Payload extends Refable<BuilderCollectionConfig>>(name: Name, payload: Payload): CollectionStateAppend<State, BuilderCollection<Name, Payload>>;
-    when: <const GatePaths extends Refable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Refable<BuilderCollectionWhen>>(gatePaths: GatePaths, name: Name, payload: Payload & BuilderWhenConstrained<State, Payload>) => CollectionStateAppend<State, CollectionWhenResolver<Name, Payload>, CollectionModelOf<CollectionWhenResolver<Name, Payload>> | WhenNullability<State, GatePaths, Payload>>;
-};
-type OptionWhenResolver<Name extends string, Payload extends Refable<BuilderOptionWhen>> = Payload extends BuilderOptionWhen ? BuilderOption<Name, WhenConfigPayload<Payload, BuilderOptionValues>> : BuilderOption<Name, BuilderRef>;
-type ComponentWhenResolver<Name extends string, Payload extends Refable<BuilderComponentWhen>> = Payload extends BuilderComponentWhen ? BuilderComponent<Name, WhenConfigPayload<Payload, BuilderComponentDetails>> : BuilderComponent<Name, BuilderRef>;
-type CollectionWhenResolver<Name extends string, Payload extends Refable<BuilderCollectionWhen>> = Payload extends BuilderCollectionWhen ? BuilderCollection<Name, WhenConfigPayload<Payload, BuilderCollectionConfig>> : BuilderCollection<Name, BuilderRef>;
-type OptionStateAppend<State extends BuilderState, Option extends BuilderOption, ModelType = OptionModelOf<Option>> = Builder<BuilderStateAppend<State, {
-    model: State['model'] & {
-        [K in Option['name']]: ModelType;
-    };
-    options: [...State['options'], Option];
-}>>;
-type ComponentStateAppend<State extends BuilderState, Component extends BuilderComponent> = Builder<BuilderStateAppend<State, {
-    components: [...State['components'], Component];
-}>>;
-type CollectionStateAppend<State extends BuilderState, Collection extends BuilderCollection, ModelType = CollectionModelOf<Collection>> = Builder<BuilderStateAppend<State, {
-    model: State['model'] & Record<Collection['name'], ModelType>;
-    collections: [...State['collections'], Collection];
-}>>;
-type OptionModelOf<Option extends BuilderOption> = Option['payload'] extends BuilderRef ? string : Option['payload'] extends {
-    readonly value: infer Value;
-} ? Value : never;
-type CollectionModelOf<Collection extends BuilderCollection> = [Collection['payload']] extends [
-    never
-] ? null : Collection['payload'] extends BuilderCollectionConfig ? Collection['payload']['builder'] extends Builder<infer State extends BuilderState> ? CollectionShape<Collection, State['model']> : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
-type CollectionShape<Collection extends BuilderCollection, Item> = Collection['payload'] extends BuilderCollectionConfig ? Collection['payload']['min'] extends number ? Collection['payload']['max'] extends number ? number extends Collection['payload']['min'] ? ReadonlyArray<Item> : number extends Collection['payload']['max'] ? ReadonlyArray<Item> : Collection['payload']['min'] extends Collection['payload']['max'] ? CollectionTuple<Item, Collection['payload']['min']> : ReadonlyArray<Item> : ReadonlyArray<Item> : ReadonlyArray<Item> : ReadonlyArray<Item>;
-type CollectionTuple<Item, Length extends number, Result extends ReadonlyArray<Item> = []> = Result['length'] extends Length ? Result : CollectionTuple<Item, Length, [...Result, Item]>;
-export declare function builderOptionMethod(): ((name: string, payload: Refable<BuilderOptionValues>) => BuilderOption<string, Refable<import("..").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("..").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, Refable<readonly (readonly (string | number)[])[]>>) & {
-    when(gatePaths: Refable<BuilderPaths>, name: string, payload: Refable<BuilderOptionWhen>): BuilderOption<string, Refable<BuilderOptionWhen>, readonly (readonly (string | number)[])[] | BuilderRef>;
-};
-export declare function builderComponentMethod(): ((name: string, payload?: Refable<BuilderComponentDetails>) => BuilderComponent<string, Refable<BuilderComponentDetails<Refable<readonly import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[]>>> | import("../when").BuilderEnableConfig<Refable<BuilderComponentDetails<Refable<readonly import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[]>>>>, Refable<readonly (readonly (string | number)[])[]>>) & {
-    when(gatePaths: Refable<BuilderPaths>, name: string, payload?: Refable<BuilderComponentWhen>): BuilderComponent<string, Refable<BuilderComponentWhen>, readonly (readonly (string | number)[])[] | BuilderRef>;
-};
-export declare function builderCollectionMethod(): ((name: string, payload: Refable<BuilderCollectionConfig>) => BuilderCollection<string, Refable<BuilderCollectionConfig<Refable<import("./builder").BuilderGeneric>, Refable<number>, Refable<number>>>, Refable<readonly (readonly (string | number)[])[]>>) & {
-    when(gatePaths: Refable<BuilderPaths>, name: string, payload: Refable<BuilderCollectionWhen>): BuilderCollection<string, Refable<BuilderCollectionWhen>, readonly (readonly (string | number)[])[] | BuilderRef>;
-};
-export {};

package/dist/entities/builder/parameter.d.ts

@@ -1,62 +0,0 @@
-import type { BuilderPaths } from '../../paths';
-import type { BuilderRef, Refable } from '../../references';
-import type { BuilderCollectionPayload } from '../collection/index';
-import type { BuilderComponentPayload } from '../component/index';
-import type { BuilderOptionPayload } from '../option/index';
-import type { BuilderWhenConfig, BuilderWhenConstrained, WhenConfigNullable } from '../when';
-import type { BuilderState, BuilderStateAppend } from './state';
-import { Builder } from './builder.js';
-type ParameterNamesOf<Entries extends ReadonlyArray<EntryLike>> = EntryParameters<Entries>['name'];
-type PayloadForParameter<State extends BuilderState, Name extends string> = Name extends ParameterNamesOf<State['options']> ? BuilderOptionPayload : Name extends ParameterNamesOf<State['collections']> ? BuilderCollectionPayload : Name extends ParameterNamesOf<State['components']> ? BuilderComponentPayload : never;
-export type BuilderBindings<State extends BuilderState> = {
-    readonly [Name in ParameterNamesOf<State['options']> | ParameterNamesOf<State['collections']> | ParameterNamesOf<State['components']>]: BuilderWhenConstrained<State, PayloadForParameter<State, Name>>;
-};
-export declare function bindBuilder<State extends BuilderState, Bindings extends BuilderBindings<State>>(builder: Builder<State>, bindings: Bindings): Builder<BuilderBoundState<State, Bindings>>;
-export type BuilderBoundState<State extends BuilderState, Bindings extends BuilderBindings<State>> = BuilderStateAppend<State, {
-    options: EntryBound<State['options'], Extract<keyof Bindings, string>>;
-    collections: EntryBound<State['collections'], Extract<keyof Bindings, string>>;
-    components: EntryBound<State['components'], Extract<keyof Bindings, string>>;
-    model: Omit<State['model'], keyof Bindings> & {
-        [K in Extract<keyof Bindings, string>]: BindingModelType<Bindings[K]>;
-    };
-}>;
-export type BindingModelType<Binding> = BindingValueType<Binding> | BindingConfigNullable<Binding>;
-type BindingValueType<Binding> = Binding extends {
-    readonly type: 'match';
-    readonly selectMap: infer SelectMap extends Record<string, unknown>;
-} ? NonNullable<SelectMap[keyof SelectMap]> extends {
-    readonly value: infer Value;
-} ? Value : string : Binding extends {
-    readonly payload: {
-        readonly value: infer Value;
-    };
-} ? Value : Binding extends {
-    readonly value: infer Value;
-} ? Value : string;
-type BindingConfigNullable<Binding> = Binding extends BuilderWhenConfig ? WhenConfigNullable<Binding> : never;
-type EntryLike = {
-    readonly name: string;
-    readonly payload: unknown;
-    readonly gatePaths?: Refable<BuilderPaths>;
-};
-type EntryBound<Entries extends ReadonlyArray<EntryLike>, BoundNames extends string> = Entries extends readonly [
-    infer Head extends EntryLike,
-    ...infer Tail extends ReadonlyArray<EntryLike>
-] ? Head extends {
-    readonly payload: infer Payload;
-} ? Payload extends BuilderRef ? Head['name'] extends BoundNames ? [...EntryBound<Tail, BoundNames>] : [Head, ...EntryBound<Tail, BoundNames>] : [Head, ...EntryBound<Tail, BoundNames>] : [Head, ...EntryBound<Tail, BoundNames>] : [];
-type EntryParameters<Entries extends ReadonlyArray<EntryLike>> = Entries[number] extends infer Entry ? Entry extends {
-    readonly payload: infer Payload;
-} ? PayloadParameters<Payload> : never : never;
-type PayloadParameters<Payload> = ParameterOf<Payload> | (Payload extends {
-    readonly type: 'match';
-    readonly selectMap: infer SelectMap;
-} ? ParameterOf<SelectMap[keyof SelectMap]> : never) | (Payload extends {
-    readonly type: 'enable' | 'unless';
-    readonly payload: infer Inner;
-} ? ParameterOf<Inner> : never);
-type ParameterOf<Value> = Extract<Value, BuilderRef> extends infer Ref extends BuilderRef ? {
-    readonly name: Ref['name'];
-    readonly payload: Ref;
-} : never;
-export {};

package/dist/entities/builder/parameter.js

@@ -1,18 +0,0 @@
-import * as v from 'valibot';
-import { isRef } from '../../references.js';
-import { createWalkerBinding } from '../../walker/index.js';
-import { Builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';
-import { mergeBuilderParts } from './builders.js';
-export function bindBuilder(builder, bindings) {
-    const { expectations, references } = builder;
-    const bindingEntries = Object.entries(bindings);
-    const boundNames = new Set(bindingEntries.filter(([, value]) => v.is(BuilderSchema, value)).map(([name]) => name));
-    const remainingReferences = references.filter((reference) => !isRef(reference) || !boundNames.has(reference.name));
-    const bindingLookup = bindings;
-    const walkBind = createWalkerBinding({
-        lookupBinding: (ref) => bindingLookup[ref.name]
-    });
-    const walked = walkBind(BuilderSerialisedSchema, builder);
-    const merged = mergeBuilderParts(bindingEntries.map(([, value]) => value));
-    return new Builder([...remainingReferences, ...merged.references], [...walked.options, ...merged.options], [...walked.components, ...merged.components], [...walked.collections, ...merged.collections], [...expectations, ...merged.expectations]);
-}

package/dist/entities/builder/validate.d.ts

@@ -1,3 +0,0 @@
-import type { BuilderGeneric } from './builder';
-export declare function validateDuplicates(builder: BuilderGeneric): void;
-export declare function validatePaths(builder: BuilderGeneric): void;

package/dist/entities/builder/validate.js

@@ -1,108 +0,0 @@
-import * as v from 'valibot';
-import { BuilderException } from '../../exception.js';
-import { isRef } from '../../references.js';
-import { BuilderCollectionConfigSchema } from '../collection/index.js';
-import { BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../when.js';
-export function validateDuplicates(builder) {
-    const kinds = [
-        { entryKind: 'option', entries: builder.options },
-        { entryKind: 'component', entries: builder.components },
-        { entryKind: 'collection', entries: builder.collections }
-    ];
-    const errors = kinds.flatMap(({ entryKind, entries }) => {
-        const seen = new Set();
-        return entries.flatMap((entry) => {
-            if (seen.has(entry.name)) {
-                return [{ kind: 'duplicate-name', entryKind, name: entry.name }];
-            }
-            seen.add(entry.name);
-            return [];
-        });
-    });
-    if (errors.length > 0) {
-        throw new BuilderException(errors);
-    }
-}
-export function validatePaths(builder) {
-    const errors = collectPathErrors(builder);
-    if (errors.length > 0) {
-        throw new BuilderException(errors);
-    }
-}
-function collectPathErrors(builder) {
-    if (builder.expectations.length > 0) {
-        return [];
-    }
-    const allEntries = [...builder.options, ...builder.components, ...builder.collections];
-    return allEntries.flatMap((entry) => pathsForEntry(entry).flatMap((path) => collectEntryPathErrors(builder, entry.name, path)));
-}
-function pathsForEntry(entry) {
-    const gatePaths = entry.gatePaths != null && !isRef(entry.gatePaths)
-        ? entry.gatePaths
-        : [];
-    const configPaths = pathsFromWhen(entry.payload);
-    return [...gatePaths, ...configPaths];
-}
-function pathsFromWhen(payload) {
-    if (v.is(BuilderWhenMatchSchema, payload)) {
-        const matchPath = payload.matchPath;
-        return isRef(matchPath) ? [] : [matchPath];
-    }
-    if (v.is(BuilderWhenUnlessSchema, payload)) {
-        const unlessPath = payload.unlessPath;
-        return isRef(unlessPath) ? [] : [unlessPath];
-    }
-    return [];
-}
-function collectEntryPathErrors(builder, entryName, path) {
-    const collectionSegments = path.slice(0, -1);
-    const optionName = path.at(-1);
-    const reached = traverseCollections([builder], collectionSegments);
-    if (reached === null) {
-        return [{ kind: 'invalid-gate-path', name: entryName, path }];
-    }
-    const anyHasOption = reached.some((current) => current.options.some((option) => option.name === optionName));
-    return anyHasOption ? [] : [{ kind: 'invalid-gate-path', name: entryName, path }];
-}
-function traverseCollections(candidates, remaining) {
-    if (remaining.length === 0) {
-        return candidates;
-    }
-    const [collectionName, index, ...rest] = remaining;
-    if (!v.is(v.string(), collectionName) || !v.is(v.number(), index)) {
-        return null;
-    }
-    const descents = candidates.map((current) => descendCollection(current, collectionName, index));
-    if (descents.some((descent) => descent === null)) {
-        return null;
-    }
-    const nextCandidates = descents.flatMap((descent) => descent ?? []);
-    if (nextCandidates.length === 0) {
-        return null;
-    }
-    return traverseCollections(nextCandidates, rest);
-}
-function descendCollection(builder, collectionName, index) {
-    const collection = builder.collections.find((entry) => entry.name === collectionName);
-    if (!collection) {
-        return [];
-    }
-    const configs = possibleConfigs(collection.payload);
-    const withinBounds = configs.filter((config) => isRef(config.max) || index < config.max);
-    if (withinBounds.length === 0 && configs.length > 0) {
-        return null;
-    }
-    return withinBounds.flatMap((config) => (isRef(config.builder) ? [] : [config.builder]));
-}
-function possibleConfigs(payload) {
-    if (isRef(payload)) {
-        return [];
-    }
-    if (v.is(BuilderCollectionConfigSchema, payload)) {
-        return [payload];
-    }
-    if (payload.type === 'match') {
-        return Object.values(payload.selectMap).flatMap((value) => v.is(BuilderCollectionConfigSchema, value) ? [value] : []);
-    }
-    return v.is(BuilderCollectionConfigSchema, payload.payload) ? [payload.payload] : [];
-}

package/dist/entities/errors.d.ts

@@ -1,21 +0,0 @@
-import type { BuilderPath } from '../paths';
-import type { BuilderExpectationKind } from './expectation';
-export type BuilderErrorUnmetExpectation = {
-    readonly kind: 'unmet-expectation';
-    readonly expectationKind: BuilderExpectationKind;
-    readonly name: string;
-};
-export type BuilderErrorUnboundParameter = {
-    readonly kind: 'unbound-parameter';
-    readonly name: string;
-};
-export type BuilderErrorInvalidGatePath = {
-    readonly kind: 'invalid-gate-path';
-    readonly name: string;
-    readonly path: BuilderPath;
-};
-export type BuilderErrorDuplicateName = {
-    readonly kind: 'duplicate-name';
-    readonly entryKind: 'option' | 'component' | 'collection';
-    readonly name: string;
-};

package/dist/entities/ui/label.d.ts

@@ -1,18 +0,0 @@
-import * as v from 'valibot';
-export declare class BuilderUILabel<const Label extends string = string> {
-    readonly type: 'label';
-    readonly label: Label;
-    constructor(label: Label);
-}
-export declare const BuilderUILabelSchema: v.InstanceSchema<typeof BuilderUILabel, undefined>;
-export declare const BuilderUILabelSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly label: v.StringSchema<undefined>;
-}, undefined>, v.MetadataAction<{
-    label: string;
-}, {
-    readonly serialisable: typeof BuilderUILabel;
-    readonly instance: v.InstanceSchema<typeof BuilderUILabel, undefined>;
-}>, v.ReadonlyAction<{
-    label: string;
-}>]>;
-export type BuilderUILabelSerialised = v.InferOutput<typeof BuilderUILabelSerialisedSchema>;

package/dist/entities/ui/label.js

@@ -1,12 +0,0 @@
-import * as v from 'valibot';
-import { serialisable } from '../../serialisable.js';
-export class BuilderUILabel {
-    label;
-    constructor(label) {
-        this.label = label;
-    }
-}
-export const BuilderUILabelSchema = v.instance(BuilderUILabel);
-export const BuilderUILabelSerialisedSchema = serialisable(BuilderUILabel, v.object({
-    label: v.string()
-}));

package/dist/entities/ui/parameter.d.ts

@@ -1,7 +0,0 @@
-import type { Refable } from '../../references';
-import type { BuilderGeneric } from '../builder/index';
-import type { BuilderUIItems } from './pages';
-import type { BuilderUIGeneric } from './ui';
-import { BuilderUI } from './ui.js';
-export type BuilderUIBindings = Record<string, string | BuilderUIGeneric | BuilderUIItems | unknown>;
-export declare function bindUI<BuilderType extends Refable<BuilderGeneric>>(ui: BuilderUI<BuilderType>, bindings: BuilderUIBindings): BuilderUI<BuilderType>;

package/dist/entities/ui/parameter.js

@@ -1,29 +0,0 @@
-import * as v from 'valibot';
-import { createWalkerBinding } from '../../walker/index.js';
-import { BuilderUILabel } from './label.js';
-import { BuilderUIItemsSerialisedSchema } from './pages.js';
-import { BuilderUI, BuilderUISchema } from './ui.js';
-import { mergeUIParts } from './uis.js';
-export function bindUI(ui, bindings) {
-    const merged = mergeUIParts(Object.values(bindings));
-    const walk = createWalkerBinding({
-        lookupBinding: (ref) => {
-            const binding = bindings[ref.name];
-            if (binding == null) {
-                return null;
-            }
-            if (typeof binding === 'string') {
-                return new BuilderUILabel(binding);
-            }
-            if (v.is(BuilderUISchema, binding)) {
-                return [...binding.items];
-            }
-            return binding;
-        }
-    });
-    const boundItems = walk(BuilderUIItemsSerialisedSchema, ui.items);
-    return new BuilderUI(ui.builder, [...ui.references, ...merged.references], boundItems, [
-        ...ui.expectations,
-        ...merged.expectations
-    ]);
-}

package/dist/entities/ui/validate.d.ts

@@ -1,8 +0,0 @@
-import type { Refable } from '../../references';
-import type { BuilderGeneric } from '../builder/index';
-import type { BuilderUIItems } from './pages';
-export type BuilderErrorPagesUnknownCollection = {
-    readonly kind: 'pages-unknown-collection';
-    readonly name: string;
-};
-export declare function validatePagesCollections(builder: Refable<BuilderGeneric>, items: Refable<BuilderUIItems>): void;

package/dist/entities/ui/validate.js

@@ -1,21 +0,0 @@
-import { BuilderException } from '../../exception.js';
-import { isRef } from '../../references.js';
-import { BuilderUIPages } from './pages.js';
-export function validatePagesCollections(builder, items) {
-    if (isRef(builder) || isRef(items)) {
-        return;
-    }
-    const errors = items.flatMap((item) => {
-        if (isRef(item) || !(item instanceof BuilderUIPages)) {
-            return [];
-        }
-        const exists = builder.collections.some((entry) => entry.name === item.name);
-        if (exists) {
-            return [];
-        }
-        return [{ kind: 'pages-unknown-collection', name: item.name }];
-    });
-    if (errors.length > 0) {
-        throw new BuilderException(errors);
-    }
-}

package/dist/entities/validate.d.ts

@@ -1,28 +0,0 @@
-import type { BuilderExpectation } from './expectation';
-import type { BuilderRef } from '../references';
-import type { Builder, BuilderGeneric } from './builder/index';
-import type { BuilderCollection, BuilderCollectionConfig } from './collection/index';
-import type { BuilderComponent, BuilderComponentDetails } from './component/index';
-import type { BuilderOption, BuilderSelectType, BuilderToggleType } from './option/index';
-import type { BuilderUI, BuilderUIDescribe, BuilderUIGeneric, BuilderUIItem, BuilderUIItems, BuilderUILabel, BuilderUIPage, BuilderUIPages } from './ui/index';
-export type Strip<T> = T extends BuilderRef ? never : T extends BuilderSelectType | BuilderToggleType | BuilderUILabel | BuilderExpectation ? T : T extends Builder<infer State> ? Builder<Strip<State>> : T extends BuilderOption<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderOption<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderComponent<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderComponent<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderCollection<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderCollection<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderCollectionConfig<infer Inner, infer Min, infer Max> ? BuilderCollectionConfig<Strip<Inner>, Strip<Min>, Strip<Max>> : T extends BuilderComponentDetails<infer Expectations> ? BuilderComponentDetails<Strip<Expectations>> : T extends BuilderUI<infer Inner, infer Items> ? BuilderUI<Strip<Inner>, Strip<Items> & BuilderUIItems> : T extends BuilderUIPage<infer Label, infer Paths> ? BuilderUIPage<Strip<Label>, Strip<Paths>> : T extends BuilderUIDescribe<infer Label, infer Paths> ? BuilderUIDescribe<Strip<Label>, Strip<Paths>> : T extends BuilderUIPages<infer Name, infer Label, infer Items> ? BuilderUIPages<Name, Strip<Label>, Strip<Items>> : T extends ReadonlyArray<unknown> ? StripTuple<T> : T extends object ? {
-    readonly [Key in keyof T]: Strip<T[Key]>;
-} : T;
-type StripEntry<Narrowed, Payload, GatePaths> = [Strip<Payload>] extends [never] ? never : [Strip<GatePaths>] extends [never] ? never : Narrowed;
-export type StripTuple<T extends ReadonlyArray<unknown>> = T extends readonly [
-    infer Head,
-    ...infer Rest extends ReadonlyArray<unknown>
-] ? [Strip<Head>] extends [never] ? StripTuple<Rest> : readonly [Strip<Head>, ...StripTuple<Rest>] : T extends readonly [] ? readonly [] : ReadonlyArray<Strip<T[number]>>;
-export type BuilderValidated = Strip<BuilderGeneric>;
-export type BuilderOptionValidated = Strip<BuilderOption>;
-export type BuilderOptionsValidated = ReadonlyArray<BuilderOptionValidated>;
-export type BuilderComponentValidated = Strip<BuilderComponent>;
-export type BuilderComponentsValidated = ReadonlyArray<BuilderComponentValidated>;
-export type BuilderComponentDetailsValidated = Strip<BuilderComponentDetails>;
-export type BuilderCollectionValidated = Strip<BuilderCollection>;
-export type BuilderCollectionsValidated = ReadonlyArray<BuilderCollectionValidated>;
-export type BuilderCollectionConfigValidated = Strip<BuilderCollectionConfig>;
-export type BuilderUIValidated = Strip<BuilderUIGeneric>;
-export type BuilderUIItemValidated = Strip<BuilderUIItem>;
-export type BuilderUIItemsValidated = Strip<BuilderUIItems>;
-export {};

package/dist/mappers/assert/builder.d.ts

@@ -1,2 +0,0 @@
-import type { BuilderGeneric, Strip } from '../../entities/index';
-export declare function assertBuilder<Input extends BuilderGeneric>(builder: Input): asserts builder is Input & Strip<Input>;

package/dist/mappers/assert/builder.js

@@ -1,46 +0,0 @@
-import * as v from 'valibot';
-import { BuilderCollectionConfigSchema, BuilderSerialisedSchema } from '../../entities/index.js';
-import { BuilderException } from '../../exception.js';
-import { isRef } from '../../references.js';
-import { createWalkerValidation } from '../../walker/index.js';
-import { collectExpectationErrors } from './expectation.js';
-export function assertBuilder(builder) {
-    const errors = collectBuilderErrors(builder);
-    if (errors.length > 0) {
-        throw new BuilderException(errors);
-    }
-}
-function collectBuilderErrors(builder) {
-    const expectationErrors = collectNestedBuilders(builder).flatMap((inner) => collectExpectationErrors(inner, inner.expectations));
-    const parameterErrors = [];
-    const walkValidate = createWalkerValidation((ref) => {
-        parameterErrors.push({ kind: 'unbound-parameter', name: ref.name });
-    });
-    walkValidate(BuilderSerialisedSchema, builder);
-    const referenceErrors = builder.references
-        .filter(isRef)
-        .map((reference) => ({ kind: 'unbound-parameter', name: reference.name }));
-    return [...expectationErrors, ...referenceErrors, ...parameterErrors];
-}
-function collectNestedBuilders(builder) {
-    const nested = builder.collections.flatMap((collection) => nestedBuildersOf(collection.payload));
-    return [builder, ...nested.flatMap((inner) => collectNestedBuilders(inner))];
-}
-function nestedBuildersOf(payload) {
-    if (isRef(payload)) {
-        return [];
-    }
-    if (v.is(BuilderCollectionConfigSchema, payload)) {
-        return isRef(payload.builder) ? [] : [payload.builder];
-    }
-    const whenPayload = payload;
-    if (whenPayload.type === 'match' && whenPayload.selectMap != null) {
-        return Object.values(whenPayload.selectMap).flatMap((value) => value && !isRef(value.builder) ? [value.builder] : []);
-    }
-    const inner = whenPayload.payload;
-    if (inner == null || isRef(inner)) {
-        return [];
-    }
-    const innerBuilder = inner.builder;
-    return isRef(innerBuilder) ? [] : [innerBuilder];
-}

package/dist/mappers/assert/expectation.d.ts

@@ -1,2 +0,0 @@
-import type { BuilderErrorUnmetExpectation, BuilderExpectations, BuilderGeneric } from '../../entities/index';
-export declare function collectExpectationErrors(builder: BuilderGeneric, expectations: BuilderExpectations): ReadonlyArray<BuilderErrorUnmetExpectation>;

package/dist/mappers/assert/expectation.js

@@ -1,23 +0,0 @@
-export function collectExpectationErrors(builder, expectations) {
-    return expectations.flatMap((expectation) => {
-        if (expectation.kind === 'detail') {
-            return [];
-        }
-        const lookup = expectation.kind === 'option'
-            ? builder.options
-            : expectation.kind === 'component'
-                ? builder.components
-                : builder.collections;
-        const exists = lookup.some((entry) => entry.name === expectation.name);
-        if (exists) {
-            return [];
-        }
-        return [
-            {
-                kind: 'unmet-expectation',
-                expectationKind: expectation.kind,
-                name: expectation.name
-            }
-        ];
-    });
-}

package/dist/mappers/assert/index.d.ts

@@ -1,6 +0,0 @@
-export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption } from './model';
-export type { BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail } from './models';
-export { assertBuilder } from './builder.js';
-export { assertModel } from './model.js';
-export { assertModels } from './models.js';
-export { assertUI } from './ui.js';

package/dist/mappers/assert/index.js

@@ -1,4 +0,0 @@
-export { assertBuilder } from './builder.js';
-export { assertModel } from './model.js';
-export { assertModels } from './models.js';
-export { assertUI } from './ui.js';

package/dist/mappers/assert/model.d.ts

@@ -1,13 +0,0 @@
-import type { BuilderValidated } from '../../entities/index';
-import type { BuilderModel } from '../../model';
-export type BuilderErrorInvalidOption = {
-    readonly kind: 'invalid-option';
-    readonly name: string;
-    readonly value: unknown;
-};
-export type BuilderErrorInvalidCollection = {
-    readonly kind: 'invalid-collection';
-    readonly name: string;
-    readonly detail: string;
-};
-export declare function assertModel(builder: BuilderValidated, model: BuilderModel): void;

package/dist/mappers/assert/model.js

@@ -1,47 +0,0 @@
-import * as v from 'valibot';
-import { BuilderException } from '../../exception.js';
-import { resolveCollection, resolveOption } from '../resolve.js';
-export function assertModel(builder, model) {
-    const errors = collectModelErrors(builder.options, builder.collections, model);
-    if (errors.length > 0) {
-        throw new BuilderException(errors);
-    }
-}
-function collectModelErrors(options, collections, model) {
-    const optionErrors = options.flatMap((entry) => {
-        const option = resolveOption(entry, model);
-        if (!option) {
-            return [];
-        }
-        const value = model[option.name];
-        if (!v.is(option.payload.valueSchema, value)) {
-            return [{ kind: 'invalid-option', name: option.name, value }];
-        }
-        return [];
-    });
-    const collectionErrors = collections.flatMap((entry) => {
-        const collection = resolveCollection(entry, model);
-        if (!collection) {
-            return [];
-        }
-        const existing = model[collection.name];
-        if (!Array.isArray(existing)) {
-            return [
-                {
-                    kind: 'invalid-collection',
-                    name: collection.name,
-                    detail: 'expected an array'
-                }
-            ];
-        }
-        const nestedBuilder = collection.payload.builder;
-        return existing.flatMap((itemModel, index) => {
-            const nestedErrors = collectModelErrors(nestedBuilder.options, nestedBuilder.collections, itemModel);
-            return nestedErrors.map((error) => ({
-                ...error,
-                name: `${collection.name}[${String(index)}].${error.name}`
-            }));
-        });
-    });
-    return [...optionErrors, ...collectionErrors];
-}

package/dist/mappers/assert/models.d.ts

@@ -1,33 +0,0 @@
-import type { BuilderValidated } from '../../entities/index';
-import type { BuilderData, BuilderModel } from '../../model';
-export type BuilderErrorMissingComponent = {
-    readonly kind: 'missing-component';
-    readonly component: string;
-};
-export type BuilderErrorUnexpectedComponent = {
-    readonly kind: 'unexpected-component';
-    readonly component: string;
-};
-export type BuilderErrorMissingVariant = {
-    readonly kind: 'missing-variant';
-    readonly component: string;
-    readonly model: BuilderModel;
-};
-export type BuilderErrorInvalidVariant = {
-    readonly kind: 'invalid-variant';
-    readonly component: string;
-    readonly model: BuilderModel;
-};
-export type BuilderErrorMissingDetail = {
-    readonly kind: 'missing-detail';
-    readonly component: string;
-    readonly detail: string;
-    readonly model: BuilderModel;
-};
-export type BuilderErrorUnexpectedDetail = {
-    readonly kind: 'unexpected-detail';
-    readonly component: string;
-    readonly detail: string;
-    readonly model: BuilderModel;
-};
-export declare function assertModels(builder: BuilderValidated, builderData: BuilderData): void;