@builder-builder/builder 0.0.1

package/dist/schemas/serialise.js

@@ -0,0 +1,141 @@
+import * as v from 'valibot';
+import { BuilderPathSchema, BuilderPathsSchema, BuilderPrimitiveSchema } from './primitives.js';
+const BuilderSerialisedSelectTypeObject = 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({
+    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({
+    type: v.literal('enable'),
+    values: v.variant('type', [BuilderSerialisedSelectTypeObject, BuilderSerialisedToggleTypeObject])
+});
+const BuilderSerialisedOptionMatchConfigObject = v.object({
+    type: v.literal('match'),
+    matchPath: BuilderPathSchema,
+    selectMap: v.record(v.string(), v.nullable(v.variant('type', [BuilderSerialisedSelectTypeObject, BuilderSerialisedToggleTypeObject])))
+});
+const BuilderSerialisedOptionUnlessConfigObject = 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());
+export const BuilderOptionWhenConfigSerialisedSchema = v.pipe(v.variant('type', [
+    BuilderSerialisedOptionEnableConfigObject,
+    BuilderSerialisedOptionMatchConfigObject,
+    BuilderSerialisedOptionUnlessConfigObject
+]), v.readonly());
+export const BuilderOptionSerialisedSchema = v.pipe(v.object({
+    name: v.string(),
+    values: v.variant('type', [
+        BuilderSerialisedSelectTypeObject,
+        BuilderSerialisedToggleTypeObject
+    ]),
+    gatePaths: BuilderPathsSchema,
+    config: v.nullable(v.variant('type', [
+        BuilderSerialisedOptionEnableConfigObject,
+        BuilderSerialisedOptionMatchConfigObject,
+        BuilderSerialisedOptionUnlessConfigObject
+    ]))
+}), v.readonly());
+export const BuilderComponentSerialisedSchema = v.pipe(v.object({
+    name: v.string(),
+    paths: BuilderPathsSchema,
+    dependencies: v.pipe(v.array(v.string()), v.readonly())
+}), v.readonly());
+const lazyBuilder = () => v.lazy(() => BuilderSerialisedSchema);
+const BuilderSerialisedCollectionConfigObject = v.object({
+    builder: lazyBuilder(),
+    min: v.number(),
+    max: v.number()
+});
+const BuilderSerialisedCollectionEnableConfigObject = v.object({
+    type: v.literal('enable'),
+    builder: lazyBuilder(),
+    min: v.number(),
+    max: v.number()
+});
+const BuilderSerialisedCollectionMatchConfigObject = v.object({
+    type: v.literal('match'),
+    matchPath: BuilderPathSchema,
+    selectMap: v.record(v.string(), v.nullable(BuilderSerialisedCollectionConfigObject))
+});
+const BuilderSerialisedCollectionUnlessConfigObject = v.object({
+    type: v.literal('unless'),
+    unlessPath: BuilderPathSchema,
+    disabledValues: v.pipe(v.array(BuilderPrimitiveSchema), v.readonly()),
+    builder: lazyBuilder(),
+    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(),
+    min: v.number(),
+    max: v.number(),
+    gatePaths: BuilderPathsSchema,
+    config: v.nullable(v.variant('type', [
+        BuilderSerialisedCollectionEnableConfigObject,
+        BuilderSerialisedCollectionMatchConfigObject,
+        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()),
+    paths: BuilderPathsSchema
+});
+const BuilderSerialisedUIDescribeObject = v.object({
+    type: v.literal('describe'),
+    label: v.nullable(v.string()),
+    paths: BuilderPathsSchema
+});
+const lazySerialisedUIItems = () => v.lazy(() => BuilderUIItemsSerialisedSchema);
+const BuilderSerialisedUICollectionObject = v.object({
+    type: v.literal('collection'),
+    name: v.string(),
+    label: v.string(),
+    items: lazySerialisedUIItems()
+});
+export const BuilderUIPageSerialisedSchema = v.pipe(BuilderSerialisedUIPageObject, v.readonly());
+export const BuilderUIDescribeSerialisedSchema = v.pipe(BuilderSerialisedUIDescribeObject, v.readonly());
+export const BuilderUICollectionSerialisedSchema = v.pipe(BuilderSerialisedUICollectionObject, v.readonly());
+export const BuilderUIItemSerialisedSchema = v.pipe(v.variant('type', [
+    BuilderSerialisedUIPageObject,
+    BuilderSerialisedUIDescribeObject,
+    BuilderSerialisedUICollectionObject
+]), v.readonly());
+export const BuilderUIItemsSerialisedSchema = v.pipe(v.array(v.variant('type', [
+    BuilderSerialisedUIPageObject,
+    BuilderSerialisedUIDescribeObject,
+    BuilderSerialisedUICollectionObject
+])), v.readonly());

package/dist/schemas/ui.d.ts

@@ -0,0 +1,96 @@
+import * as v from 'valibot';
+export declare const BuilderUIPageSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"page", undefined>;
+    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly paths: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+}, undefined>, v.ReadonlyAction<{
+    type: "page";
+    label: string | null;
+    readonly paths: readonly (readonly (string | number)[])[];
+}>]>;
+export type BuilderUIPage = v.InferOutput<typeof BuilderUIPageSchema>;
+export declare const BuilderUIDescribeSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"describe", undefined>;
+    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly paths: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+}, undefined>, v.ReadonlyAction<{
+    type: "describe";
+    label: string | null;
+    readonly paths: readonly (readonly (string | number)[])[];
+}>]>;
+export type BuilderUIDescribe = v.InferOutput<typeof BuilderUIDescribeSchema>;
+export type BuilderUICollection = {
+    readonly type: 'collection';
+    readonly name: string;
+    readonly label: string;
+    readonly items: BuilderUIItems;
+};
+export type BuilderUIItem = BuilderUIPage | BuilderUIDescribe | BuilderUICollection;
+export type BuilderUIItems = ReadonlyArray<BuilderUIItem>;
+type UIItemsSchemaType = v.GenericSchema<BuilderUIItems>;
+export declare const BuilderUICollectionSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"collection", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly label: v.StringSchema<undefined>;
+    readonly items: v.LazySchema<UIItemsSchemaType>;
+}, undefined>, v.ReadonlyAction<{
+    type: "collection";
+    name: string;
+    label: string;
+    items: BuilderUIItems;
+}>]>;
+export declare const BuilderUIItemSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"page", undefined>;
+    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly paths: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"describe", undefined>;
+    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly paths: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"collection", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly label: v.StringSchema<undefined>;
+    readonly items: v.LazySchema<UIItemsSchemaType>;
+}, undefined>], undefined>, v.ReadonlyAction<{
+    type: "page";
+    label: string | null;
+    readonly paths: readonly (readonly (string | number)[])[];
+} | {
+    type: "describe";
+    label: string | null;
+    readonly paths: readonly (readonly (string | number)[])[];
+} | {
+    type: "collection";
+    name: string;
+    label: string;
+    items: BuilderUIItems;
+}>]>;
+export declare const BuilderUIItemsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"page", undefined>;
+    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly paths: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"describe", undefined>;
+    readonly label: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly paths: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"collection", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly label: v.StringSchema<undefined>;
+    readonly items: v.LazySchema<UIItemsSchemaType>;
+}, undefined>], undefined>, undefined>, v.ReadonlyAction<({
+    type: "page";
+    label: string | null;
+    readonly paths: readonly (readonly (string | number)[])[];
+} | {
+    type: "describe";
+    label: string | null;
+    readonly paths: readonly (readonly (string | number)[])[];
+} | {
+    type: "collection";
+    name: string;
+    label: string;
+    items: BuilderUIItems;
+})[]>]>;
+export {};

