@builder-builder/builder 0.0.4 → 0.0.5

package/dist/{schemas/serialise.js → serialise/schemas.js}

@@ -1,14 +1,8 @@
 import * as v from 'valibot';
-import { BuilderParameter } from '../core/parameter.js';
-import { BuilderSelectType } from '../core/option/select.js';
-import { BuilderToggleType } from '../core/option/toggle.js';
-import { BuilderPathSchema, BuilderPathsSchema, BuilderPrimitiveSchema } from './primitives.js';
-export const BuilderParameterSchema = v.instance(BuilderParameter);
-export const BuilderOptionValuesSchema = v.union([
-    v.instance(BuilderSelectType),
-    v.instance(BuilderToggleType)
-]);
-export const BuilderOptionValuesMapSchema = v.record(v.string(), v.nullable(BuilderOptionValuesSchema));
+import { BuilderParameterSchema } from '../core/parameter.js';
+import { BuilderOptionValuesMapSchema, BuilderOptionValuesSchema } from '../core/option/option.js';
+import { BuilderPathSchema, BuilderPathsSchema, BuilderPrimitiveSchema } from '../schemas/primitives.js';
+export { BuilderOptionValuesMapSchema, BuilderOptionValuesSchema, BuilderParameterSchema };
 export const BuilderSelectTypeSerialisedSchema = v.pipe(v.object({
     type: v.literal('select'),
     options: v.pipe(v.tupleWithRest([v.string()], v.string()), v.readonly()),
@@ -83,15 +77,6 @@ const BuilderSerialisedCollectionUnlessConfigObject = v.object({
     min: v.number(),
     max: v.number()
 });
-export const BuilderCollectionConfigSerialisedSchema = v.pipe(BuilderSerialisedCollectionConfigObject, v.readonly());
-export const BuilderCollectionEnableConfigSerialisedSchema = v.pipe(BuilderSerialisedCollectionEnableConfigObject, v.readonly());
-export const BuilderCollectionMatchConfigSerialisedSchema = v.pipe(BuilderSerialisedCollectionMatchConfigObject, v.readonly());
-export const BuilderCollectionUnlessConfigSerialisedSchema = v.pipe(BuilderSerialisedCollectionUnlessConfigObject, v.readonly());
-export const BuilderCollectionWhenConfigSerialisedSchema = v.pipe(v.variant('type', [
-    BuilderSerialisedCollectionEnableConfigObject,
-    BuilderSerialisedCollectionMatchConfigObject,
-    BuilderSerialisedCollectionUnlessConfigObject
-]), v.readonly());
 const BuilderSerialisedCollectionObject = v.object({
     name: v.string(),
     builder: lazyBuilder(),
@@ -104,12 +89,6 @@ const BuilderSerialisedCollectionObject = v.object({
         BuilderSerialisedCollectionUnlessConfigObject
     ]))
 });
-export const BuilderCollectionSerialisedSchema = v.pipe(BuilderSerialisedCollectionObject, v.readonly());
-export const BuilderSerialisedSchema = v.pipe(v.object({
-    options: v.pipe(v.array(BuilderOptionSerialisedSchema), v.readonly()),
-    components: v.pipe(v.array(BuilderComponentSerialisedSchema), v.readonly()),
-    collections: v.pipe(v.array(BuilderSerialisedCollectionObject), v.readonly())
-}), v.readonly());
 const BuilderSerialisedUIPageObject = v.object({
     type: v.literal('page'),
     label: v.nullable(v.string()),
@@ -127,6 +106,26 @@ const BuilderSerialisedUICollectionObject = v.object({
     label: v.string(),
     items: lazySerialisedUIItems()
 });
+export const BuilderCollectionConfigSerialisedSchema = v.pipe(BuilderSerialisedCollectionConfigObject, v.readonly());
+export const BuilderCollectionEnableConfigSerialisedSchema = v.pipe(BuilderSerialisedCollectionEnableConfigObject, v.readonly());
+export const BuilderCollectionMatchConfigSerialisedSchema = v.pipe(BuilderSerialisedCollectionMatchConfigObject, v.readonly());
+export const BuilderCollectionUnlessConfigSerialisedSchema = v.pipe(BuilderSerialisedCollectionUnlessConfigObject, v.readonly());
+export const BuilderCollectionWhenConfigSerialisedSchema = v.pipe(v.variant('type', [
+    BuilderSerialisedCollectionEnableConfigObject,
+    BuilderSerialisedCollectionMatchConfigObject,
+    BuilderSerialisedCollectionUnlessConfigObject
+]), v.readonly());
+export const BuilderCollectionSerialisedSchema = v.pipe(BuilderSerialisedCollectionObject, v.readonly());
+export const BuilderExpectationSerialisedSchema = v.pipe(v.object({
+    name: v.string(),
+    kind: v.picklist(['option', 'component'])
+}), v.readonly());
+export const BuilderSerialisedSchema = v.pipe(v.object({
+    options: v.pipe(v.array(BuilderOptionSerialisedSchema), v.readonly()),
+    components: v.pipe(v.array(BuilderComponentSerialisedSchema), v.readonly()),
+    collections: v.pipe(v.array(BuilderSerialisedCollectionObject), v.readonly()),
+    expectations: v.pipe(v.array(BuilderExpectationSerialisedSchema), v.readonly())
+}), v.readonly());
 export const BuilderUIPageSerialisedSchema = v.pipe(BuilderSerialisedUIPageObject, v.readonly());
 export const BuilderUIDescribeSerialisedSchema = v.pipe(BuilderSerialisedUIDescribeObject, v.readonly());
 export const BuilderUICollectionSerialisedSchema = v.pipe(BuilderSerialisedUICollectionObject, v.readonly());

package/dist/serialise/serialise.d.ts

@@ -1,6 +1,6 @@
 import type { BuilderGeneric } from '../core/index';
+import type { BuilderSerialised, BuilderUISerialised } from './schemas';
 import type { BuilderUIGeneric } from '../ui';
-import type { BuilderSerialised, BuilderUISerialised } from '../schemas/index';
 export declare const serialise: {
     builder: typeof serialiseBuilder;
     ui: typeof serialiseUI;

package/dist/serialise/serialise.js

@@ -1,6 +1,5 @@
 import * as v from 'valibot';
-import { BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderSelectType } from '../core/index.js';
-import { BuilderParameterSchema } from '../schemas/index.js';
+import { BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderParameterSchema, BuilderSelectType } from '../core/index.js';
 export const serialise = {
     builder: serialiseBuilder,
     ui: serialiseUI
@@ -9,7 +8,8 @@ function serialiseBuilder(builder) {
     return {
         options: builder.options.map(serialiseOption),
         components: builder.components.map(serialiseComponent),
-        collections: builder.collections.map(serialiseCollection)
+        collections: builder.collections.map(serialiseCollection),
+        expectations: builder.expectations.map(serialiseExpectation)
     };
 }
 function serialiseUI(input) {
@@ -30,6 +30,12 @@ function serialiseComponent(component) {
         dependencies: component.dependencies
     };
 }
+function serialiseExpectation(expectation) {
+    return {
+        name: expectation.name,
+        kind: expectation.kind
+    };
+}
 function serialiseCollection(collection) {
     return {
         name: collection.name,

package/dist/ui.d.ts

@@ -1,16 +1,18 @@
 import type { BuilderModelPaths } from './paths';
 import type { BuilderCollectionNamesOf, BuilderCollectionOf, BuilderGeneric } from './core/index';
+import type { BuilderExpectationEntries, BuilderExpectations, BuilderModelAsserted } from './core/expectation';
 import type { BuilderUIItems } from './schemas/index';
 export type BuilderUIGeneric = BuilderUI<BuilderGeneric>;
 export type BuilderUIFactory<Builder extends BuilderGeneric = BuilderGeneric> = (ui: BuilderUI<Builder>) => BuilderUIGeneric;
-export type BuilderUIPart<Builder extends BuilderGeneric = BuilderGeneric> = BuilderUIGeneric | BuilderUIFactory<Builder>;
-export type BuilderUIParts<Builder extends BuilderGeneric = BuilderGeneric> = ReadonlyArray<BuilderUIPart<Builder>>;
+export type BuilderUIs = ReadonlyArray<BuilderUIGeneric>;
 export declare class BuilderUI<Builder extends BuilderGeneric = BuilderGeneric> {
     readonly builder: Builder;
     readonly items: BuilderUIItems;
-    constructor(builder: Builder, items?: BuilderUIItems);
+    readonly expectations: BuilderExpectationEntries;
+    constructor(builder: Builder, items?: BuilderUIItems, expectations?: BuilderExpectationEntries);
+    expect<const Expectations extends BuilderExpectations>(...expectations: Expectations): BuilderUI<BuilderModelAsserted<Builder, Expectations>>;
     page(label: string | null, paths: BuilderModelPaths<Builder>): BuilderUI<Builder>;
     describe(label: string | null, paths: BuilderModelPaths<Builder>): BuilderUI<Builder>;
     collection<const Name extends BuilderCollectionNamesOf<Builder>>(name: Name, label: string, factory: BuilderUIFactory<BuilderCollectionOf<Builder, Name>['builder']>): BuilderUI<Builder>;
 }
-export declare function ui<const Builder extends BuilderGeneric>(builder: Builder, ...parts: BuilderUIParts<Builder>): BuilderUI<Builder>;
+export declare function ui<const Builder extends BuilderGeneric>(builder: Builder, ...uis: BuilderUIs): BuilderUI<Builder>;

package/dist/ui.js

@@ -1,35 +1,42 @@
 import * as v from 'valibot';
+import { BuilderExpectation } from './core/expectation.js';
 import { check } from './check.js';
 export class BuilderUI {
     builder;
     items;
-    constructor(builder, items = []) {
+    expectations;
+    constructor(builder, items = [], expectations = []) {
         this.builder = builder;
         this.items = items;
+        this.expectations = expectations;
+    }
+    expect(...expectations) {
+        return new BuilderUI(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- type narrowing cast, validated at merge time
+        this.builder, this.items, [...this.expectations, ...expectations]);
     }
     page(label, paths) {
-        return new BuilderUI(this.builder, [...this.items, { type: 'page', label, paths }]);
+        return new BuilderUI(this.builder, [...this.items, { type: 'page', label, paths }], this.expectations);
     }
     describe(label, paths) {
-        return new BuilderUI(this.builder, [...this.items, { type: 'describe', label, paths }]);
+        return new BuilderUI(this.builder, [...this.items, { type: 'describe', label, paths }], this.expectations);
     }
     collection(name, label, factory) {
         const foundCollection = this.builder.collections.find((entry) => entry.name === name);
         check.truthy(foundCollection, `Collection '${name}' not found! ❌`);
         const templateUI = new BuilderUI(foundCollection.builder);
         const result = factory(templateUI);
-        return new BuilderUI(this.builder, [
-            ...this.items,
-            { type: 'collection', name, label, items: result.items }
-        ]);
+        return new BuilderUI(this.builder, [...this.items, { type: 'collection', name, label, items: result.items }], this.expectations);
     }
 }
-export function ui(builder, ...parts) {
-    const base = new BuilderUI(builder);
-    return parts.reduce((accumulated, part) => {
-        if (v.is(v.instance(BuilderUI), part)) {
-            return new BuilderUI(accumulated.builder, [...accumulated.items, ...part.items]);
+export function ui(builder, ...uis) {
+    const merged = uis.reduce((accumulated, ui) => {
+        return new BuilderUI(accumulated.builder, [...accumulated.items, ...ui.items], [...accumulated.expectations, ...ui.expectations]);
+    }, new BuilderUI(builder));
+    merged.expectations.forEach((expectation) => {
+        if (v.is(v.instance(BuilderExpectation), expectation) && expectation.kind === 'option') {
+            expectation.validate(merged.builder.options);
         }
-        return new BuilderUI(accumulated.builder, part(accumulated).items);
-    }, base);
+    });
+    return merged;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "type": "module",
   "exports": {
     ".": {

package/dist/assert/assert.d.ts

@@ -1,28 +0,0 @@
-import type { BuilderStateMerge, BuilderGeneric, BuilderStateOf } from '../core/index';
-import type { Prettify } from '../prettify';
-import type { BuilderUI } from '../ui';
-import type { BuilderExpectations } from './expectation';
-import { BuilderComponent, Builder } from '../core/index.js';
-import { BuilderExpectation } from './expectation.js';
-export type BuilderModelAsserted<BuilderInput extends BuilderGeneric, Expectations extends BuilderExpectations> = Builder<BuilderStateMerge<BuilderStateOf<BuilderInput>, {
-    model: ModelAssert<BuilderInput, Expectations>;
-    components: ComponentAssert<BuilderInput, Expectations>;
-}>>;
-export type BuilderUIModelAsserted<Builder extends BuilderGeneric, Expectations extends BuilderExpectations> = BuilderUI<BuilderModelAsserted<Builder, Expectations>>;
-declare function assertBuilder<const Builder extends BuilderGeneric, const Expectations extends BuilderExpectations>(builder: Builder, ...expectations: Expectations): BuilderModelAsserted<Builder, Expectations>;
-declare function assertUI<const Builder extends BuilderGeneric, const Expectations extends BuilderExpectations>(ui: BuilderUI<Builder>, ...expectations: Expectations): BuilderUIModelAsserted<Builder, Expectations>;
-export declare const assert: {
-    builder: typeof assertBuilder;
-    ui: typeof assertUI;
-};
-type ModelAssert<BuilderInput extends BuilderGeneric, Items extends BuilderExpectations, Current extends BuilderStateOf<BuilderInput> = BuilderStateOf<BuilderInput>, Asserted extends ExpectedModel<Items> = ExpectedModel<Items>> = unknown extends Current['model'] ? Prettify<Asserted> : Prettify<Current['model'] & Asserted>;
-type ComponentAssert<BuilderInput extends BuilderGeneric, Items extends BuilderExpectations, Current extends BuilderStateOf<BuilderInput> = BuilderStateOf<BuilderInput>, Asserted extends ExpectedComponents<Items> = ExpectedComponents<Items>> = Current['components'] extends [] ? ExpectedComponents<Items> : number extends Asserted['length'] ? Asserted : [...Current['components'], ...Asserted];
-type ExpectedModel<Items extends ReadonlyArray<BuilderExpectation>> = Items extends readonly [
-    infer Head,
-    ...infer Tail extends ReadonlyArray<BuilderExpectation>
-] ? (Head extends BuilderExpectation<infer Name, infer Value> ? [Value] extends [never] ? unknown : Record<Name, Value> : unknown) & ExpectedModel<Tail> : unknown;
-type ExpectedComponents<Items extends ReadonlyArray<BuilderExpectation>> = Items extends readonly [
-    infer Head,
-    ...infer Tail extends ReadonlyArray<BuilderExpectation>
-] ? Head extends BuilderExpectation<infer Name, Array<any>> ? [BuilderComponent<Name>, ...ExpectedComponents<Tail>] : ExpectedComponents<Tail> : [];
-export {};

package/dist/assert/assert.js

@@ -1,28 +0,0 @@
-import * as v from 'valibot';
-import { BuilderComponent, Builder } from '../core/index.js';
-import { BuilderExpectation } from './expectation.js';
-function assertBuilder(builder, ...expectations) {
-    expectations.forEach((expectation) => {
-        if (v.is(v.instance(BuilderExpectation), expectation)) {
-            if (expectation.kind === 'option') {
-                expectation.validate(builder.options);
-            }
-            else if (expectation.kind === 'component') {
-                expectation.validate(builder.components);
-            }
-        }
-    });
-    return builder;
-}
-function assertUI(ui, ...expectations) {
-    expectations.forEach((expectation) => {
-        if (v.is(v.instance(BuilderExpectation), expectation) && expectation.kind === 'option') {
-            expectation.validate(ui.builder.options);
-        }
-    });
-    return ui;
-}
-export const assert = {
-    builder: assertBuilder,
-    ui: assertUI
-};

package/dist/assert/expectation.d.ts

@@ -1,20 +0,0 @@
-import type { BuilderComponentEntries, BuilderOptionEntries } from '../core/index';
-export type BuilderExpectationKind = 'option' | 'component';
-export type BuilderExpectationEntries = BuilderOptionEntries | BuilderComponentEntries;
-export declare class BuilderExpectation<Name extends string = string, Value = unknown> {
-    readonly name: Name;
-    readonly kind: BuilderExpectationKind;
-    constructor(name: Name, kind: BuilderExpectationKind);
-    optional(): BuilderExpectation<Name, Value | null>;
-    validate(entries: BuilderExpectationEntries): void;
-}
-export type BuilderExpectations = readonly [
-    BuilderExpectation,
-    ...ReadonlyArray<BuilderExpectation>
-];
-export declare const option: {
-    expect: <const Name extends string>(name: Name) => BuilderExpectation<Name, string>;
-};
-export declare const component: {
-    expect: <const Name extends string>(name: Name) => BuilderExpectation<Name, never>;
-};

package/dist/assert/index.d.ts

@@ -1,3 +0,0 @@
-export type { BuilderExpectations } from './expectation';
-export { assert } from './assert.js';
-export { BuilderExpectation, component, option } from './expectation.js';

package/dist/assert/index.js

@@ -1,2 +0,0 @@
-export { assert } from './assert.js';
-export { BuilderExpectation, component, option } from './expectation.js';

package/dist/schemas/layout.d.ts

@@ -1,52 +0,0 @@
-import * as v from 'valibot';
-export declare const BuilderLayoutOptionSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly path: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
-}, undefined>, v.ReadonlyAction<{
-    readonly path: readonly (string | number)[];
-}>]>;
-export type BuilderLayoutOption = v.InferOutput<typeof BuilderLayoutOptionSchema>;
-export declare const BuilderLayoutOptionsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly path: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
-}, undefined>, v.ReadonlyAction<{
-    readonly path: readonly (string | number)[];
-}>]>, undefined>, v.ReadonlyAction<Readonly<{
-    readonly path: readonly (string | number)[];
-}>[]>]>;
-export type BuilderLayoutOptions = v.InferOutput<typeof BuilderLayoutOptionsSchema>;
-export declare const BuilderLayoutPageSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    readonly options: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly path: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
-    }, undefined>, v.ReadonlyAction<{
-        readonly path: readonly (string | number)[];
-    }>]>, undefined>, v.ReadonlyAction<Readonly<{
-        readonly path: readonly (string | number)[];
-    }>[]>]>;
-}, undefined>, v.ReadonlyAction<{
-    label: string | null;
-    readonly options: readonly Readonly<{
-        readonly path: readonly (string | number)[];
-    }>[];
-}>]>;
-export type BuilderLayoutPage = v.InferOutput<typeof BuilderLayoutPageSchema>;
-export declare const BuilderLayoutSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    readonly options: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly path: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
-    }, undefined>, v.ReadonlyAction<{
-        readonly path: readonly (string | number)[];
-    }>]>, undefined>, v.ReadonlyAction<Readonly<{
-        readonly path: readonly (string | number)[];
-    }>[]>]>;
-}, undefined>, v.ReadonlyAction<{
-    label: string | null;
-    readonly options: readonly Readonly<{
-        readonly path: readonly (string | number)[];
-    }>[];
-}>]>, undefined>, v.ReadonlyAction<Readonly<{
-    label: string | null;
-    readonly options: readonly Readonly<{
-        readonly path: readonly (string | number)[];
-    }>[];
-}>[]>]>;
-export type BuilderLayout = v.InferOutput<typeof BuilderLayoutSchema>;

package/dist/schemas/layout.js

@@ -1,6 +0,0 @@
-import * as v from 'valibot';
-import { BuilderPathSchema } from './primitives.js';
-export const BuilderLayoutOptionSchema = v.pipe(v.object({ path: BuilderPathSchema }), v.readonly());
-export const BuilderLayoutOptionsSchema = v.pipe(v.array(BuilderLayoutOptionSchema), v.readonly());
-export const BuilderLayoutPageSchema = v.pipe(v.object({ label: v.nullable(v.string()), options: BuilderLayoutOptionsSchema }), v.readonly());
-export const BuilderLayoutSchema = v.pipe(v.array(BuilderLayoutPageSchema), v.readonly());