@builder-builder/builder 0.0.14 → 0.0.16

package/dist/validate/pricing.js

@@ -0,0 +1,127 @@
+import * as v from 'valibot';
+import { check } from '../check.js';
+import { BuilderPricingExpressionSchema, BuilderPricingSerialisedSchema, BuilderRatesSchema, pricing, serialise } from '../entities/index.js';
+import { validate } from './brand.js';
+import { BuilderValidateErrors } from './errors.js';
+import { resolver } from './resolve.js';
+const EMPTY_PRICING = validate(serialise.pricing(pricing()));
+const NumberSchema = v.number();
+export function validatePricing(input, references = [], errors = new BuilderValidateErrors()) {
+    if (!check.is(BuilderPricingSerialisedSchema, input)) {
+        errors.invalidInput('pricing');
+        return [EMPTY_PRICING, errors.errors];
+    }
+    const resolve = resolver(errors, references);
+    const structure = validatePricingStructure(input, resolve, errors);
+    return [validate(structure), errors.errors];
+}
+export function validatePricingStructure(input, resolve, errors) {
+    const rates = input.rates.flatMap((entry) => {
+        const resolved = resolve(entry);
+        return v.is(BuilderRatesSchema, resolved) ? [resolved] : [];
+    });
+    const formula = input.formula == null ? null : resolveExpression(input.formula);
+    if (formula != null) {
+        walkExpression(formula, false);
+    }
+    return { rates, formula };
+    function resolveExpression(input) {
+        const resolved = resolve(input);
+        if (!check.is(BuilderPricingExpressionSchema, resolved)) {
+            return null;
+        }
+        if (check.is(NumberSchema, resolved)) {
+            return resolved;
+        }
+        if (resolved.kind === 'variantPrice' || resolved.kind === 'lookup') {
+            return resolved;
+        }
+        if (resolved.kind === 'variants') {
+            const inner = errors.scope('expression', () => resolveExpression(resolved.expression));
+            return { ...resolved, expression: inner ?? resolved.expression };
+        }
+        const left = errors.scope('left', () => resolveExpression(resolved.left));
+        const right = errors.scope('right', () => resolveExpression(resolved.right));
+        return { ...resolved, left: left ?? resolved.left, right: right ?? resolved.right };
+    }
+    function walkExpression(expression, insideVariants) {
+        if (check.is(NumberSchema, expression)) {
+            return;
+        }
+        switch (expression.kind) {
+            case 'variantPrice':
+                if (!insideVariants) {
+                    errors.invalidPricing('scope');
+                }
+                return;
+            case 'lookup':
+                errors.scope('lookup', () => {
+                    const exists = rates.some((entry) => entry[expression.rate] != null);
+                    if (!exists) {
+                        errors.missingRate(expression.rate);
+                    }
+                    if (!insideVariants) {
+                        errors.invalidPricing('scope');
+                    }
+                });
+                return;
+            case 'variants':
+                errors.scope('variants', () => {
+                    if (insideVariants) {
+                        errors.invalidPricing('nested-variants');
+                    }
+                    const inner = expression.expression;
+                    check.assert(BuilderPricingExpressionSchema, inner);
+                    errors.scope('expression', () => walkExpression(inner, true));
+                });
+                return;
+            case 'add':
+            case 'sub':
+            case 'mul':
+            case 'div': {
+                const { left, right } = expression;
+                check.assert(BuilderPricingExpressionSchema, left);
+                check.assert(BuilderPricingExpressionSchema, right);
+                errors.scope('left', () => walkExpression(left, insideVariants));
+                errors.scope('right', () => walkExpression(right, insideVariants));
+                return;
+            }
+        }
+    }
+}
+export function checkPricingExpectations(model, pricing, errors) {
+    if (pricing.formula == null) {
+        return;
+    }
+    const optionNames = new Set(model.options.map((option) => option.name));
+    walkExpression(pricing.formula);
+    function walkExpression(expression) {
+        if (!check.is(BuilderPricingExpressionSchema, expression)) {
+            return;
+        }
+        if (check.is(NumberSchema, expression)) {
+            return;
+        }
+        switch (expression.kind) {
+            case 'lookup':
+                errors.scope('lookup', () => {
+                    if (expression.key.kind === 'option' && !optionNames.has(expression.key.name)) {
+                        errors.unmetExpectation('option', expression.key.name);
+                    }
+                });
+                return;
+            case 'variants':
+                errors.scope('variants', () => errors.scope('expression', () => walkExpression(expression.expression)));
+                return;
+            case 'add':
+            case 'sub':
+            case 'mul':
+            case 'div':
+                errors.scope('left', () => walkExpression(expression.left));
+                errors.scope('right', () => walkExpression(expression.right));
+                return;
+            default:
+                return;
+        }
+    }
+}

