@builder-builder/builder 0.0.7 → 0.0.9

package/dist/core/option/method.d.ts

@@ -1,70 +0,0 @@
-import type { BuilderPrimitive } from '../../model';
-import type { BuilderPath, BuilderResolvePath, BuilderValidPath, BuilderValidPaths } from '../../paths';
-import type { BuilderMerge, BuilderState } from '../builder';
-import type { BuilderWhenEnableConfig, BuilderWhenMatchConfig, BuilderWhenUnlessConfig, WhenNullability, WhenPathsNullable } from '../when/index';
-import type { BuilderOption, BuilderOptionValueType, BuilderOptionValues, BuilderOptionValuesMap } from './option';
-import { BuilderParameter } from '../parameter.js';
-export type BuilderOptionEnableConfig<Values extends BuilderOptionValues | BuilderParameter = BuilderOptionValues | BuilderParameter> = BuilderWhenEnableConfig<OptionPayload<Values>>;
-export type BuilderOptionMatchConfig<SelectMap extends BuilderOptionValuesMap | BuilderParameter = BuilderOptionValuesMap | BuilderParameter, MatchPath extends BuilderPath = BuilderPath> = BuilderWhenMatchConfig<SelectMap, MatchPath>;
-export type BuilderOptionUnlessConfig<Values extends BuilderOptionValues | BuilderParameter = BuilderOptionValues | BuilderParameter, UnlessPath extends BuilderPath = BuilderPath> = BuilderWhenUnlessConfig<OptionPayload<Values>, UnlessPath>;
-export type BuilderOptionWhenConfig = BuilderOptionEnableConfig | BuilderOptionMatchConfig | BuilderOptionUnlessConfig;
-export type BuilderOptionWhenConfigValues<Config extends BuilderOptionWhenConfig> = Config extends {
-    readonly values: infer Values;
-} ? Values extends BuilderOptionValues ? Values : never : Config extends BuilderOptionMatchConfig<infer SelectMapType> ? SelectMapType extends BuilderOptionValuesMap ? NonNullable<SelectMapType[keyof SelectMapType]> & BuilderOptionValues : never : never;
-export type BuilderOptionMethod<State extends BuilderState> = {
-    <const Name extends string, const Values extends BuilderOptionValues>(name: Name, values: Values): BuilderMerge<State, {
-        model: State['model'] & {
-            [K in Name]: BuilderOptionValueType<Values>;
-        };
-        options: [...State['options'], BuilderOption<Name, Values>];
-    }>;
-    <const Name extends string>(name: Name, values: BuilderParameter): BuilderMerge<State, {
-        model: State['model'] & {
-            [K in Name]: string;
-        };
-        options: [...State['options'], BuilderOption<Name, BuilderParameter>];
-    }>;
-    when: {
-        <const GatePaths extends BuilderValidPaths<State['model']>, const Name extends string>(gatePaths: GatePaths, name: Name, config: BuilderParameter): BuilderMerge<State, {
-            model: State['model'] & {
-                [K in Name]: string | WhenPathsNullable<State['model'], GatePaths>;
-            };
-            options: [...State['options'], BuilderOption<Name, BuilderParameter>];
-        }>;
-        <const GatePaths extends BuilderValidPaths<State['model']>, const Name extends string, const Config extends BuilderOptionWhenConfig>(gatePaths: GatePaths, name: Name, config: Config & ValidOptionWhenConfig<State['model'], Config>): BuilderMerge<State, OptionWhenResult<State, GatePaths, Name, Config>>;
-    };
-};
-export declare const enable: typeof createEnable & {
-    parameter: () => BuilderParameter;
-};
-export declare const match: typeof createMatch & {
-    parameter: () => BuilderParameter;
-};
-export declare const unless: typeof createUnless & {
-    parameter: () => BuilderParameter;
-};
-type OptionPayload<Values extends BuilderOptionValues | BuilderParameter = BuilderOptionValues | BuilderParameter> = {
-    readonly values: Values;
-};
-type WhenParameterOf<Config extends BuilderOptionWhenConfig> = Config extends {
-    readonly values: infer Values;
-} ? Values extends BuilderParameter ? Values : never : never;
-type OptionWhenResult<State extends BuilderState, GatePaths extends BuilderValidPaths<State['model']>, Name extends string, Config extends BuilderOptionWhenConfig> = WhenParameterOf<Config> extends never ? {
-    model: State['model'] & {
-        [K in Name]: BuilderOptionValueType<BuilderOptionWhenConfigValues<Config>> | WhenNullability<State['model'], GatePaths, Config>;
-    };
-    options: [...State['options'], BuilderOption<Name, BuilderOptionWhenConfigValues<Config>>];
-} : {
-    model: State['model'] & {
-        [K in Name]: string | null;
-    };
-    options: [...State['options'], BuilderOption<Name, WhenParameterOf<Config>>];
-};
-type WhenMatchKeyOf<Model, Config extends BuilderOptionWhenConfig> = Config extends BuilderOptionMatchConfig<any, infer MatchPath> ? BuilderResolvePath<Model, MatchPath> & string : string;
-type ValidOptionWhenConfig<Model, Config extends BuilderOptionWhenConfig> = Config extends BuilderOptionMatchConfig<infer SelectMap, infer MatchPath> ? SelectMap extends BuilderParameter ? BuilderOptionMatchConfig<SelectMap, MatchPath & Readonly<BuilderValidPath<Model>>> : BuilderOptionMatchConfig<Record<WhenMatchKeyOf<Model, Config>, BuilderOptionValuesMap[string]>, MatchPath & Readonly<BuilderValidPath<Model>>> : Config extends BuilderOptionUnlessConfig<infer Values, infer UnlessPath> ? Values extends BuilderParameter ? BuilderOptionUnlessConfig<Values, UnlessPath & Readonly<BuilderValidPath<Model>>> : Config & {
-    readonly unlessPath: Readonly<BuilderValidPath<Model>>;
-} : Config;
-declare function createEnable<const Values extends BuilderOptionValues>(values: Values): BuilderOptionEnableConfig<Values>;
-declare function createMatch<const MatchPath extends BuilderPath, const SelectMap extends BuilderOptionValuesMap>(matchPath: MatchPath, selectMap: SelectMap): BuilderOptionMatchConfig<SelectMap, MatchPath>;
-declare function createUnless<const Values extends BuilderOptionValues, const UnlessPath extends BuilderPath>(unlessPath: UnlessPath, disabledValues: ReadonlyArray<BuilderPrimitive>, values: Values): BuilderOptionUnlessConfig<Values, UnlessPath>;
-export {};

