@builder-builder/builder 0.0.7 → 0.0.9

package/dist/serialise/schemas.js

@@ -1,150 +0,0 @@
-import * as v from 'valibot';
-import { BuilderParameterSchema } from '../core/parameter.js';
-import { BuilderOptionValuesMapSchema, BuilderOptionValuesSchema } from '../core/option/option.js';
-import { BuilderPathSchema, BuilderPathsSchema, BuilderPrimitivesSchema } 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())
-}), v.readonly());
-export const BuilderToggleTypeSerialisedSchema = v.pipe(v.object({
-    type: v.literal('toggle'),
-    valueType: v.picklist(['string', 'boolean', 'number']),
-    defaultValue: v.nullable(v.union([v.boolean(), v.string(), v.number()])),
-    optional: v.boolean()
-}), 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.union([BuilderValuesSerialisedSchema, BuilderParameterSerialisedSchema])
-}), v.readonly());
-export const BuilderOptionMatchConfigSerialisedSchema = v.pipe(v.object({
-    type: v.literal('match'),
-    matchPath: BuilderPathSchema,
-    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: BuilderPrimitivesSchema,
-    values: v.union([BuilderValuesSerialisedSchema, BuilderParameterSerialisedSchema])
-}), v.readonly());
-export const BuilderOptionWhenConfigSerialisedSchema = v.pipe(v.variant('type', [
-    BuilderOptionEnableConfigSerialisedSchema,
-    BuilderOptionMatchConfigSerialisedSchema,
-    BuilderOptionUnlessConfigSerialisedSchema
-]), v.readonly());
-export const BuilderOptionSerialisedSchema = v.pipe(v.object({
-    name: v.string(),
-    values: v.union([BuilderValuesSerialisedSchema, BuilderParameterSerialisedSchema]),
-    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: BuilderDependenciesSerialisedSchema
-}), 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: BuilderPrimitivesSchema,
-    builder: lazyBuilder(),
-    min: v.number(),
-    max: v.number()
-});
-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
-    ]))
-});
-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 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', '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: 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());
-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());
-export const BuilderUISerialisedSchema = v.pipe(v.object({
-    items: BuilderUIItemsSerialisedSchema,
-    expectations: BuilderExpectationsSerialisedSchema
-}), v.readonly());

package/dist/serialise/serialise.d.ts

@@ -1,13 +0,0 @@
-import type { BuilderGeneric } from '../core/index';
-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

@@ -1,147 +0,0 @@
-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) {
-    return {
-        options: builder.options.map(serialiseOption),
-        components: builder.components.map(serialiseComponent),
-        collections: builder.collections.map(serialiseCollection),
-        expectations: builder.expectations.map(serialiseExpectation)
-    };
-}
-function serialiseUI(input) {
-    return {
-        items: input.items,
-        expectations: input.expectations.map(serialiseExpectation)
-    };
-}
-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 serialiseExpectation(expectation) {
-    return {
-        name: expectation.name,
-        kind: expectation.kind
-    };
-}
-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 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 serialiseSelect(optionValues);
-    }
-    return {
-        type: 'toggle',
-        valueType: optionValues.valueType,
-        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': {
-            if (v.is(BuilderParameterSchema, config.selectMap)) {
-                return {
-                    type: 'match',
-                    matchPath: config.matchPath,
-                    selectMap: { type: 'parameter' }
-                };
-            }
-            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/serialise/validate.d.ts

@@ -1,26 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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,19 +0,0 @@
-import type { BuilderModelPaths } from './paths';
-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 BuilderUIs = ReadonlyArray<BuilderUI<BuilderGeneric | null>>;
-export declare class BuilderUI<Builder extends BuilderGeneric | null = BuilderGeneric> {
-    readonly builder: Builder;
-    readonly 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, itemUI: BuilderUI<BuilderGeneric | null>): 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,44 +0,0 @@
-import { Builder } from './core/builder.js';
-import { check } from './check.js';
-import { validateBuilder } from './core/validate.js';
-export class BuilderUI {
-    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 }], this.expectations);
-    }
-    describe(label, paths) {
-        return new BuilderUI(this.builder, [...this.items, { type: 'describe', label, paths }], 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) {
-    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));
-    validateBuilder(new Builder(merged.builder.options, merged.builder.components, merged.builder.collections, merged.expectations), { strict: true });
-    return merged;
-}