@builder-builder/builder 0.0.5 → 0.0.7

package/dist/serialise/schemas.js

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { BuilderParameterSchema } from '../core/parameter.js';
 import { BuilderOptionValuesMapSchema, BuilderOptionValuesSchema } from '../core/option/option.js';
-import { BuilderPathSchema, BuilderPathsSchema, BuilderPrimitiveSchema } from '../schemas/primitives.js';
+import { BuilderPathSchema, BuilderPathsSchema, BuilderPrimitivesSchema } from '../schemas/primitives.js';
 export { BuilderOptionValuesMapSchema, BuilderOptionValuesSchema, BuilderParameterSchema };
 export const BuilderSelectTypeSerialisedSchema = v.pipe(v.object({
     type: v.literal('select'),
@@ -12,7 +12,7 @@ export const BuilderSelectTypeSerialisedSchema = v.pipe(v.object({
 }), v.readonly());
 export const BuilderToggleTypeSerialisedSchema = v.pipe(v.object({
     type: v.literal('toggle'),
-    valueType: v.string(),
+    valueType: v.picklist(['string', 'boolean', 'number']),
     defaultValue: v.nullable(v.union([v.boolean(), v.string(), v.number()])),
     optional: v.boolean()
 }), v.readonly());
@@ -33,7 +33,7 @@ export const BuilderOptionMatchConfigSerialisedSchema = v.pipe(v.object({
 export const BuilderOptionUnlessConfigSerialisedSchema = v.pipe(v.object({
     type: v.literal('unless'),
     unlessPath: BuilderPathSchema,
-    disabledValues: v.pipe(v.array(BuilderPrimitiveSchema), v.readonly()),
+    disabledValues: BuilderPrimitivesSchema,
     values: v.union([BuilderValuesSerialisedSchema, BuilderParameterSerialisedSchema])
 }), v.readonly());
 export const BuilderOptionWhenConfigSerialisedSchema = v.pipe(v.variant('type', [
@@ -47,10 +47,11 @@ export const BuilderOptionSerialisedSchema = v.pipe(v.object({
     gatePaths: BuilderPathsSchema,
     config: v.nullable(BuilderOptionWhenConfigSerialisedSchema)
 }), v.readonly());
+const BuilderDependenciesSerialisedSchema = v.pipe(v.array(v.string()), v.readonly());
 export const BuilderComponentSerialisedSchema = v.pipe(v.object({
     name: v.string(),
     paths: BuilderPathsSchema,
-    dependencies: v.pipe(v.array(v.string()), v.readonly())
+    dependencies: BuilderDependenciesSerialisedSchema
 }), v.readonly());
 const lazyBuilder = () => v.lazy(() => BuilderSerialisedSchema);
 const BuilderSerialisedCollectionConfigObject = v.object({
@@ -72,7 +73,7 @@ const BuilderSerialisedCollectionMatchConfigObject = v.object({
 const BuilderSerialisedCollectionUnlessConfigObject = v.object({
     type: v.literal('unless'),
     unlessPath: BuilderPathSchema,
-    disabledValues: v.pipe(v.array(BuilderPrimitiveSchema), v.readonly()),
+    disabledValues: BuilderPrimitivesSchema,
     builder: lazyBuilder(),
     min: v.number(),
     max: v.number()
@@ -118,13 +119,17 @@ export const BuilderCollectionWhenConfigSerialisedSchema = v.pipe(v.variant('typ
 export const BuilderCollectionSerialisedSchema = v.pipe(BuilderSerialisedCollectionObject, v.readonly());
 export const BuilderExpectationSerialisedSchema = v.pipe(v.object({
     name: v.string(),
-    kind: v.picklist(['option', 'component'])
+    kind: v.picklist(['option', 'component', 'collection'])
 }), v.readonly());
+const BuilderOptionsSerialisedSchema = v.pipe(v.array(BuilderOptionSerialisedSchema), v.readonly());
+const BuilderComponentsSerialisedSchema = v.pipe(v.array(BuilderComponentSerialisedSchema), v.readonly());
+const BuilderCollectionsSerialisedSchema = v.pipe(v.array(BuilderSerialisedCollectionObject), v.readonly());
+const BuilderExpectationsSerialisedSchema = v.pipe(v.array(BuilderExpectationSerialisedSchema), 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())
+    options: BuilderOptionsSerialisedSchema,
+    components: BuilderComponentsSerialisedSchema,
+    collections: BuilderCollectionsSerialisedSchema,
+    expectations: BuilderExpectationsSerialisedSchema
 }), v.readonly());
 export const BuilderUIPageSerialisedSchema = v.pipe(BuilderSerialisedUIPageObject, v.readonly());
 export const BuilderUIDescribeSerialisedSchema = v.pipe(BuilderSerialisedUIDescribeObject, v.readonly());
@@ -139,3 +144,7 @@ export const BuilderUIItemsSerialisedSchema = v.pipe(v.array(v.variant('type', [
     BuilderSerialisedUIDescribeObject,
     BuilderSerialisedUICollectionObject
 ])), v.readonly());
+export const BuilderUISerialisedSchema = v.pipe(v.object({
+    items: BuilderUIItemsSerialisedSchema,
+    expectations: BuilderExpectationsSerialisedSchema
+}), v.readonly());

package/dist/serialise/serialise.d.ts

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

package/dist/serialise/serialise.js

@@ -2,6 +2,7 @@ import * as v from 'valibot';
 import { BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderParameterSchema, BuilderSelectType } from '../core/index.js';
 export const serialise = {
     builder: serialiseBuilder,
+    select: serialiseSelect,
     ui: serialiseUI
 };
 function serialiseBuilder(builder) {
@@ -13,7 +14,10 @@ function serialiseBuilder(builder) {
     };
 }
 function serialiseUI(input) {
-    return input.items;
+    return {
+        items: input.items,
+        expectations: input.expectations.map(serialiseExpectation)
+    };
 }
 function serialiseOption(option) {
     return {
@@ -46,22 +50,25 @@ function serialiseCollection(collection) {
         config: serialiseCollectionWhenConfig(collection.config)
     };
 }
+function serialiseSelect(selectType) {
+    return {
+        type: 'select',
+        options: selectType.options,
+        defaultValue: selectType.defaultValue,
+        optional: selectType.isOptional,
+        labels: selectType.optionLabels
+    };
+}
 function serialiseValues(optionValues) {
     if (v.is(BuilderParameterSchema, optionValues)) {
         return { type: 'parameter' };
     }
     if (v.is(v.instance(BuilderSelectType), optionValues)) {
-        return {
-            type: 'select',
-            options: optionValues.options,
-            defaultValue: optionValues.defaultValue,
-            optional: optionValues.isOptional,
-            labels: optionValues.optionLabels
-        };
+        return serialiseSelect(optionValues);
     }
     return {
         type: 'toggle',
-        valueType: optionValues.valueSchema.expects,
+        valueType: optionValues.valueType,
         defaultValue: optionValues.defaultValue,
         optional: optionValues.isOptional
     };

package/dist/serialise/validate.d.ts

@@ -0,0 +1,26 @@
+import type { BuilderSerialised } from './schemas';
+declare const validated: unique symbol;
+export type BuilderSerialisedValidated = BuilderSerialised & {
+    readonly [validated]: true;
+};
+export type BuilderSerialisedErrorKind = 'duplicate-option' | 'duplicate-component' | 'duplicate-collection' | 'invalid-gate-path' | 'invalid-component-path' | 'invalid-component-dependency' | 'invalid-config-path';
+export type BuilderSerialisedError = {
+    readonly kind: BuilderSerialisedErrorKind;
+    readonly name: string;
+    readonly detail: string;
+};
+export type BuilderSerialisedErrors = ReadonlyArray<BuilderSerialisedError>;
+export type BuilderSerialisedValidateResult = readonly [
+    BuilderSerialisedValidated,
+    BuilderSerialisedErrors
+];
+export type BuilderSerialisedValidateOptions = {
+    readonly strict: true;
+};
+export declare class BuilderSerialisedValidateError extends Error {
+    readonly errors: BuilderSerialisedErrors;
+    constructor(errors: BuilderSerialisedErrors);
+}
+export declare const validate: typeof validateSerialised;
+declare function validateSerialised(data: unknown, options?: BuilderSerialisedValidateOptions): BuilderSerialisedValidateResult;
+export {};

package/dist/serialise/validate.js

@@ -0,0 +1,148 @@
+import * as v from 'valibot';
+import { BuilderSerialisedSchema } from './schemas.js';
+export class BuilderSerialisedValidateError extends Error {
+    errors;
+    constructor(errors) {
+        super('serialised validation failed');
+        this.errors = errors;
+    }
+}
+export const validate = validateSerialised;
+function validateSerialised(data, options) {
+    const serialised = v.parse(BuilderSerialisedSchema, data);
+    let errors = [];
+    const optionNames = new Set();
+    const componentNames = new Set();
+    const collectionNames = new Set();
+    const optionExpectationNames = new Set(serialised.expectations
+        .filter((expectation) => expectation.kind === 'option')
+        .map((expectation) => expectation.name));
+    const componentExpectationNames = new Set(serialised.expectations
+        .filter((expectation) => expectation.kind === 'component')
+        .map((expectation) => expectation.name));
+    const validOptionPaths = () => {
+        const names = new Set(optionNames);
+        optionExpectationNames.forEach((name) => names.add(name));
+        return names;
+    };
+    const validComponentNames = () => {
+        const names = new Set(componentNames);
+        componentExpectationNames.forEach((name) => names.add(name));
+        return names;
+    };
+    serialised.options.forEach((option) => {
+        if (optionNames.has(option.name)) {
+            errors = [
+                ...errors,
+                {
+                    kind: 'duplicate-option',
+                    name: option.name,
+                    detail: `Duplicate option '${option.name}'`
+                }
+            ];
+        }
+        optionNames.add(option.name);
+        const validPaths = validOptionPaths();
+        option.gatePaths.forEach((gatePath) => {
+            const [pathName] = gatePath;
+            if (typeof pathName === 'string' && !validPaths.has(pathName)) {
+                errors = [
+                    ...errors,
+                    {
+                        kind: 'invalid-gate-path',
+                        name: option.name,
+                        detail: `Option '${option.name}' has gate path '${String(pathName)}' which does not reference a known option or expectation`
+                    }
+                ];
+            }
+        });
+        if (option.config !== null) {
+            if (option.config.type === 'match' && 'matchPath' in option.config) {
+                const [matchPathName] = option.config.matchPath;
+                if (typeof matchPathName === 'string' && !validPaths.has(matchPathName)) {
+                    errors = [
+                        ...errors,
+                        {
+                            kind: 'invalid-config-path',
+                            name: option.name,
+                            detail: `Option '${option.name}' has match path '${String(matchPathName)}' which does not reference a known option or expectation`
+                        }
+                    ];
+                }
+            }
+            if (option.config.type === 'unless' && 'unlessPath' in option.config) {
+                const [unlessPathName] = option.config.unlessPath;
+                if (typeof unlessPathName === 'string' && !validPaths.has(unlessPathName)) {
+                    errors = [
+                        ...errors,
+                        {
+                            kind: 'invalid-config-path',
+                            name: option.name,
+                            detail: `Option '${option.name}' has unless path '${String(unlessPathName)}' which does not reference a known option or expectation`
+                        }
+                    ];
+                }
+            }
+        }
+    });
+    const validPaths = validOptionPaths();
+    serialised.components.forEach((component) => {
+        if (componentNames.has(component.name)) {
+            errors = [
+                ...errors,
+                {
+                    kind: 'duplicate-component',
+                    name: component.name,
+                    detail: `Duplicate component '${component.name}'`
+                }
+            ];
+        }
+        componentNames.add(component.name);
+        component.paths.forEach((path) => {
+            const [pathName] = path;
+            if (typeof pathName === 'string' && !validPaths.has(pathName)) {
+                errors = [
+                    ...errors,
+                    {
+                        kind: 'invalid-component-path',
+                        name: component.name,
+                        detail: `Component '${component.name}' references path '${String(pathName)}' which does not reference a known option or expectation`
+                    }
+                ];
+            }
+        });
+        component.dependencies.forEach((dependency) => {
+            if (!validComponentNames().has(dependency)) {
+                errors = [
+                    ...errors,
+                    {
+                        kind: 'invalid-component-dependency',
+                        name: component.name,
+                        detail: `Component '${component.name}' depends on '${dependency}' which does not reference a known component or expectation`
+                    }
+                ];
+            }
+        });
+    });
+    serialised.collections.forEach((collection) => {
+        if (collectionNames.has(collection.name)) {
+            errors = [
+                ...errors,
+                {
+                    kind: 'duplicate-collection',
+                    name: collection.name,
+                    detail: `Duplicate collection '${collection.name}'`
+                }
+            ];
+        }
+        collectionNames.add(collection.name);
+    });
+    serialised.collections.forEach((collection) => {
+        const [, nestedErrors] = validateSerialised(collection.builder);
+        errors = [...errors, ...nestedErrors];
+    });
+    if (options?.strict && errors.length > 0) {
+        throw new BuilderSerialisedValidateError(errors);
+    }
+    return [serialised, errors];
+}

package/dist/ui.d.ts

@@ -1,11 +1,11 @@
 import type { BuilderModelPaths } from './paths';
-import type { BuilderCollectionNamesOf, BuilderCollectionOf, BuilderGeneric } from './core/index';
+import type { BuilderCollectionNamesOf, BuilderGeneric } from './core/index';
 import type { BuilderExpectationEntries, BuilderExpectations, BuilderModelAsserted } from './core/expectation';
+import type { BuilderValidated } from './core/validate';
 import type { BuilderUIItems } from './schemas/index';
 export type BuilderUIGeneric = BuilderUI<BuilderGeneric>;
-export type BuilderUIFactory<Builder extends BuilderGeneric = BuilderGeneric> = (ui: BuilderUI<Builder>) => BuilderUIGeneric;
-export type BuilderUIs = ReadonlyArray<BuilderUIGeneric>;
-export declare class BuilderUI<Builder extends BuilderGeneric = BuilderGeneric> {
+export type BuilderUIs = ReadonlyArray<BuilderUI<BuilderGeneric | null>>;
+export declare class BuilderUI<Builder extends BuilderGeneric | null = BuilderGeneric> {
     readonly builder: Builder;
     readonly items: BuilderUIItems;
     readonly expectations: BuilderExpectationEntries;
@@ -13,6 +13,7 @@ export declare class BuilderUI<Builder extends BuilderGeneric = BuilderGeneric>
     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>;
+    collection<const Name extends BuilderCollectionNamesOf<Builder>>(name: Name, label: string, itemUI: BuilderUI<BuilderGeneric | null>): BuilderUI<Builder>;
 }
-export declare function ui<const Builder extends BuilderGeneric>(builder: Builder, ...uis: BuilderUIs): BuilderUI<Builder>;
+export declare function ui(): BuilderUI<null>;
+export declare function ui<const Builder extends BuilderValidated>(builder: Builder, ...uis: BuilderUIs): BuilderUI<Builder>;

package/dist/ui.js

@@ -1,6 +1,6 @@
-import * as v from 'valibot';
-import { BuilderExpectation } from './core/expectation.js';
+import { Builder } from './core/builder.js';
 import { check } from './check.js';
+import { validateBuilder } from './core/validate.js';
 export class BuilderUI {
     builder;
     items;
@@ -21,22 +21,24 @@ export class BuilderUI {
     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 }], this.expectations);
+    collection(name, label, itemUI) {
+        if (this.builder) {
+            const foundCollection = this.builder.collections.find((entry) => entry.name === name);
+            check.truthy(foundCollection, `Collection '${name}' not found! ❌`);
+        }
+        return new BuilderUI(this.builder, [...this.items, { type: 'collection', name, label, items: itemUI.items }], this.expectations);
     }
 }
 export function ui(builder, ...uis) {
-    const merged = uis.reduce((accumulated, ui) => {
-        return new BuilderUI(accumulated.builder, [...accumulated.items, ...ui.items], [...accumulated.expectations, ...ui.expectations]);
+    if (!builder) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- null builder for partial UIs, typed as BuilderUI<null>
+        return new BuilderUI(null);
+    }
+    const merged = uis.reduce((accumulated, currentUI) => {
+        return new BuilderUI(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accumulated.builder is always the real builder from the first argument
+        accumulated.builder, [...accumulated.items, ...currentUI.items], [...accumulated.expectations, ...currentUI.expectations]);
     }, new BuilderUI(builder));
-    merged.expectations.forEach((expectation) => {
-        if (v.is(v.instance(BuilderExpectation), expectation) && expectation.kind === 'option') {
-            expectation.validate(merged.builder.options);
-        }
-    });
+    validateBuilder(new Builder(merged.builder.options, merged.builder.components, merged.builder.collections, merged.expectations), { strict: true });
     return merged;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "type": "module",
   "exports": {
     ".": {
@@ -39,6 +39,7 @@
     "@sveltejs/vite-plugin-svelte": "^5.0.0",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/svelte": "^5.2.4",
+    "@vitest/coverage-v8": "^3.1.4",
     "dotenv-cli": "^8.0.0",
     "eslint": "^9.18.0",
     "eslint-config-prettier": "^10.0.1",
@@ -64,7 +65,7 @@
     "@vercel/kv": "^3.0.0",
     "comlink": "^4.4.2",
     "fast-deep-equal": "^3.1.3",
-    "svelte-clerk": "^0.12.3",
+    "svelte-clerk": "^1.1.1",
     "valibot": "^1.1.0"
   }
 }