package/dist/core/option/method.js

@@ -1,13 +0,0 @@
-import { BuilderParameter } from '../parameter.js';
-export const enable = Object.assign(createEnable, { parameter: () => new BuilderParameter() });
-export const match = Object.assign(createMatch, { parameter: () => new BuilderParameter() });
-export const unless = Object.assign(createUnless, { parameter: () => new BuilderParameter() });
-function createEnable(values) {
-    return { type: 'enable', values };
-}
-function createMatch(matchPath, selectMap) {
-    return { type: 'match', matchPath, selectMap };
-}
-function createUnless(unlessPath, disabledValues, values) {
-    return { type: 'unless', unlessPath, disabledValues, values };
-}

package/dist/core/option/option.d.ts

@@ -1,30 +0,0 @@
-import type { BuilderPaths } from '../../paths';
-import type { BuilderParameter } from '../parameter';
-import type { BuilderOptionWhenConfig } from './method';
-import type { BuilderSelectTypeValues } from './select';
-import * as v from 'valibot';
-import { BuilderSelectType } from './select.js';
-import { BuilderToggleType } from './toggle.js';
-export declare const BuilderOptionValuesSchema: v.UnionSchema<[v.InstanceSchema<typeof BuilderSelectType, undefined>, v.InstanceSchema<typeof BuilderToggleType, undefined>], undefined>;
-export type BuilderOptionValues = v.InferOutput<typeof BuilderOptionValuesSchema>;
-export declare const BuilderOptionValuesMapSchema: v.RecordSchema<v.StringSchema<undefined>, v.NullableSchema<v.UnionSchema<[v.InstanceSchema<typeof BuilderSelectType, undefined>, v.InstanceSchema<typeof BuilderToggleType, undefined>], undefined>, undefined>, undefined>;
-export type BuilderOptionValuesMap = v.InferOutput<typeof BuilderOptionValuesMapSchema>;
-export type BuilderOptionValueSchema = v.GenericSchema<string | number | boolean | null>;
-export type BuilderSelectTypeGeneric = BuilderSelectType<BuilderSelectTypeValues, BuilderOptionValueSchema>;
-export type BuilderToggleTypeGeneric = BuilderToggleType<BuilderOptionValueSchema>;
-export type BuilderOptionValueType<Values> = Values extends BuilderParameter ? string : Values extends {
-    readonly value: infer Value;
-} ? Value : never;
-export type BuilderOptionEntries = ReadonlyArray<BuilderOption>;
-export declare class BuilderOption<const Name extends string = string, const Values extends BuilderOptionValues | BuilderParameter = BuilderOptionValues | BuilderParameter> {
-    readonly model: {
-        [K in Name]: BuilderOptionValueType<Values>;
-    };
-    readonly name: Name;
-    readonly values: Values;
-    readonly gatePaths: BuilderPaths;
-    readonly config: BuilderOptionWhenConfig | null;
-    constructor(name: Name, values: Values, gatePaths?: BuilderPaths, config?: BuilderOptionWhenConfig | null);
-    resolve(model: unknown): BuilderOption<Name, BuilderOptionValues> | null;
-    dependencyKeys(): ReadonlyArray<string>;
-}