package/dist/schemas/ui.js

@@ -0,0 +1,23 @@
+import * as v from 'valibot';
+import { BuilderPathsSchema } from './primitives.js';
+const BuilderUIPageObject = v.object({
+    type: v.literal('page'),
+    label: v.nullable(v.string()),
+    paths: BuilderPathsSchema
+});
+const BuilderUIDescribeObject = v.object({
+    type: v.literal('describe'),
+    label: v.nullable(v.string()),
+    paths: BuilderPathsSchema
+});
+export const BuilderUIPageSchema = v.pipe(BuilderUIPageObject, v.readonly());
+export const BuilderUIDescribeSchema = v.pipe(BuilderUIDescribeObject, v.readonly());
+const BuilderUICollectionObject = v.object({
+    type: v.literal('collection'),
+    name: v.string(),
+    label: v.string(),
+    items: v.lazy(() => BuilderUIItemsSchema)
+});
+export const BuilderUICollectionSchema = v.pipe(BuilderUICollectionObject, v.readonly());
+export const BuilderUIItemSchema = v.pipe(v.variant('type', [BuilderUIPageObject, BuilderUIDescribeObject, BuilderUICollectionObject]), v.readonly());
+export const BuilderUIItemsSchema = v.pipe(v.array(v.variant('type', [BuilderUIPageObject, BuilderUIDescribeObject, BuilderUICollectionObject])), v.readonly());