package/dist/validate/ui.js

@@ -1,8 +1,9 @@
 import { check } from '../check.js';
-import { BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, serialise, uis } from '../entities/index.js';
+import { BuilderModelSerialisedSchema, BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, serialise, uis } from '../entities/index.js';
 import { validate } from './brand.js';
 import { BuilderValidateErrors } from './errors.js';
 import { checkExpectations } from './expectations.js';
+import { checkPath, collectionConfigs } from './paths.js';
 import { resolver } from './resolve.js';
 export function validateUI(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderUISerialisedSchema, input)) {
@@ -82,9 +83,11 @@ export function validateUIStructure(ui, resolve, errors) {
     }
 }
 export function checkUIExpectations(mergedModel, ui, errors) {
+    const expectedOptionNames = collectExpectedOptionNames(ui);
     errors.scope('expectations', () => {
         checkExpectations(mergedModel, ui.expectations, errors);
     });
+    errors.scope('items', () => walkItems(mergedModel, ui.items));
     errors.scope('uis', () => {
         ui.uis.forEach((nested, nestedIndex) => {
             errors.scope(nestedIndex, () => {
@@ -92,4 +95,60 @@ export function checkUIExpectations(mergedModel, ui, errors) {
             });
         });
     });
+    function walkItems(model, items) {
+        items.forEach((entry, itemIndex) => {
+            const item = entry;
+            errors.scope(itemIndex, () => {
+                if (item.type === 'pages') {
+                    walkPages(model, item);
+                    return;
+                }
+                const inputs = item.inputs;
+                if (!Array.isArray(inputs)) {
+                    return;
+                }
+                errors.scope('inputs', () => inputs.forEach((input, entryIndex) => {
+                    errors.scope(entryIndex, () => walkInput(model, input));
+                }));
+            });
+        });
+    }
+    function walkPages(outerModel, pages) {
+        const collection = outerModel.collections.find((entry) => entry.name === pages.name);
+        if (collection == null) {
+            return;
+        }
+        const innerModels = collectionConfigs(collection).flatMap(({ model: configModel }) => check.is(BuilderModelSerialisedSchema, configModel) ? [configModel] : []);
+        if (innerModels.length === 0) {
+            return;
+        }
+        const [firstInnerModel] = innerModels;
+        errors.scope('items', () => walkItems(firstInnerModel, pages.items));
+    }
+    function walkInput(model, input) {
+        const path = input.path;
+        if (!Array.isArray(path)) {
+            return;
+        }
+        const leaf = path.at(-1);
+        if (typeof leaf === 'string' && expectedOptionNames.has(leaf)) {
+            return;
+        }
+        errors.scope('path', () => {
+            checkPath(model, path, errors);
+        });
+    }
+}
+function collectExpectedOptionNames(ui) {
+    const names = new Set();
+    collectFromUI(ui);
+    return names;
+    function collectFromUI(node) {
+        node.expectations.forEach((expectation) => {
+            if (expectation.kind === 'option') {
+                names.add(expectation.name);
+            }
+        });
+        node.uis.forEach((nested) => collectFromUI(nested));
+    }
 }

package/dist/validate/variants.js

@@ -11,6 +11,10 @@ export function validateVariants(model, input, options = {}, errors = new Builde
     }
     const variants = input;
     const expected = createVariants(model);
+    if (Object.keys(expected).length === 0) {
+        errors.noComponents();
+        return [validate({}), errors.errors];
+    }
     errors.scope('variants', () => {
         checkVariants();
         checkComponents();

package/package.json

@@ -1,23 +1,16 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    },
-    "./codegen": {
-      "types": "./dist/codegen/index.d.ts",
-      "default": "./dist/codegen/index.js"
     }
   },
   "files": [
     "dist"
   ],
-  "bin": {
-    "bb": "./dist/cli.js"
-  },
   "svelte": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "publishConfig": {
@@ -76,8 +69,6 @@
   "dependencies": {
     "@floating-ui/dom": "^1.7.2",
     "@lucide/svelte": "^0.525.0",
-    "@phenomnomnominal/tsquery": "^6.2.0",
-    "@phenomnomnominal/tstemplate": "^0.1.0",
     "@supabase/supabase-js": "^2.104.0",
     "@upstash/ratelimit": "^2.0.5",
     "@upstash/redis": "^1.35.0",

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli.js

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-import { writeFileSync } from 'node:fs';
-import { parseArgs } from 'node:util';
-import { generateOrderType } from './codegen/index.js';
-const DEFAULT_API_URL = 'https://builder-builder.com';
-run().catch((caught) => {
-    const message = caught instanceof Error ? caught.message : String(caught);
-    process.stderr.write(`bb: ${message}\n`);
-    process.exit(1);
-});
-async function run() {
-    const { values } = parseArgs({
-        options: {
-            id: { type: 'string' },
-            out: { type: 'string' },
-            api: { type: 'string', default: DEFAULT_API_URL },
-            key: { type: 'string' }
-        },
-        strict: true
-    });
-    const id = values.id;
-    const out = values.out;
-    if (id == null || out == null) {
-        process.stderr.write('Usage: bb --id <entity-id> --out <file> [--api <url>] [--key <api-key>]\n');
-        process.exit(1);
-        return;
-    }
-    const apiUrl = values.api ?? DEFAULT_API_URL;
-    const apiKey = values.key ?? process.env.BB_API_KEY;
-    if (apiKey == null || apiKey.length === 0) {
-        throw new Error('missing API key — pass --key or set BB_API_KEY');
-    }
-    const entity = await fetchEntity({ apiUrl, id, apiKey });
-    const generated = generateOrderType({ name: entity.name, builder: entity.builder });
-    const fetchedAt = new Date().toISOString();
-    const header = `// AUTO-GENERATED — DO NOT EDIT\n` +
-        `// Source: ${id} (${entity.name}) — fetched ${fetchedAt}\n` +
-        `// Regenerate: bb --id ${id} --out ${out}\n\n`;
-    writeFileSync(out, header + generated);
-    process.stdout.write(`bb: wrote ${out}\n`);
-}
-async function fetchEntity(options) {
-    const url = `${options.apiUrl.replace(/\/$/, '')}/api/builder/${options.id}`;
-    const response = await fetch(url, {
-        headers: { 'X-Builder-Builder-Key': options.apiKey }
-    });
-    if (!response.ok) {
-        const body = await response.text();
-        throw new Error(`fetch ${url} failed: ${response.status} ${response.statusText} — ${body}`);
-    }
-    const payload = (await response.json());
-    return payload;
-}

package/dist/codegen/index.d.ts

@@ -1,7 +0,0 @@
-import type { BuilderRefEntities, BuilderSerialised } from '../entities/index.js';
-export type GenerateOrderTypeInput = {
-    readonly name: string;
-    readonly builder: BuilderSerialised;
-    readonly references?: BuilderRefEntities;
-};
-export declare function generateOrderType(input: GenerateOrderTypeInput): string;

package/dist/codegen/index.js

@@ -1,212 +0,0 @@
-import ts from 'typescript';
-import * as v from 'valibot';
-import { check } from '../check.js';
-import { BuilderException } from '../exception.js';
-import { optionGraph, variantsFor } from '../mappers/index.js';
-import { validateBuilder } from '../validate/index.js';
-import { tsmember, tstype } from './template.js';
-export function generateOrderType(input) {
-    const [validated, errors] = validateBuilder(input.builder, input.references ?? []);
-    if (errors.length > 0) {
-        throw new BuilderException(errors);
-    }
-    const typeName = `${pascalCase(input.name)}Order`;
-    const typeNode = renderModelOrder(validated.model);
-    const declaration = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], typeName, undefined, typeNode);
-    const sourceFile = ts.createSourceFile('generated.ts', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-    return `${printer.printNode(ts.EmitHint.Unspecified, declaration, sourceFile)}\n`;
-}
-function renderModelOrder(model) {
-    const graph = optionGraph(model);
-    const componentMembers = model.components.map((component) => {
-        return renderComponentMember(component, model, graph);
-    });
-    const collectionMembers = model.collections.map((collection) => {
-        return renderCollectionMember(collection);
-    });
-    return ts.factory.createTypeLiteralNode([...componentMembers, ...collectionMembers]);
-}
-function renderComponentMember(component, model, graph) {
-    const variant = renderComponentVariant(component, model, graph);
-    return tsmember('readonly <%= name %>: <%= variant %> | null;', {
-        name: propertyName(component.name),
-        variant
-    });
-}
-function renderComponentVariant(component, model, graph) {
-    const instance = renderComponentInstance(component, model, graph);
-    const detailFields = extractDetailFields(component.payload);
-    if (detailFields.length === 0) {
-        return tstype('{ readonly instance: <%= i %> }', { i: instance });
-    }
-    const details = renderDetailFields(detailFields);
-    return tstype('{ readonly instance: <%= i %>; readonly details: <%= d %> }', {
-        i: instance,
-        d: details
-    });
-}
-function renderComponentInstance(component, model, graph) {
-    rejectUnsupportedDependencyPaths(component);
-    const observedValues = perKeyValueSets(variantsFor(component, graph));
-    const members = [];
-    observedValues.forEach((values, key) => {
-        members.push(tsmember('readonly <%= name %>: <%= type %>;', {
-            name: propertyName(key),
-            type: renderOptionValueType(key, values, model)
-        }));
-    });
-    return ts.factory.createTypeLiteralNode(members);
-}
-function rejectUnsupportedDependencyPaths(component) {
-    const paths = component.paths ?? [];
-    paths.forEach((path) => {
-        if (path.length !== 1) {
-            throw new Error(`codegen: multi-segment dependency paths are not yet supported (component '${component.name}', path ${JSON.stringify(path)})`);
-        }
-        const [head] = path;
-        check.assert(v.string(), head, `codegen invariant: component dependency path head must be a string (component '${component.name}', path ${JSON.stringify(path)})! ❌`);
-    });
-}
-function perKeyValueSets(variants) {
-    const result = new Map();
-    variants.forEach((instance) => {
-        Object.entries(instance).forEach(([key, value]) => {
-            const existing = result.get(key) ?? new Set();
-            existing.add(value);
-            result.set(key, existing);
-        });
-    });
-    return result;
-}
-function renderOptionValueType(name, observedValues, model) {
-    const option = model.options.find((candidate) => candidate.name === name);
-    check.truthy(option, `codegen invariant: option '${name}' referenced by a component must be defined in the model! ❌`);
-    return renderOptionValueShape(option.payload, observedValues);
-}
-function renderOptionValueShape(payload, observedValues) {
-    if (payload.type === 'toggle') {
-        return maybeNullable(primitiveTypeNode(payload.valueType), payload.isOptional);
-    }
-    if (payload.type === 'select') {
-        const literals = Array.from(observedValues)
-            .filter((value) => typeof value === 'string')
-            .map((value) => {
-            return ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(value));
-        });
-        return maybeNullable(unionOf(literals), payload.isOptional);
-    }
-    if (payload.type === 'enable' || payload.type === 'unless') {
-        return renderOptionValueShape(payload.payload, observedValues);
-    }
-    const branches = Object.values(payload.selectMap).filter((branch) => branch != null);
-    const [first] = branches;
-    if (first == null) {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword);
-    }
-    return renderOptionValueShape(first, observedValues);
-}
-function extractDetailFields(payload) {
-    if (!('type' in payload)) {
-        return payload.fields;
-    }
-    if (payload.type === 'enable' || payload.type === 'unless') {
-        return extractDetailFields(payload.payload);
-    }
-    const branches = Object.values(payload.selectMap).filter((branch) => branch != null);
-    const [first] = branches;
-    if (first == null) {
-        return [];
-    }
-    return extractDetailFields(first);
-}
-function renderDetailFields(fields) {
-    const members = fields.map((field) => {
-        return tsmember('readonly <%= name %>: <%= type %>;', {
-            name: propertyName(field.name),
-            type: maybeNullable(primitiveTypeNode(field.valueType), field.isOptional)
-        });
-    });
-    return ts.factory.createTypeLiteralNode(members);
-}
-function renderCollectionMember(collection) {
-    const config = extractCollectionConfig(collection.payload);
-    const itemNode = renderModelOrder(config.model);
-    const tupleSize = fixedTupleSize(config.min, config.max);
-    const value = tupleSize == null
-        ? tstype('ReadonlyArray<<%= i %>>', { i: itemNode })
-        : tstype('readonly [%= items %]', {
-            items: Array.from({ length: tupleSize }, () => itemNode)
-        });
-    return tsmember('readonly <%= name %>: <%= value %>;', {
-        name: propertyName(collection.name),
-        value
-    });
-}
-function extractCollectionConfig(payload) {
-    if (!('type' in payload)) {
-        return payload;
-    }
-    if (payload.type === 'enable' || payload.type === 'unless') {
-        return extractCollectionConfig(payload.payload);
-    }
-    const branches = Object.values(payload.selectMap).filter((branch) => branch != null);
-    const [first] = branches;
-    if (first == null) {
-        throw new Error(`codegen: collection 'match' has no non-null branch`);
-    }
-    return extractCollectionConfig(first);
-}
-function fixedTupleSize(min, max) {
-    if (min !== max) {
-        return null;
-    }
-    if (!Number.isInteger(min) || min < 0) {
-        return null;
-    }
-    return min;
-}
-function propertyName(name) {
-    if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) {
-        return ts.factory.createIdentifier(name);
-    }
-    return ts.factory.createStringLiteral(name);
-}
-function primitiveTypeNode(valueType) {
-    if (valueType === 'string') {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
-    }
-    if (valueType === 'number') {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-    }
-    return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
-}
-function unionOf(members) {
-    const [first, ...rest] = members;
-    if (first == null) {
-        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword);
-    }
-    if (rest.length === 0) {
-        return first;
-    }
-    return ts.factory.createUnionTypeNode([first, ...rest]);
-}
-function maybeNullable(node, isNullable) {
-    if (!isNullable) {
-        return node;
-    }
-    return ts.factory.createUnionTypeNode([
-        node,
-        ts.factory.createLiteralTypeNode(ts.factory.createNull())
-    ]);
-}
-function pascalCase(name) {
-    const words = name.split(/[\s\-_]+/).filter((word) => word.length > 0);
-    if (words.length === 0) {
-        throw new Error(`codegen: name '${name}' produces an empty type name`);
-    }
-    return words
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join('')
-        .replace(/[^A-Za-z0-9]/g, '');
-}