package/dist/core/option/option.js

@@ -1,42 +0,0 @@
-import * as v from 'valibot';
-import { check } from '../../check.js';
-import { resolve } from '../when/index.js';
-import { BuilderSelectType } from './select.js';
-import { BuilderToggleType } from './toggle.js';
-export const BuilderOptionValuesSchema = v.union([
-    v.instance(BuilderSelectType),
-    v.instance(BuilderToggleType)
-]);
-export const BuilderOptionValuesMapSchema = v.record(v.string(), v.nullable(BuilderOptionValuesSchema));
-export class BuilderOption {
-    name;
-    values;
-    gatePaths;
-    config;
-    constructor(name, values, gatePaths = [], config = null) {
-        this.name = name;
-        this.values = values;
-        this.gatePaths = gatePaths;
-        this.config = config;
-    }
-    resolve(model) {
-        check.assert(BuilderOptionValuesSchema, this.values);
-        return resolve(this, model, (selectMap, matchValue) => {
-            check.assert(BuilderOptionValuesMapSchema, selectMap);
-            const entry = selectMap[matchValue];
-            return entry ? new BuilderOption(this.name, entry) : null;
-        });
-    }
-    dependencyKeys() {
-        const keys = new Set(this.gatePaths.map(([first]) => String(first)));
-        if (this.config?.type === 'match') {
-            const [firstMatchSegment] = this.config.matchPath;
-            keys.add(String(firstMatchSegment));
-        }
-        else if (this.config?.type === 'unless') {
-            const [firstUnlessSegment] = this.config.unlessPath;
-            keys.add(String(firstUnlessSegment));
-        }
-        return Array.from(keys);
-    }
-}

package/dist/core/option/select.d.ts

