@builder-builder/builder 0.0.6 → 0.0.8

package/dist/serialise/schemas.js

@@ -1,141 +0,0 @@
-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';
-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.string(),
-    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: v.pipe(v.array(BuilderPrimitiveSchema), v.readonly()),
-    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());
-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()
-});
-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());
-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());
-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/serialise/serialise.d.ts

@@ -1,10 +0,0 @@
-import type { BuilderGeneric } from '../core/index';
-import type { BuilderSerialised, BuilderUISerialised } from './schemas';
-import type { BuilderUIGeneric } from '../ui';
-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

@@ -1,140 +0,0 @@
-import * as v from 'valibot';
-import { BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderParameterSchema, 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),
-        expectations: builder.expectations.map(serialiseExpectation)
-    };
-}
-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 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 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 {
-        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': {
-            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/ui.d.ts

@@ -1,18 +0,0 @@
-import type { BuilderModelPaths } from './paths';
-import type { BuilderCollectionNamesOf, 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 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 BuilderGeneric>(builder: Builder, ...uis: BuilderUIs): BuilderUI<Builder>;

package/dist/ui.js

@@ -1,53 +0,0 @@
-import * as v from 'valibot';
-import { BuilderExpectation } from './core/expectation.js';
-import { check } from './check.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));
-    merged.expectations.forEach((expectation) => {
-        if (v.is(v.instance(BuilderExpectation), expectation)) {
-            if (expectation.kind === 'option') {
-                expectation.validate(merged.builder.options);
-            }
-            else if (expectation.kind === 'collection') {
-                expectation.validate(merged.builder.collections);
-            }
-        }
-    });
-    return merged;
-}