@builder-builder/builder 0.0.3 → 0.0.5

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

@@ -1,56 +1,51 @@
 import * as v from 'valibot';
-import { BuilderPathSchema, BuilderPathsSchema, BuilderPrimitiveSchema } from './primitives.js';
-const BuilderSerialisedSelectTypeObject = v.object({
+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()),
     defaultValue: v.nullable(v.string()),
     optional: v.boolean(),
     labels: v.record(v.string(), v.string())
-});
-const BuilderSerialisedToggleTypeObject = v.object({
+}), v.readonly());
+export const BuilderToggleTypeSerialisedSchema = v.pipe(v.object({
     type: v.literal('toggle'),
     valueType: v.string(),
     defaultValue: v.nullable(v.union([v.boolean(), v.string(), v.number()])),
     optional: v.boolean()
-});
-export const BuilderSelectTypeSerialisedSchema = v.pipe(BuilderSerialisedSelectTypeObject, v.readonly());
-export const BuilderToggleTypeSerialisedSchema = v.pipe(BuilderSerialisedToggleTypeObject, v.readonly());
-export const BuilderValuesSerialisedSchema = v.pipe(v.variant('type', [BuilderSerialisedSelectTypeObject, BuilderSerialisedToggleTypeObject]), v.readonly());
-const BuilderSerialisedOptionEnableConfigObject = v.object({
+}), v.readonly());
+export const BuilderParameterSerialisedSchema = v.pipe(v.object({ type: v.literal('parameter') }), v.readonly());
+export const BuilderValuesSerialisedSchema = v.pipe(v.variant('type', [BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSerialisedSchema]), v.readonly());
+export const BuilderOptionEnableConfigSerialisedSchema = v.pipe(v.object({
     type: v.literal('enable'),
-    values: v.variant('type', [BuilderSerialisedSelectTypeObject, BuilderSerialisedToggleTypeObject])
-});
-const BuilderSerialisedOptionMatchConfigObject = v.object({
+    values: v.union([BuilderValuesSerialisedSchema, BuilderParameterSerialisedSchema])
+}), v.readonly());
+export const BuilderOptionMatchConfigSerialisedSchema = v.pipe(v.object({
     type: v.literal('match'),
     matchPath: BuilderPathSchema,
-    selectMap: v.record(v.string(), v.nullable(v.variant('type', [BuilderSerialisedSelectTypeObject, BuilderSerialisedToggleTypeObject])))
-});
-const BuilderSerialisedOptionUnlessConfigObject = v.object({
+    selectMap: v.union([
+        v.record(v.string(), v.nullable(BuilderValuesSerialisedSchema)),
+        BuilderParameterSerialisedSchema
+    ])
+}), v.readonly());
+export const BuilderOptionUnlessConfigSerialisedSchema = v.pipe(v.object({
     type: v.literal('unless'),
     unlessPath: BuilderPathSchema,
     disabledValues: v.pipe(v.array(BuilderPrimitiveSchema), v.readonly()),
-    values: v.variant('type', [BuilderSerialisedSelectTypeObject, BuilderSerialisedToggleTypeObject])
-});
-export const BuilderOptionEnableConfigSerialisedSchema = v.pipe(BuilderSerialisedOptionEnableConfigObject, v.readonly());
-export const BuilderOptionMatchConfigSerialisedSchema = v.pipe(BuilderSerialisedOptionMatchConfigObject, v.readonly());
-export const BuilderOptionUnlessConfigSerialisedSchema = v.pipe(BuilderSerialisedOptionUnlessConfigObject, v.readonly());
+    values: v.union([BuilderValuesSerialisedSchema, BuilderParameterSerialisedSchema])
+}), v.readonly());
 export const BuilderOptionWhenConfigSerialisedSchema = v.pipe(v.variant('type', [
-    BuilderSerialisedOptionEnableConfigObject,
-    BuilderSerialisedOptionMatchConfigObject,
-    BuilderSerialisedOptionUnlessConfigObject
+    BuilderOptionEnableConfigSerialisedSchema,
+    BuilderOptionMatchConfigSerialisedSchema,
+    BuilderOptionUnlessConfigSerialisedSchema
 ]), v.readonly());
 export const BuilderOptionSerialisedSchema = v.pipe(v.object({
     name: v.string(),
-    values: v.variant('type', [
-        BuilderSerialisedSelectTypeObject,
-        BuilderSerialisedToggleTypeObject
-    ]),
+    values: v.union([BuilderValuesSerialisedSchema, BuilderParameterSerialisedSchema]),
     gatePaths: BuilderPathsSchema,
-    config: v.nullable(v.variant('type', [
-        BuilderSerialisedOptionEnableConfigObject,
-        BuilderSerialisedOptionMatchConfigObject,
-        BuilderSerialisedOptionUnlessConfigObject
-    ]))
+    config: v.nullable(BuilderOptionWhenConfigSerialisedSchema)
 }), v.readonly());
 export const BuilderComponentSerialisedSchema = v.pipe(v.object({
     name: v.string(),
@@ -82,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(),
@@ -103,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()),
@@ -126,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,5 +1,5 @@
 import * as v from 'valibot';
-import { BuilderCollection, BuilderComponent, BuilderOption, BuilderSelectType } from '../core/index.js';
+import { BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderParameterSchema, BuilderSelectType } from '../core/index.js';
 export const serialise = {
     builder: serialiseBuilder,
     ui: serialiseUI
@@ -8,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) {
@@ -29,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,
@@ -40,6 +47,9 @@ function serialiseCollection(collection) {
     };
 }
 function serialiseValues(optionValues) {
+    if (v.is(BuilderParameterSchema, optionValues)) {
+        return { type: 'parameter' };
+    }
     if (v.is(v.instance(BuilderSelectType), optionValues)) {
         return {
             type: 'select',
@@ -65,6 +75,13 @@ function serialiseOptionWhenConfig(config) {
             return { type: 'enable', values: serialiseValues(config.values) };
         }
         case 'match': {
+            if (v.is(BuilderParameterSchema, config.selectMap)) {
+                return {
+                    type: 'match',
+                    matchPath: config.matchPath,
+                    selectMap: { type: 'parameter' }
+                };
+            }
             return {
                 type: 'match',
                 matchPath: config.matchPath,

package/dist/ui.d.ts

@@ -1,18 +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<B extends BuilderGeneric = BuilderGeneric> = (ui: BuilderUI<B>) => BuilderUIGeneric;
-export type BuilderUIPart<B extends BuilderGeneric = BuilderGeneric> = BuilderUIGeneric | BuilderUIFactory<B>;
-export type BuilderUIParts<B extends BuilderGeneric = BuilderGeneric> = ReadonlyArray<BuilderUIPart<B>>;
-export declare class BuilderUI<B extends BuilderGeneric = BuilderGeneric> {
-    readonly builder: B;
+export type BuilderUIFactory<Builder extends BuilderGeneric = BuilderGeneric> = (ui: BuilderUI<Builder>) => BuilderUIGeneric;
+export type BuilderUIs = ReadonlyArray<BuilderUIGeneric>;
+export declare class BuilderUI<Builder extends BuilderGeneric = BuilderGeneric> {
+    readonly builder: Builder;
     readonly items: BuilderUIItems;
-    constructor(builder: B, items?: BuilderUIItems);
-    page(label: string | null, paths: BuilderModelPaths<B>): BuilderUI<B>;
-    describe(label: string | null, paths: BuilderModelPaths<B>): BuilderUI<B>;
-    collection<const Name extends BuilderCollectionNamesOf<B>>(name: Name, label: string, factory: BuilderUIFactory<CollectionItemBuilder<B, Name>>): BuilderUI<B>;
+    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 B extends BuilderGeneric>(builder: B, ...parts: BuilderUIParts<B>): BuilderUI<B>;
-type CollectionItemBuilder<BuilderInput extends BuilderGeneric, Name extends string> = BuilderCollectionOf<BuilderInput, Name>['builder'] extends BuilderGeneric ? BuilderCollectionOf<BuilderInput, Name>['builder'] : BuilderGeneric;
-export {};
+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 { invariant } from './invariant.js';
+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);
-        invariant(foundCollection, `Collection '${String(name)}' not found! ❌`);
+        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.3",
+  "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, Items extends BuilderExpectations> = Builder<BuilderStateMerge<BuilderStateOf<BuilderInput>, {
-    model: ModelAssert<BuilderInput, Items>;
-    components: ComponentAssert<BuilderInput, Items>;
-}>>;
-export type BuilderUIModelAsserted<BuilderInput extends BuilderGeneric, Items extends BuilderExpectations> = BuilderUI<BuilderModelAsserted<BuilderInput, Items>>;
-declare function assertBuilder<const R extends BuilderGeneric, const Items extends BuilderExpectations>(builder: R, ...items: Items): BuilderModelAsserted<R, Items>;
-declare function assertUI<const R extends BuilderGeneric, const Items extends BuilderExpectations>(ui: BuilderUI<R>, ...items: Items): BuilderUIModelAsserted<R, Items>;
-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, ...items) {
-    items.forEach((item) => {
-        if (v.is(v.instance(BuilderExpectation), item)) {
-            if (item.kind === 'option') {
-                item.validate(builder.options);
-            }
-            else if (item.kind === 'component') {
-                item.validate(builder.components);
-            }
-        }
-    });
-    return builder;
-}
-function assertUI(ui, ...items) {
-    items.forEach((item) => {
-        if (v.is(v.instance(BuilderExpectation), item) && item.kind === 'option') {
-            item.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/invariant.d.ts

@@ -1 +0,0 @@
-export declare function invariant<Input>(input: Input, message?: `${string}! ❌`): asserts input is Exclude<Input, null | undefined | '' | 0 | false>;

package/dist/invariant.js

@@ -1,6 +0,0 @@
-const DEFAULT_INVARIANT_MESSAGE = 'Unexpected falsy value! ❌';
-export function invariant(input, message = DEFAULT_INVARIANT_MESSAGE) {
-    if (!input) {
-        throw new Error(message);
-    }
-}

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());