@@ -1,22 +0,0 @@
-import type { BuilderOptionValueSchema } from './option';
-import * as v from 'valibot';
-import { BuilderParameter } from '../parameter.js';
-export type BuilderSelectTypeValues = readonly [string, ...ReadonlyArray<string>];
-export type BuilderSelectTypeLabels<Values extends BuilderSelectTypeValues> = Partial<Record<Values[number], string>>;
-export declare class BuilderSelectType<const Values extends BuilderSelectTypeValues = BuilderSelectTypeValues, const ValueSchema extends BuilderOptionValueSchema = BuilderOptionValueSchema> {
-    readonly value: v.InferOutput<ValueSchema>;
-    readonly options: Values;
-    readonly valueSchema: ValueSchema;
-    readonly defaultValue: v.InferOutput<ValueSchema>;
-    readonly isOptional: boolean;
-    readonly optionLabels: BuilderSelectTypeLabels<Values>;
-    constructor(values: Values, valueSchema: ValueSchema, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, optionLabels?: BuilderSelectTypeLabels<Values>);
-    default(newDefault: v.InferOutput<ValueSchema>): BuilderSelectType<Values, ValueSchema>;
-    optional(): BuilderSelectType<Values, v.NullableSchema<ValueSchema, undefined>>;
-    labels(optionLabels: BuilderSelectTypeLabels<Values>): BuilderSelectType<Values, ValueSchema>;
-}
-declare function createSelect<const Values extends BuilderSelectTypeValues>(values: Values): BuilderSelectType<Values, v.UnionSchema<v.LiteralSchema<Values[number], undefined>[], undefined>>;
-export declare const select: typeof createSelect & {
-    parameter: () => BuilderParameter;
-};
-export {};

package/dist/core/option/select.js

@@ -1,34 +0,0 @@
-import * as v from 'valibot';
-import { BuilderParameter } from '../parameter.js';
-export class BuilderSelectType {
-    options;
-    valueSchema;
-    defaultValue;
-    isOptional;
-    optionLabels;
-    constructor(values, valueSchema, defaultValue, optional = false, optionLabels = {}) {
-        this.options = values;
-        this.valueSchema = valueSchema;
-        this.defaultValue = defaultValue;
-        this.isOptional = optional;
-        this.optionLabels = optionLabels;
-    }
-    default(newDefault) {
-        return new BuilderSelectType(this.options, this.valueSchema, newDefault, this.isOptional, this.optionLabels);
-    }
-    optional() {
-        const { options, defaultValue } = this;
-        return new BuilderSelectType(options, v.nullable(this.valueSchema), defaultValue, true, this.optionLabels);
-    }
-    labels(optionLabels) {
-        return new BuilderSelectType(this.options, this.valueSchema, this.defaultValue, this.isOptional, optionLabels);
-    }
-}
-function createSelect(values) {
-    const [defaultValue] = values;
-    const valueSchema = v.union(values.map((value) => v.literal(value)));
-    return new BuilderSelectType(values, valueSchema, defaultValue, false);
-}
-export const select = Object.assign(createSelect, {
-    parameter: () => new BuilderParameter()
-});

package/dist/core/option/toggle.d.ts

@@ -1,16 +0,0 @@
-import type { BuilderOptionValueSchema } from './option';
-import * as v from 'valibot';
-export type BuilderToggleValueType = 'string' | 'boolean' | 'number';
-export declare class BuilderToggleType<const ValueSchema extends BuilderOptionValueSchema = BuilderOptionValueSchema> {
-    readonly value: v.InferOutput<ValueSchema>;
-    readonly valueType: BuilderToggleValueType;
-    readonly valueSchema: ValueSchema;
-    readonly defaultValue: v.InferOutput<ValueSchema>;
-    readonly isOptional: boolean;
-    constructor(valueType: BuilderToggleValueType, valueSchema: ValueSchema, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean);
-    default(newDefault: v.InferOutput<ValueSchema>): BuilderToggleType<ValueSchema>;
-    optional(): BuilderToggleType<v.NullableSchema<ValueSchema, undefined>>;
-}
-export declare function toggleString(): BuilderToggleType<v.StringSchema<undefined>>;
-export declare function toggleBoolean(): BuilderToggleType<v.BooleanSchema<undefined>>;
-export declare function toggleNumber(): BuilderToggleType<v.NumberSchema<undefined>>;

package/dist/core/option/toggle.js

