@builder-builder/builder 0.0.10 → 0.0.11

package/dist/bb.d.ts

@@ -0,0 +1,28 @@
+import type { BuilderComponentVariantsValidated, BuilderInstanceValidated, BuilderModelValidated, BuilderRefEntities, BuilderUIValidated, BuilderValidated } from './entities/index';
+import type { BuilderEnvironment, BuilderEnvironmentResult } from './environment';
+import type { BuilderOrder, BuilderRenderResult } from './mappers/index';
+import type { BuilderComponentVariants, BuilderInstance, BuilderInstanceInput } from './instance';
+export type BBOptions = {
+    readonly references?: BuilderRefEntities;
+};
+export type BB<Env extends BuilderEnvironment = 'production'> = {
+    readonly validate: {
+        builder(input: unknown): BuilderEnvironmentResult<BuilderValidated, Env>;
+        model(input: unknown): BuilderEnvironmentResult<BuilderModelValidated, Env>;
+        ui(input: unknown): BuilderEnvironmentResult<BuilderUIValidated, Env>;
+        instance(model: BuilderModelValidated, instance: BuilderInstance): BuilderEnvironmentResult<BuilderInstanceValidated, Env>;
+        variants(model: BuilderModelValidated, input: unknown, options?: {
+            readonly partial?: boolean;
+        }): BuilderEnvironmentResult<BuilderComponentVariantsValidated, Env>;
+    };
+    instance(entity: BuilderValidated | BuilderModelValidated, partial?: BuilderInstanceInput): BuilderInstance;
+    render(builder: BuilderValidated, instance: BuilderInstanceValidated): BuilderRenderResult;
+    order(model: BuilderModelValidated, instance: BuilderInstanceValidated, variants: BuilderComponentVariantsValidated): BuilderOrder;
+    variants(entity: BuilderValidated | BuilderModelValidated): BuilderComponentVariants;
+};
+export declare const bb: typeof bbProd & {
+    dev: typeof bbDev;
+};
+declare function bbProd(options?: BBOptions): BB<'production'>;
+declare function bbDev(options?: BBOptions): BB<'development'>;
+export {};

package/dist/bb.js

@@ -0,0 +1,49 @@
+import { BuilderException } from './exception.js';
+import { assertValidated, createInstance, createVariants, order, render, validateBuilder, validateInstance, validateModel, validateUI, validateVariants } from './mappers/index.js';
+export const bb = Object.assign(bbProd, {
+    dev: bbDev
+});
+function bbProd(options = {}) {
+    return bbFactory('production', options.references);
+}
+function bbDev(options = {}) {
+    return bbFactory('development', options.references);
+}
+function bbFactory(environment, references = []) {
+    return {
+        validate: {
+            builder: (input) => throwInProd(validateBuilder(input, references)),
+            model: (input) => throwInProd(validateModel(input, references)),
+            ui: (input) => throwInProd(validateUI(input, references)),
+            instance: (model, instance) => throwInProd(validateInstance(model, instance)),
+            variants: (model, input, variantOptions) => throwInProd(validateVariants(model, input, variantOptions))
+        },
+        instance: (entity, partial) => {
+            assertValidated(entity);
+            return createInstance(entity, partial, references);
+        },
+        render: (builder, instance) => {
+            assertValidated(builder);
+            assertValidated(instance);
+            return render(builder, instance, references);
+        },
+        order: (model, instance, variants) => {
+            assertValidated(model);
+            assertValidated(instance);
+            assertValidated(variants);
+            return order(model, instance, variants, references);
+        },
+        variants: (entity) => {
+            assertValidated(entity);
+            return createVariants(entity);
+        }
+    };
+    function throwInProd(result) {
+        const [entity, errors] = result;
+        const isDev = environment === 'development';
+        if (!isDev && errors.length > 0) {
+            throw new BuilderException(errors);
+        }
+        return (isDev ? result : entity);
+    }
+}

package/dist/check.d.ts

@@ -3,7 +3,7 @@ declare class Check {
     truthy<Input>(input: Input, message?: `${string}! ❌`): asserts input is Exclude<Input, null | undefined | '' | 0 | false>;
     falsy(input: unknown, message?: `${string}! ❌`): void;
     is<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown): input is v.InferInput<Schema>;
-    assert<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown): asserts input is v.InferInput<Schema>;
+    assert<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown, message?: `${string}! ❌`): asserts input is v.InferInput<Schema>;
 }
 export declare const check: Check;
 export {};

package/dist/check.js

