@builder-builder/builder 0.0.9 → 0.0.11

package/dist/entities/builder/builder.js

@@ -1,84 +1,27 @@
 import * as v from 'valibot';
-import { check } from '../../check.js';
-import { BuilderRefsSerialisedSchema } from '../../references.js';
+import { BuilderRefSerialisedSchema } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
-import { BuilderCollectionsSerialisedSchema } from '../collection/index.js';
-import { BuilderComponentDetailsSchema, BuilderComponentsSerialisedSchema, componentDetails } from '../component/index.js';
-import { BuilderExpectationsSerialisedSchema } from '../expectation.js';
-import { BuilderOptionsSerialisedSchema } from '../option/index.js';
-import { builderCollectionMethod, builderComponentMethod, builderOptionMethod } from './methods.js';
-import { bindBuilder } from './parameter.js';
-import { validateDuplicates, validatePaths } from './validate.js';
+import { BuilderModel, BuilderModelSerialisedSchema } from '../model/index.js';
+import { BuilderUI, BuilderUISerialisedSchema } from '../ui/index.js';
 export class Builder {
-    references;
-    options;
-    components;
-    collections;
-    expectations;
-    id = crypto.randomUUID();
-    constructor(references = [], options = [], components = [], collections = [], expectations = []) {
-        this.references = references;
-        this.options = options;
-        this.components = components;
-        this.collections = collections;
-        this.expectations = expectations;
-        validateDuplicates(this);
-        validatePaths(this);
+    model;
+    ui;
+    bindings;
+    constructor(model = new BuilderModel(), ui = new BuilderUI([], [], []), bindings = {}) {
+        this.model = model;
+        this.ui = ui;
+        this.bindings = bindings;
     }
-    get option() {
-        const method = builderOptionMethod();
-        const add = (name, payload) => {
-            return this.#next({ options: [...this.options, method(name, payload)] });
-        };
-        const when = (gatePaths, name, config) => {
-            return this.#next({ options: [...this.options, method.when(gatePaths, name, config)] });
-        };
-        return Object.assign(add, { when });
-    }
-    get component() {
-        const method = builderComponentMethod();
-        const add = (name, details) => {
-            const wrappedDetails = check.is(BuilderComponentDetailsSchema, details)
-                ? details
-                : details != null
-                    ? componentDetails(details)
-                    : details;
-            return this.#next({ components: [...this.components, method(name, wrappedDetails)] });
-        };
-        const when = (gatePaths, name, config) => {
-            return this.#next({
-                components: [...this.components, method.when(gatePaths, name, config)]
-            });
-        };
-        return Object.assign(add, { when });
-    }
-    get collection() {
-        const method = builderCollectionMethod();
-        const add = (name, payload) => {
-            return this.#next({ collections: [...this.collections, method(name, payload)] });
-        };
-        const when = (gatePaths, name, config) => {
-            return this.#next({
-                collections: [...this.collections, method.when(gatePaths, name, config)]
-            });
-        };
-        return Object.assign(add, { when });
-    }
-    expect(...expectations) {
-        return this.#next({ expectations: [...this.expectations, ...expectations] });
-    }
-    bind(bindings) {
-        return bindBuilder(this, bindings);
-    }
-    #next(patch) {
-        return new Builder(this.references, patch.options ?? this.options, patch.components ?? this.components, patch.collections ?? this.collections, patch.expectations ?? this.expectations);
+    bind(extra) {
+        return new Builder(this.model, this.ui, {
+            ...this.bindings,
+            ...extra
+        });
     }
 }
 export const BuilderSchema = v.instance(Builder);