@@ -1,29 +0,0 @@
-import * as v from 'valibot';
-export class BuilderToggleType {
-    valueType;
-    valueSchema;
-    defaultValue;
-    isOptional;
-    constructor(valueType, valueSchema, defaultValue, optional) {
-        this.valueType = valueType;
-        this.valueSchema = valueSchema;
-        this.defaultValue = defaultValue;
-        this.isOptional = optional || false;
-    }
-    default(newDefault) {
-        return new BuilderToggleType(this.valueType, this.valueSchema, newDefault, this.isOptional);
-    }
-    optional() {
-        const { valueType, valueSchema, defaultValue } = this;
-        return new BuilderToggleType(valueType, v.nullable(valueSchema), defaultValue, true);
-    }
-}
-export function toggleString() {
-    return new BuilderToggleType('string', v.string(), '');
-}
-export function toggleBoolean() {
-    return new BuilderToggleType('boolean', v.boolean(), false);
-}
-export function toggleNumber() {
-    return new BuilderToggleType('number', v.number(), 0);
-}

package/dist/core/parameter.d.ts

@@ -1,48 +0,0 @@
-import type { BuilderValidPath } from '../paths';
-import type { BuilderState, BuilderStateMerge } from './builder';
-import type { BuilderOption, BuilderOptionEnableConfig, BuilderOptionEntries, BuilderOptionMatchConfig, BuilderOptionUnlessConfig, BuilderOptionValues, BuilderOptionWhenConfig } from './option/index';
-import type { WhenConfigNullable } from './when/index';
-import * as v from 'valibot';
-export declare class BuilderParameter {
-    readonly parameter: true;
-}
-export declare const BuilderParameterSchema: v.InstanceSchema<typeof BuilderParameter, undefined>;
-export type ParameterisedOptions<Options extends BuilderOptionEntries> = {
-    [K in keyof Options]: Options[K] extends BuilderOption<infer Name, infer Values> ? Values extends BuilderParameter ? BuilderOption<Name, Values> : never : never;
-}[number];
-export type BuilderBindings<State extends BuilderState> = {
-    readonly [P in ParameterisedOptions<State['options']> as P['name']]?: ValidBinding<State['model']>;
-};
-export type ReplaceOption<Options extends BuilderOptionEntries, BoundNames extends string> = Options extends readonly [
-    infer Head extends BuilderOption,
-    ...infer Tail extends BuilderOptionEntries
-] ? Head extends BuilderOption<infer Name, infer Values> ? Values extends BuilderParameter ? Name extends BoundNames ? [...ReplaceOption<Tail, BoundNames>] : [Head, ...ReplaceOption<Tail, BoundNames>] : [Head, ...ReplaceOption<Tail, BoundNames>] : [Head, ...ReplaceOption<Tail, BoundNames>] : [];
-export type BuilderBoundState<State extends BuilderState, Bindings extends Record<string, unknown>> = BuilderStateMerge<State, {
-    options: ReplaceOption<State['options'], Extract<keyof Bindings, string>>;
-    model: Omit<State['model'], keyof Bindings> & {
-        [K in Extract<keyof Bindings, string>]: BindingModelType<Bindings[K]>;
-    };
-}>;
-export declare function extractValues(config: BuilderOptionWhenConfig): BuilderOptionValues;
-export declare function bindOptions<Bindings extends Record<string, unknown>>(options: BuilderOptionEntries, bindings: Bindings): BuilderOptionEntries;
-type ValidEnableConfig = BuilderOptionEnableConfig<BuilderOptionEnableConfig['values']>;
-type ValidMatchConfig<Model> = BuilderOptionMatchConfig<BuilderOptionMatchConfig['selectMap'], Readonly<BuilderValidPath<Model>>>;
-type ValidUnlessConfig<Model> = BuilderOptionUnlessConfig<BuilderOptionUnlessConfig['values'], Readonly<BuilderValidPath<Model>>>;
-type ValidBinding<Model> = BuilderOptionValues | ValidEnableConfig | ValidMatchConfig<Model> | ValidUnlessConfig<Model>;
-type BindingConfigNullable<Binding> = Binding extends {
-    readonly type: string;
-} ? WhenConfigNullable<Binding> : never;
-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 values: infer Values;
-} ? Values extends {
-    readonly value: infer Value;
-} ? Value : string : Binding extends {
-    readonly value: infer Value;
-} ? Value : string;
-type BindingModelType<Binding> = BindingValueType<Binding> | BindingConfigNullable<Binding>;
-export {};

package/dist/core/parameter.js