package/dist/serialise/deserialise.d.ts

@@ -0,0 +1,9 @@
+import type { BuilderGeneric } from '../core/index';
+import type { BuilderUIGeneric } from '../ui';
+export declare const deserialise: {
+    builder: typeof deserialiseBuilder;
+    ui: typeof deserialiseUI;
+};
+declare function deserialiseBuilder(data: unknown): BuilderGeneric;
+declare function deserialiseUI(builder: BuilderGeneric, data: unknown): BuilderUIGeneric;
+export {};

package/dist/serialise/deserialise.js

@@ -0,0 +1,108 @@
+import * as v from 'valibot';
+import { BuilderCollection, BuilderComponent, BuilderComponentGraph, BuilderOption, BuilderOptionGraph, Builder, BuilderSelectType, BuilderToggleType } from '../core/index.js';
+import { BuilderSerialisedSchema, BuilderUIItemsSerialisedSchema } from '../schemas/index.js';
+import { BuilderUI } from '../ui.js';
+export const deserialise = {
+    builder: deserialiseBuilder,
+    ui: deserialiseUI
+};
+function deserialiseBuilder(data) {
+    return buildBuilder(v.parse(BuilderSerialisedSchema, data));
+}
+function deserialiseUI(builder, data) {
+    return new BuilderUI(builder, v.parse(BuilderUIItemsSerialisedSchema, data));
+}
+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));
+}
+function deserialiseOption(data) {
+    const values = deserialiseValues(data.values);
+    const config = deserialiseOptionWhenConfig(data.config);
+    return new BuilderOption(data.name, values, data.gatePaths, config);
+}
+function deserialiseComponent(data) {
+    return new BuilderComponent(data.name, data.paths, data.dependencies);
+}
+function deserialiseCollection(data) {
+    const built = buildBuilder(data.builder);
+    const config = deserialiseCollectionWhenConfig(data.config);
+    return new BuilderCollection(data.name, built, data.min, data.max, data.gatePaths, config);
+}
+function deserialiseValues(data) {
+    if (data.type === 'select') {
+        const { optional, options, defaultValue, labels } = data;
+        const valueSchema = v.union(options.map((value) => v.literal(value)));
+        return new BuilderSelectType(options, optional ? v.nullable(valueSchema) : valueSchema, defaultValue, optional, labels);
+    }
+    const valueSchema = deserialiseToggleValueSchema(data.valueType, data.optional);
+    return new BuilderToggleType(valueSchema, data.defaultValue, data.optional);
+}
+function deserialiseToggleValueSchema(valueType, optional) {
+    const base = valueType.includes('boolean')
+        ? v.boolean()
+        : valueType.includes('string')
+            ? v.string()
+            : v.number();
+    return optional ? v.nullable(base) : base;
+}
+function deserialiseOptionWhenConfig(data) {
+    if (data === null) {
+        return null;
+    }
+    switch (data.type) {
+        case 'enable': {
+            const { type } = data;
+            const values = deserialiseValues(data.values);
+            return { type, values };
+        }
+        case 'match': {
+            const { matchPath, type } = data;
+            const selectMap = Object.fromEntries(Object.entries(data.selectMap).map(([key, value]) => [
+                key,
+                value ? deserialiseValues(value) : null
+            ]));
+            return { type, matchPath, selectMap };
+        }
+        case 'unless': {
+            const { type, unlessPath, disabledValues } = data;
+            const values = deserialiseValues(data.values);
+            return { type, unlessPath, disabledValues, values };
+        }
+    }
+}
+function deserialiseCollectionWhenConfig(data) {
+    if (data === null) {
+        return null;
+    }
+    switch (data.type) {
+        case 'enable': {
+            const { max, min, builder: builderData, type } = data;
+            return { type, builder: buildBuilder(builderData), min, max };
+        }
+        case 'match': {
+            const { matchPath, selectMap, type } = data;
+            const deserialisedSelectMap = Object.fromEntries(Object.entries(selectMap).map(([key, value]) => {
+                if (!value) {
+                    return [key, null];
+                }
+                const { builder: builderData, min, max } = value;
+                return [key, { builder: buildBuilder(builderData), min, max }];
+            }));
+            return {
+                type,
+                matchPath,
+                selectMap: deserialisedSelectMap
+            };
+        }
+        case 'unless': {
+            const { disabledValues, max, min, builder: builderData, type, unlessPath } = data;
+            return { type, unlessPath, disabledValues, builder: buildBuilder(builderData), min, max };
+        }
+    }
+}