-export const BuilderSerialisedSchema = serialisable(Builder, v.object({
-    references: BuilderRefsSerialisedSchema,
-    options: BuilderOptionsSerialisedSchema,
-    components: BuilderComponentsSerialisedSchema,
-    collections: BuilderCollectionsSerialisedSchema,
-    expectations: BuilderExpectationsSerialisedSchema
+export const BuilderSerialisedSchema = serialisable(v.object({
+    model: BuilderModelSerialisedSchema,
+    ui: BuilderUISerialisedSchema,
+    bindings: v.pipe(v.record(v.string(), v.union([BuilderRefSerialisedSchema, v.unknown()])), v.readonly())
 }));

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

@@ -0,0 +1,7 @@
+import type { BuilderModel } from '../model/model';
+import type { BuilderModelState } from '../model/state';
+import type { BuilderUI } from '../ui/ui';
+import type { BuilderBindings } from './bind';
+import { Builder } from './builder.js';
+export declare function builder(): Builder<BuilderModelState>;
+export declare function builder<const State extends BuilderModelState>(model: BuilderModel<State>, ui?: BuilderUI, bindings?: BuilderBindings): Builder<State>;

package/dist/entities/builder/factory.js

@@ -0,0 +1,4 @@
+import { Builder } from './builder.js';
+export function builder(model, ui, bindings) {
+    return new Builder(model, ui, bindings);
+}

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

@@ -1,7 +1,4 @@
-export type { BuilderGeneric, BuilderInstanceOf, BuilderReference, BuilderReferences, BuilderSerialised, BuilderStateOf } from './builder';
-export type { BuilderStateAsserted, ModelAsserted, ModelExpected } from './expectation';
-export type { BindingModelType, BuilderBindings, BuilderBoundState } from './parameter';
-export type { BuilderState, BuilderStateAppend, BuilderStateEmpty } from './state';
+export type { BuilderBindings, BuilderBindingsSerialised } from './bind';
+export type { BuilderSerialised } from './builder';
 export { Builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';
-export { builders, mergeBuilderParts } from './builders.js';
-export { bindBuilder } from './parameter.js';
+export { builder } from './factory.js';

package/dist/entities/builder/index.js

@@ -1,3 +1,2 @@
 export { Builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';
-export { builders, mergeBuilderParts } from './builders.js';
-export { bindBuilder } from './parameter.js';
+export { builder } from './factory.js';

package/dist/entities/collection/collection.d.ts

@@ -1,37 +1,88 @@
 import type { BuilderPaths } from '../../paths';
-import type { Refable, RefableSerialised } from '../../references';
-import type { BuilderState } from '../builder/index';
-import type { BuilderWhen, WhenSerialised } from '../when';
-import type { BuilderCollectionConfigSerialised } from './config';
+import type { Paramable, ParamableSerialised } from '../../references';
+import type { BuilderModelState } from '../model/index';
+import type { BuilderWhenSerialised } from '../when';
+import type { BuilderCollectionConfig, BuilderCollectionConfigSerialised } from './config';
+import type { BuilderCollectionWhen } from './when';
 import * as v from 'valibot';
-import { BuilderCollectionConfig } from './config.js';
-export type BuilderErrorInvalidCollectionBounds = {
-    readonly kind: 'invalid-collection-bounds';
-    readonly name: string;
-    readonly min: number;
-    readonly max: number;
-};
-export type BuilderCollectionPayload = BuilderCollectionConfig | BuilderWhen<Refable<BuilderCollectionConfig>>;
-export declare class BuilderCollection<const Name extends string = string, const Payload extends Refable<BuilderCollectionPayload> = Refable<BuilderCollectionPayload>, const GatePaths extends Refable<BuilderPaths> = Refable<BuilderPaths>> {
+export type BuilderCollectionPayload = BuilderCollectionConfig | BuilderCollectionWhen;
+export declare class BuilderCollection<const Name extends string = string, const Payload extends Paramable<BuilderCollectionPayload> = Paramable<BuilderCollectionPayload>, const Paths extends Paramable<BuilderPaths> = Paramable<BuilderPaths>> {
     readonly type: 'collection';
     readonly name: Name;
     readonly payload: Payload;
-    readonly gatePaths?: GatePaths;
-    constructor(name: Name, payload: Payload, gatePaths?: GatePaths);
+    readonly paths?: Paths;
+    constructor(name: Name, payload: Payload, paths?: Paths);
 }
 export declare const BuilderCollectionSchema: v.InstanceSchema<typeof BuilderCollection, undefined>;
 export type BuilderCollections = ReadonlyArray<BuilderCollection>;
-export declare const BuilderCollectionWhenSerialisedSchema: v.GenericSchema;
-export type BuilderCollectionWhenSerialised = WhenSerialised<BuilderCollectionConfigSerialised>;
+export declare const BuilderCollectionWhenSerialisedSchema: v.GenericSchema<BuilderWhenSerialised<Readonly<{
+    model: Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }> | import("..").BuilderModelSerialised;
+    min: number | Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }>;
+    max: number | Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }>;
+}>>>;
+export type BuilderCollectionWhenSerialised = BuilderWhenSerialised<BuilderCollectionConfigSerialised>;
+export declare const BuilderCollectionSelectMapSerialisedSchema: v.GenericSchema<import("..").BuilderMatchSelectMap<Readonly<{
+    type: "parameter";
+    id: string;
+    name: string;
+}> | Readonly<{
+    model: Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }> | import("..").BuilderModelSerialised;
+    min: number | Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }>;
+    max: number | Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }>;
+}>>>;
 export type BuilderCollectionSerialised = {
     readonly name: string;
-    readonly gatePaths?: RefableSerialised<BuilderPaths>;
-    readonly payload: RefableSerialised<BuilderCollectionConfigSerialised | BuilderCollectionWhenSerialised>;
+    readonly paths?: ParamableSerialised<BuilderPaths>;
+    readonly payload: ParamableSerialised<BuilderCollectionConfigSerialised | BuilderCollectionWhenSerialised>;
 };
 export declare const BuilderCollectionSerialisedSchema: v.GenericSchema<BuilderCollectionSerialised>;
 export declare const BuilderCollectionsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<BuilderCollectionSerialised>, undefined>, v.ReadonlyAction<BuilderCollectionSerialised[]>]>;
 export type BuilderCollectionsSerialised = ReadonlyArray<BuilderCollectionSerialised>;