@@ -1,31 +0,0 @@
-import * as v from 'valibot';
-import { BuilderWhenConfigSchema } from './when/index.js';
-export class BuilderParameter {
-    parameter = true;
-}
-export const BuilderParameterSchema = v.instance(BuilderParameter);
-export function extractValues(config) {
-    if (config.type === 'match') {
-        return Object.values(config.selectMap).find((value) => value !== null);
-    }
-    return config.values;
-}
-export function bindOptions(options, bindings) {
-    return options.map((option) => {
-        const binding = bindings[option.name];
-        if (binding == null) {
-            return option;
-        }
-        return bindOption(option, binding);
-    });
-}
-function createOption(option, values, config) {
-    const OptionConstructor = option.constructor;
-    return new OptionConstructor(option.name, values, option.gatePaths, config);
-}
-function bindOption(option, binding) {
-    if (v.is(BuilderWhenConfigSchema, binding)) {
-        return createOption(option, extractValues(binding), binding);
-    }
-    return createOption(option, binding, option.config);
-}

package/dist/core/validate.d.ts

@@ -1,26 +0,0 @@
-import type { BuilderGeneric } from './builder';
-declare const validated: unique symbol;
-export type BuilderValidated = BuilderGeneric & {
-    readonly [validated]: true;
-};
-export type BuilderValidateErrorUnmetExpectation = {
-    readonly kind: 'unmet-expectation';
-    readonly expectationKind: 'option' | 'component' | 'collection';
-    readonly name: string;
-};
-export type BuilderValidateErrorUnboundParameter = {
-    readonly kind: 'unbound-parameter';
-    readonly name: string;
-};
-export type BuilderValidateError = BuilderValidateErrorUnmetExpectation | BuilderValidateErrorUnboundParameter;
-export type BuilderValidateErrors = ReadonlyArray<BuilderValidateError>;
-export type BuilderValidateResult = readonly [BuilderValidated, BuilderValidateErrors];
-export type BuilderValidateOptions = {
-    readonly strict: true;
-};
-export declare class BuilderValidateException extends Error {
-    readonly errors: BuilderValidateErrors;
-    constructor(errors: BuilderValidateErrors);
-}
-export declare function validateBuilder(builder: BuilderGeneric, options?: BuilderValidateOptions): BuilderValidateResult;
-export {};

package/dist/core/validate.js

@@ -1,43 +0,0 @@
-import * as v from 'valibot';
-import { BuilderParameterSchema } from './parameter.js';
-export class BuilderValidateException extends Error {
-    errors;
-    constructor(errors) {
-        super('builder validation failed');
-        this.errors = errors;
-    }
-}
-export function validateBuilder(builder, options) {
-    const expectationErrors = validateExpectations(builder.expectations, builder);
-    const parameterErrors = validateParameters(builder.options);
-    const errors = [...expectationErrors, ...parameterErrors];
-    if (options?.strict && errors.length > 0) {
-        throw new BuilderValidateException(errors);
-    }
-    return [builder, errors];
-}
-function validateExpectations(expectations, entries) {
-    return expectations.flatMap((expectation) => {
-        const lookup = expectation.kind === 'option'
-            ? entries.options
-            : expectation.kind === 'component'
-                ? entries.components
-                : entries.collections;
-        const exists = lookup.some((entry) => entry.name === expectation.name);
-        if (exists) {
-            return [];
-        }
-        return [
-            {
-                kind: 'unmet-expectation',
-                expectationKind: expectation.kind,
-                name: expectation.name
-            }
-        ];
-    });
-}
-function validateParameters(options) {
-    return options
-        .filter((option) => v.is(BuilderParameterSchema, option.values))
-        .map((option) => ({ kind: 'unbound-parameter', name: option.name }));
-}

package/dist/core/when/config.d.ts