package/dist/codegen/template.d.ts

@@ -1,5 +0,0 @@
-import type ts from 'typescript';
-type TemplateData = Readonly<Record<string, string | ts.Node | ReadonlyArray<ts.Node>>>;
-export declare function tstype(template: string, data?: TemplateData): ts.TypeNode;
-export declare function tsmember(template: string, data?: TemplateData): ts.TypeElement;
-export {};

package/dist/codegen/template.js

@@ -1,17 +0,0 @@
-import { tsquery } from '@phenomnomnominal/tsquery';
-import { tstemplate } from '@phenomnomnominal/tstemplate';
-import { check } from '../check.js';
-export function tstype(template, data = {}) {
-    const sourceFile = tstemplate(`type __ = ${template};`, data);
-    const [declaration] = tsquery(sourceFile, 'TypeAliasDeclaration');
-    check.truthy(declaration, `tstype invariant: template produced no TypeAliasDeclaration! ❌`);
-    return declaration.type;
-}
-export function tsmember(template, data = {}) {
-    const sourceFile = tstemplate(`type __ = { ${template} };`, data);
-    const [literal] = tsquery(sourceFile, 'TypeLiteral');
-    check.truthy(literal, `tsmember invariant: template produced no TypeLiteral! ❌`);
-    const [member] = literal.members;
-    check.truthy(member, `tsmember invariant: template produced an empty TypeLiteral! ❌`);
-    return member;
-}

package/dist/entities/builder/factory.d.ts

@@ -1,7 +0,0 @@
-import type { BuilderModel } from '../model/model';
-import type { BuilderModelState } from '../model/state';
-import type { BuilderUI } from '../ui/ui';
-import type { BuilderBindings } from './bind';
-import { Builder } from './builder.js';
-export declare function builder(): Builder<BuilderModelState>;
-export declare function builder<const State extends BuilderModelState>(model: BuilderModel<State>, ui?: BuilderUI, bindings?: BuilderBindings): Builder<State>;

package/dist/entities/builder/factory.js

@@ -1,4 +0,0 @@
-import { Builder } from './builder.js';
-export function builder(model, ui, bindings) {
-    return new Builder(model, ui, bindings);
-}