-export type CollectionNamesOf<State extends BuilderState | null> = [State] extends [BuilderState] ? State['collections'][number]['name'] : never;
+export type CollectionNamesOf<State extends BuilderModelState | null> = [State] extends [
+    BuilderModelState
+] ? State['collections'][number]['name'] : never;
 export 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 {};

package/dist/entities/collection/collection.js

@@ -1,42 +1,25 @@
 import * as v from 'valibot';
-import { BuilderException } from '../../exception.js';
 import { BuilderPathsSchema } from '../../paths.js';
-import { isRef, refable } from '../../references.js';
+import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
-import { createWhenSerialisedSchema } from '../when.js';
-import { BuilderCollectionConfig, BuilderCollectionConfigSerialisedSchema } from './config.js';
+import { createSelectMapSerialisedSchema, createWhenSerialisedSchema } from '../when.js';
+import { BuilderCollectionConfigSerialisedSchema } from './config.js';
 export class BuilderCollection {
     name;
     payload;
-    gatePaths;
-    constructor(name, payload, gatePaths) {
+    paths;
+    constructor(name, payload, paths) {
         this.name = name;
         this.payload = payload;
-        this.gatePaths = gatePaths;
-        validateCollectionBounds(name, payload);
-    }
-}
-function validateCollectionBounds(name, payload) {
-    if (!(payload instanceof BuilderCollectionConfig)) {
-        return;
-    }
-    const { min, max } = payload;
-    if (isRef(min) || isRef(max)) {
-        return;
-    }
-    const minValue = min;
-    const maxValue = max;
-    if (minValue < 0 || maxValue <= 0 || maxValue < minValue) {
-        throw new BuilderException([
-            { kind: 'invalid-collection-bounds', name, min: minValue, max: maxValue }
-        ]);
+        this.paths = paths;
     }
 }
 export const BuilderCollectionSchema = v.instance(BuilderCollection);
 export const BuilderCollectionWhenSerialisedSchema = createWhenSerialisedSchema(BuilderCollectionConfigSerialisedSchema);
-export const BuilderCollectionSerialisedSchema = serialisable(BuilderCollection, v.object({
+export const BuilderCollectionSelectMapSerialisedSchema = createSelectMapSerialisedSchema(BuilderCollectionConfigSerialisedSchema);
+export const BuilderCollectionSerialisedSchema = serialisable(v.object({
     name: v.string(),
-    payload: refable(v.union([BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema])),
-    gatePaths: v.optional(refable(BuilderPathsSchema))
+    payload: paramable(v.union([BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema])),
+    paths: v.optional(paramable(BuilderPathsSchema))
 }));
 export const BuilderCollectionsSerialisedSchema = v.pipe(v.array(BuilderCollectionSerialisedSchema), v.readonly());