@@ -1,20 +0,0 @@
-import type { BuilderPrimitive } from '../../model';
-import type { BuilderPath } from '../../paths';
-import * as v from 'valibot';
-export declare const BuilderWhenConfigSchema: v.ObjectSchema<{
-    readonly type: v.PicklistSchema<["enable", "match", "unless"], undefined>;
-}, undefined>;
-export type BuilderWhenConfig = v.InferOutput<typeof BuilderWhenConfigSchema>;
-export type BuilderWhenEnableConfig<Payload> = {
-    readonly type: 'enable';
-} & Payload;
-export type BuilderWhenMatchConfig<SelectMap = Record<string, unknown>, MatchPath extends BuilderPath = BuilderPath> = {
-    readonly type: 'match';
-    readonly matchPath: MatchPath;
-    readonly selectMap: SelectMap;
-};
-export type BuilderWhenUnlessConfig<Payload, UnlessPath extends BuilderPath = BuilderPath> = {
-    readonly type: 'unless';
-    readonly unlessPath: UnlessPath;
-    readonly disabledValues: ReadonlyArray<BuilderPrimitive>;
-} & Payload;

package/dist/core/when/config.js

@@ -1,4 +0,0 @@
-import * as v from 'valibot';
-export const BuilderWhenConfigSchema = v.object({
-    type: v.picklist(['enable', 'match', 'unless'])
-});

package/dist/core/when/constrain.d.ts

@@ -1,14 +0,0 @@
-import type { BuilderValidPath } from '../../paths';
-export type WhenConfigConstrained<Model, Config extends {
-    readonly type: string;
-}> = Config extends {
-    readonly type: 'match';
-    readonly matchPath: infer MatchPath;
-} ? Config & {
-    readonly matchPath: MatchPath & Readonly<BuilderValidPath<Model>>;
-} : Config extends {
-    readonly type: 'unless';
-    readonly unlessPath: infer UnlessPath;
-} ? Config & {
-    readonly unlessPath: UnlessPath & Readonly<BuilderValidPath<Model>>;
-} : Config;

package/dist/core/when/index.d.ts

@@ -1,5 +0,0 @@
-export type { BuilderWhenConfig, BuilderWhenEnableConfig, BuilderWhenMatchConfig, BuilderWhenUnlessConfig } from './config';
-export { BuilderWhenConfigSchema } from './config.js';
-export type { WhenConfigNullable, WhenNullability, WhenPathsNullable } from './nullability';
-export type { WhenConfigConstrained } from './constrain';
-export { resolve } from './resolve.js';

package/dist/core/when/index.js

@@ -1,2 +0,0 @@
-export { BuilderWhenConfigSchema } from './config.js';
-export { resolve } from './resolve.js';

package/dist/core/when/nullability.d.ts

@@ -1,18 +0,0 @@
-import type { BuilderPath, BuilderPaths, BuilderResolvePath } from '../../paths';
-export type WhenConfigNullable<Config extends {
-    readonly type: string;
-}> = Config extends {
-    readonly type: 'unless';
-} ? null : Config extends {
-    readonly type: 'match';
-    readonly selectMap: infer SelectMap;
-} ? null extends SelectMap[keyof SelectMap] ? null : never : never;
-export type WhenPathsNullable<Model, GatePaths extends BuilderPaths> = GatePaths extends readonly [
-    infer Head extends BuilderPath,
-    ...infer Tail extends BuilderPaths
-] ? WhenPathNullable<Model, Head> | WhenPathsNullable<Model, Tail> : never;
-export type WhenNullability<Model, GatePaths extends BuilderPaths, Config extends {
-    readonly type: string;
-}> = WhenPathsNullable<Model, GatePaths> | WhenConfigNullable<Config>;
-type WhenPathNullable<Model, Path extends BuilderPath> = null extends BuilderResolvePath<Model, Path> ? null : never;
-export {};

package/dist/core/when/resolve.d.ts

@@ -1,18 +0,0 @@
-import type { BuilderPath, BuilderPaths } from '../../paths';
-export declare function resolve<Entry extends Resolvable>(entry: Entry, model: unknown, onMatch: (selectMap: unknown, matchValue: string) => Entry | null): Entry | null;
-type ResolvableConfig = {
-    readonly type: 'enable';
-} | {
-    readonly type: 'match';
-    readonly matchPath: BuilderPath;
-    readonly selectMap: unknown;
-} | {
-    readonly type: 'unless';
-    readonly unlessPath: BuilderPath;
-    readonly disabledValues: ReadonlyArray<unknown>;
-};
-interface Resolvable {
-    readonly gatePaths: BuilderPaths;
-    readonly config: ResolvableConfig | null;
-}
-export {};

