@builder-builder/builder 0.0.3 → 0.0.4

package/dist/schemas/serialise.js

@@ -1,56 +1,57 @@
 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';
-const BuilderSerialisedSelectTypeObject = v.object({
+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));
+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(),

package/dist/serialise/deserialise.js

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-import { BuilderCollection, BuilderComponent, BuilderComponentGraph, BuilderOption, BuilderOptionGraph, Builder, BuilderSelectType, BuilderToggleType } from '../core/index.js';
+import { BuilderCollection, BuilderComponent, BuilderOption, Builder, BuilderParameter, BuilderSelectType, BuilderToggleType } from '../core/index.js';
 import { BuilderSerialisedSchema, BuilderUIItemsSerialisedSchema } from '../schemas/index.js';
 import { BuilderUI } from '../ui.js';
 export const deserialise = {
@@ -16,10 +16,7 @@ function buildBuilder(data) {
     const options = data.options.map(deserialiseOption);
     const components = data.components.map(deserialiseComponent);
     const collections = data.collections.map(deserialiseCollection);
-    const rebuiltOptionGraph = options.reduce((graph, option) => graph.add(option), new BuilderOptionGraph());
-    const rebuiltComponentGraph = components.reduce((graph, component) => graph.add(component, rebuiltOptionGraph), new BuilderComponentGraph());
-    const collectionComponentGraphs = collections.map((collection) => collection.builder.componentGraph);
-    return new Builder(options, collections, components, rebuiltOptionGraph, BuilderComponentGraph.merge(rebuiltComponentGraph, ...collectionComponentGraphs));
+    return new Builder(options, collections, components);
 }
 function deserialiseOption(data) {
     const values = deserialiseValues(data.values);
@@ -35,6 +32,9 @@ function deserialiseCollection(data) {
     return new BuilderCollection(data.name, built, data.min, data.max, data.gatePaths, config);
 }
 function deserialiseValues(data) {
+    if (data.type === 'parameter') {
+        return new BuilderParameter();
+    }
     if (data.type === 'select') {
         const { optional, options, defaultValue, labels } = data;
         const valueSchema = v.union(options.map((value) => v.literal(value)));
@@ -63,11 +63,16 @@ function deserialiseOptionWhenConfig(data) {
         }
         case 'match': {
             const { matchPath, type } = data;
+            if ('type' in data.selectMap && data.selectMap.type === 'parameter') {
+                const parameter = new BuilderParameter();
+                return { type, matchPath, selectMap: parameter, values: parameter };
+            }
             const selectMap = Object.fromEntries(Object.entries(data.selectMap).map(([key, value]) => [
                 key,
                 value ? deserialiseValues(value) : null
             ]));
-            return { type, matchPath, selectMap };
+            const values = Object.values(selectMap).find((value) => value !== null);
+            return { type, matchPath, selectMap, values };
         }
         case 'unless': {
             const { type, unlessPath, disabledValues } = data;

package/dist/serialise/serialise.js

@@ -1,5 +1,6 @@
 import * as v from 'valibot';
-import { BuilderCollection, BuilderComponent, BuilderOption, BuilderSelectType } from '../core/index.js';
+import { BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderSelectType } from '../core/index.js';
+import { BuilderParameterSchema } from '../schemas/index.js';
 export const serialise = {
     builder: serialiseBuilder,
     ui: serialiseUI
@@ -40,6 +41,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 +69,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

@@ -2,17 +2,15 @@ import type { BuilderModelPaths } from './paths';
 import type { BuilderCollectionNamesOf, BuilderCollectionOf, BuilderGeneric } from './core/index';
 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 BuilderUIPart<Builder extends BuilderGeneric = BuilderGeneric> = BuilderUIGeneric | BuilderUIFactory<Builder>;
+export type BuilderUIParts<Builder extends BuilderGeneric = BuilderGeneric> = ReadonlyArray<BuilderUIPart<Builder>>;
+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>;
+    constructor(builder: Builder, items?: BuilderUIItems);
+    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, ...parts: BuilderUIParts<Builder>): BuilderUI<Builder>;

package/dist/ui.js

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-import { invariant } from './invariant.js';
+import { check } from './check.js';
 export class BuilderUI {
     builder;
     items;
@@ -15,7 +15,7 @@ export class BuilderUI {
     }
     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, [

package/package.json

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

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