package/dist/serialise/index.d.ts

@@ -0,0 +1,4 @@
+export type { BuilderCollectionSerialised, BuilderCollectionConfigSerialised, BuilderCollectionEnableConfigSerialised, BuilderCollectionMatchConfigSerialised, BuilderCollectionUnlessConfigSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderOptionSerialised, BuilderOptionEnableConfigSerialised, BuilderOptionMatchConfigSerialised, BuilderOptionUnlessConfigSerialised, BuilderOptionWhenConfigSerialised, BuilderSerialised, BuilderSelectTypeSerialised, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderUICollectionSerialised, BuilderUIDescribeSerialised, BuilderUIItemSerialised, BuilderUIItemsSerialised, BuilderUIPageSerialised, BuilderValuesSerialised } from '../schemas/index';
+export { BuilderCollectionConfigSerialisedSchema, BuilderCollectionEnableConfigSerialisedSchema, BuilderCollectionMatchConfigSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionUnlessConfigSerialisedSchema, BuilderCollectionWhenConfigSerialisedSchema, BuilderComponentSerialisedSchema, BuilderOptionEnableConfigSerialisedSchema, BuilderOptionMatchConfigSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionUnlessConfigSerialisedSchema, BuilderOptionWhenConfigSerialisedSchema, BuilderSerialisedSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSerialisedSchema, BuilderUICollectionSerialisedSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSerialisedSchema, BuilderValuesSerialisedSchema } from '../schemas/index.js';
+export { deserialise } from './deserialise.js';
+export { serialise } from './serialise.js';

package/dist/serialise/index.js

@@ -0,0 +1,3 @@
+export { BuilderCollectionConfigSerialisedSchema, BuilderCollectionEnableConfigSerialisedSchema, BuilderCollectionMatchConfigSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionUnlessConfigSerialisedSchema, BuilderCollectionWhenConfigSerialisedSchema, BuilderComponentSerialisedSchema, BuilderOptionEnableConfigSerialisedSchema, BuilderOptionMatchConfigSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionUnlessConfigSerialisedSchema, BuilderOptionWhenConfigSerialisedSchema, BuilderSerialisedSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSerialisedSchema, BuilderUICollectionSerialisedSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSerialisedSchema, BuilderValuesSerialisedSchema } from '../schemas/index.js';
+export { deserialise } from './deserialise.js';
+export { serialise } from './serialise.js';

package/dist/serialise/serialise.d.ts

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

package/dist/serialise/serialise.js

@@ -0,0 +1,123 @@
+import * as v from 'valibot';
+import { BuilderCollection, BuilderComponent, BuilderOption, BuilderSelectType } from '../core/index.js';
+export const serialise = {
+    builder: serialiseBuilder,
+    ui: serialiseUI
+};
+function serialiseBuilder(builder) {
+    return {
+        options: builder.options.map(serialiseOption),
+        components: builder.components.map(serialiseComponent),
+        collections: builder.collections.map(serialiseCollection)
+    };
+}
+function serialiseUI(input) {
+    return input.items;
+}
+function serialiseOption(option) {
+    return {
+        name: option.name,
+        values: serialiseValues(option.values),
+        gatePaths: option.gatePaths,
+        config: serialiseOptionWhenConfig(option.config)
+    };
+}
+function serialiseComponent(component) {
+    return {
+        name: component.name,
+        paths: component.paths,
+        dependencies: component.dependencies
+    };
+}
+function serialiseCollection(collection) {
+    return {
+        name: collection.name,
+        builder: serialiseBuilder(collection.builder),
+        min: collection.min,
+        max: collection.max,
+        gatePaths: collection.gatePaths,
+        config: serialiseCollectionWhenConfig(collection.config)
+    };
+}
+function serialiseValues(optionValues) {
+    if (v.is(v.instance(BuilderSelectType), optionValues)) {
+        return {
+            type: 'select',
+            options: optionValues.options,
+            defaultValue: optionValues.defaultValue,
+            optional: optionValues.isOptional,
+            labels: optionValues.optionLabels
+        };
+    }
+    return {
+        type: 'toggle',
+        valueType: optionValues.valueSchema.expects,
+        defaultValue: optionValues.defaultValue,
+        optional: optionValues.isOptional
+    };
+}
+function serialiseOptionWhenConfig(config) {
+    if (config === null) {
+        return null;
+    }
+    switch (config.type) {
+        case 'enable': {
+            return { type: 'enable', values: serialiseValues(config.values) };
+        }
+        case 'match': {
+            return {
+                type: 'match',
+                matchPath: config.matchPath,
+                selectMap: Object.fromEntries(Object.entries(config.selectMap).map(([key, value]) => [
+                    key,
+                    value ? serialiseValues(value) : null
+                ]))
+            };
+        }
+        case 'unless': {
+            return {
+                type: 'unless',
+                unlessPath: config.unlessPath,
+                disabledValues: config.disabledValues,
+                values: serialiseValues(config.values)
+            };
+        }
+    }
+}
+function serialiseCollectionWhenConfig(config) {
+    if (config === null) {
+        return null;
+    }
+    switch (config.type) {
+        case 'enable': {
+            return {
+                type: 'enable',
+                builder: serialiseBuilder(config.builder),
+                min: config.min,
+                max: config.max
+            };
+        }
+        case 'match': {
+            return {
+                type: 'match',
+                matchPath: config.matchPath,
+                selectMap: Object.fromEntries(Object.entries(config.selectMap).map(([key, value]) => [
+                    key,
+                    value
+                        ? { builder: serialiseBuilder(value.builder), min: value.min, max: value.max }
+                        : null
+                ]))
+            };
+        }
+        case 'unless': {
+            return {
+                type: 'unless',
+                unlessPath: config.unlessPath,
+                disabledValues: config.disabledValues,
+                builder: serialiseBuilder(config.builder),
+                min: config.min,
+                max: config.max
+            };
+        }
+    }
+}