package/dist/core/when/resolve.js

@@ -1,22 +0,0 @@
-import { readPath } from '../../paths.js';
-export function resolve(entry, model, onMatch) {
-    if (entry.config === null) {
-        return entry;
-    }
-    if (!entry.gatePaths.every((path) => !!readPath(model, path))) {
-        return null;
-    }
-    switch (entry.config.type) {
-        case 'enable': {
-            return entry;
-        }
-        case 'match': {
-            const matchValue = String(readPath(model, entry.config.matchPath));
-            return onMatch(entry.config.selectMap, matchValue);
-        }
-        case 'unless': {
-            const value = readPath(model, entry.config.unlessPath);
-            return !entry.config.disabledValues.includes(value) ? entry : null;
-        }
-    }
-}

package/dist/resolve/index.d.ts

@@ -1,10 +0,0 @@
-export type { BuilderOrder } from './order';
-export type { BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } from './render';
-export type { BuilderDataValidated, BuilderDataError, BuilderDataErrors, BuilderDataErrorComponentMissing, BuilderDataErrorComponentUnexpected, BuilderDataErrorVariantInvalid, BuilderDataErrorVariantMissing, BuilderDataValidateResult } from './validate';
-export type { BuilderModelValidated, BuilderModelValidateError, BuilderModelValidateErrors, BuilderModelValidateErrorInvalidCollection, BuilderModelValidateErrorInvalidOption, BuilderModelValidateOptions, BuilderModelValidateResult } from './instance';
-export type { BuilderDescription, BuilderDescriptionItem } from '../schemas/index';
-export { instance, BuilderModelValidateException } from './instance.js';
-export { models } from './models.js';
-export { order } from './order.js';
-export { ordinal, render } from './render.js';
-export { validate, BuilderDataValidateError } from './validate.js';

package/dist/resolve/index.js

@@ -1,5 +0,0 @@
-export { instance, BuilderModelValidateException } from './instance.js';
-export { models } from './models.js';
-export { order } from './order.js';
-export { ordinal, render } from './render.js';
-export { validate, BuilderDataValidateError } from './validate.js';

package/dist/resolve/instance.d.ts

@@ -1,35 +0,0 @@
-import type { BuilderGeneric, BuilderModelOf } from '../core/index';
-import type { BuilderModel, BuilderModelInput } from '../model';
-declare const modelValidated: unique symbol;
-export type BuilderModelValidated = BuilderModel & {
-    readonly [modelValidated]: true;
-};
-export type BuilderModelValidateErrorInvalidOption = {
-    readonly kind: 'invalid-option';
-    readonly name: string;
-    readonly value: unknown;
-};
-export type BuilderModelValidateErrorInvalidCollection = {
-    readonly kind: 'invalid-collection';
-    readonly name: string;
-    readonly detail: string;
-};
-export type BuilderModelValidateError = BuilderModelValidateErrorInvalidOption | BuilderModelValidateErrorInvalidCollection;
-export type BuilderModelValidateErrors = ReadonlyArray<BuilderModelValidateError>;
-export type BuilderModelValidateResult = readonly [
-    BuilderModelValidated,
-    BuilderModelValidateErrors
-];
-export type BuilderModelValidateOptions = {
-    readonly strict: true;
-};
-export declare class BuilderModelValidateException extends Error {
-    readonly errors: BuilderModelValidateErrors;
-    constructor(errors: BuilderModelValidateErrors);
-}
-export declare function validateInstance(builder: BuilderGeneric, model: BuilderModel, options?: BuilderModelValidateOptions): BuilderModelValidateResult;
-export declare const instance: typeof createInstance & {
-    validate: typeof validateInstance;
-};
-declare function createInstance<const Builder extends BuilderGeneric>(builder: Builder, partial?: BuilderModelInput): BuilderModelOf<Builder> & BuilderModelValidated;
-export {};