@@ -15,8 +15,10 @@ class Check {
     is(schema, input) {
         return v.is(schema, input);
     }
-    assert(schema, input) {
-        v.assert(schema, input);
+    assert(schema, input, message = DEFAULT_MESSAGE) {
+        if (!v.is(schema, input)) {
+            throw new BuilderException([], message);
+        }
     }
 }
 export const check = new Check();

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

@@ -1,85 +1,4 @@
-import type { BuilderPaths } from '../../paths';
-import type { BuilderParameter, BuilderParameters, BuilderRef, Paramable } from '../../references';
-import type { BuilderCollectionConfig } from '../collection/config';
-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 { BuilderGeneric } from './builder';
-import type { BuilderState, BuilderStateAppend } from './state';
-import { Builder } from './builder.js';
-export type BuilderBindings<State extends BuilderState> = {
-    readonly [Name in BuilderParametersNamesOf<State['parameters']> | ParameterNamesOf<State['options']> | ParameterNamesOf<State['collections']> | ParameterNamesOf<State['components']> | CollectionConfigParameterNamesOf<State['collections']>]?: BuilderWhenConstrained<State, PayloadForParameter<State, Name>> | BuilderRef;
-};
-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'], Bindings>;
-    collections: EntryBound<State['collections'], Bindings>;
-    components: EntryBound<State['components'], Bindings>;
-    model: Omit<State['model'], keyof Bindings> & {
-        [K in Extract<keyof Bindings, string>]: BindingModelType<Bindings[K]>;
-    };
-}>;
-export type BindingModelType<Binding> = Binding extends BuilderRef ? unknown : 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?: Paramable<BuilderPaths>;
-};
-type EntryBound<Entries extends ReadonlyArray<EntryLike>, Bindings> = Entries extends readonly [
-    infer Head extends EntryLike,
-    ...infer Tail extends ReadonlyArray<EntryLike>
-] ? Head extends {
-    readonly payload: infer Payload;
-} ? Payload extends BuilderParameter ? Head['name'] extends keyof Bindings ? Bindings[Head['name']] extends BuilderRef ? [Head, ...EntryBound<Tail, Bindings>] : [...EntryBound<Tail, Bindings>] : [Head, ...EntryBound<Tail, Bindings>] : [Head, ...EntryBound<Tail, Bindings>] : [Head, ...EntryBound<Tail, Bindings>] : [];
-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, BuilderParameter> extends infer Parameter extends BuilderParameter ? {
-    readonly name: Parameter['name'];
-    readonly payload: Parameter;
-} : never;
-type ParameterNamesOf<Entries extends ReadonlyArray<EntryLike>> = EntryParameters<Entries>['name'];
-type PayloadForParameter<State extends BuilderState, Name extends string> = Name extends BuilderParametersNamesOf<State['parameters']> ? BuilderGeneric : Name extends ParameterNamesOf<State['options']> ? BuilderOptionPayload : Name extends ParameterNamesOf<State['collections']> ? BuilderCollectionPayload : Name extends ParameterNamesOf<State['components']> ? BuilderComponentPayload : Name extends CollectionConfigParameterNamesOf<State['collections']> ? CollectionConfigExpectedOf<State['collections'], Name> : never;
-type BuilderParametersNamesOf<Parameters extends BuilderParameters> = Extract<Parameters[number], BuilderParameter>['name'];
-type CollectionConfigOf<Payload> = Payload extends BuilderCollectionConfig<infer Builder, infer Min, infer Max> ? BuilderCollectionConfig<Builder, Min, Max> : Payload extends {
-    readonly type: 'enable' | 'unless';
-    readonly payload: infer Inner;
-} ? CollectionConfigOf<Inner> : Payload extends {
-    readonly type: 'match';
-    readonly selectMap: infer SelectMap;
-} ? CollectionConfigOf<NonNullable<SelectMap[keyof SelectMap]>> : never;
-type CollectionConfigParameterInfo<Value, Expected> = Value extends BuilderParameter ? {
-    readonly name: Value['name'];
-    readonly payload: Value;
-    readonly expected: Expected;
-} : never;
-type CollectionConfigParameters<Payload> = [CollectionConfigOf<Payload>] extends [never] ? never : CollectionConfigOf<Payload> extends BuilderCollectionConfig<infer Builder, infer Min, infer Max> ? CollectionConfigParameterInfo<Builder, BuilderGeneric> | CollectionConfigParameterInfo<Min, number> | CollectionConfigParameterInfo<Max, number> : never;
-type CollectionConfigParametersOfEntries<Entries extends ReadonlyArray<EntryLike>> = Entries[number] extends infer Entry ? Entry extends {
-    readonly payload: infer Payload;
-} ? CollectionConfigParameters<Payload> : never : never;
-type CollectionConfigParameterNamesOf<Entries extends ReadonlyArray<EntryLike>> = CollectionConfigParametersOfEntries<Entries>['name'];
-type CollectionConfigExpectedOf<Entries extends ReadonlyArray<EntryLike>, Name extends string> = Extract<CollectionConfigParametersOfEntries<Entries>, {
-    readonly name: Name;
-}>['expected'];
-export {};
+import type { BuilderEntitySerialised } from '../kind';
+import type { BuilderRefSerialised } from '../../references';
+export type BuilderBindings = Readonly<Record<string, unknown>>;
+export type BuilderBindingsSerialised = Readonly<Record<string, BuilderEntitySerialised | BuilderRefSerialised>>;

package/dist/entities/builder/bind.js

@@ -1,9 +1 @@
-import { bind } from '../bind.js';
-import { Builder } from './builder.js';
-import { mergeBuilderParts } from './builders.js';
-export function bindBuilder(builder, bindings) {
-    return bind(builder, bindings, (walked, walkedNonRefValues, remainingParameters, newReferences) => {
-        const merged = mergeBuilderParts(walkedNonRefValues);
-        return new Builder([...remainingParameters, ...merged.parameters], [...walked.options, ...merged.options], [...walked.components, ...merged.components], [...walked.collections, ...merged.collections], [...walked.expectations, ...merged.expectations], [...walked.references, ...newReferences, ...merged.references]);
-    });
-}
+export {};