package/dist/ui.d.ts

@@ -0,0 +1,18 @@
+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;
+    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>;
+}
+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 {};

package/dist/ui.js

@@ -0,0 +1,35 @@
+import * as v from 'valibot';
+import { invariant } from './invariant.js';
+export class BuilderUI {
+    builder;
+    items;
+    constructor(builder, items = []) {
+        this.builder = builder;
+        this.items = items;
+    }
+    page(label, paths) {
+        return new BuilderUI(this.builder, [...this.items, { type: 'page', label, paths }]);
+    }
+    describe(label, paths) {
+        return new BuilderUI(this.builder, [...this.items, { type: 'describe', label, paths }]);
+    }
+    collection(name, label, factory) {
+        const foundCollection = this.builder.collections.find((entry) => entry.name === name);
+        invariant(foundCollection, `Collection '${String(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 }
+        ]);
+    }
+}
+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]);
+        }
+        return new BuilderUI(accumulated.builder, part(accumulated).items);
+    }, base);
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@builder-builder/builder",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "dev": "vite dev",
+    "predev": "npm run types:db",
+    "dev:v": "NO_UPDATE_NOTIFIER=false VERCEL_ENV=development vercel dev",
+    "build": "vite build",
+    "package": "svelte-kit sync && svelte-package --input src/lib/builder",
+    "preview": "vite preview",
+    "prepare": "svelte-kit sync || echo ''",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "format": "prettier --write .",
+    "lint": "prettier --check . && eslint .",
+    "test:unit": "vitest",
+    "test": "npm run test:unit -- --run",
+    "types:db": "dotenv -e .env.development.local -- supabase gen types typescript --project-id \"$SUPABASE_PROJECT_ID\" --schema public > ./src/lib/db/database.types.ts"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1.2.5",
+    "@eslint/js": "^9.18.0",
+    "@sveltejs/adapter-auto": "^6.0.0",
+    "@sveltejs/adapter-vercel": "^5.7.2",
+    "@sveltejs/kit": "^2.16.0",
+    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/vite-plugin-svelte": "^5.0.0",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/svelte": "^5.2.4",
+    "dotenv-cli": "^8.0.0",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-svelte": "^3.0.0",
+    "globals": "^16.0.0",
+    "jsdom": "^26.0.0",
+    "prettier": "^3.4.2",
+    "prettier-plugin-svelte": "^3.3.3",
+    "supabase": "^2.33.9",
+    "svelte": "^5.0.0",
+    "svelte-check": "^4.0.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.20.0",
+    "vite": "^6.2.6",
+    "vitest": "^3.0.0"
+  },
+  "dependencies": {
+    "@floating-ui/dom": "^1.7.2",
+    "@lucide/svelte": "^0.525.0",
+    "@supabase/supabase-js": "^2.49.8",
+    "@upstash/ratelimit": "^2.0.5",
+    "@upstash/redis": "^1.35.0",
+    "@vercel/kv": "^3.0.0",
+    "comlink": "^4.4.2",
+    "fast-deep-equal": "^3.1.3",
+    "svelte-clerk": "^0.12.3",
+    "valibot": "^1.1.0"
+  }
+}