@loadmap/dsl 0.0.0-stage → 0.1.1

package/dist/compile-C2Kdi-Ul.d.ts

@@ -0,0 +1,212 @@
+import { CheckResult, Model } from "@loadmap/core";
+import { Direction, View } from "@loadmap/layout";
+/** A range of the source, as offsets: `from` inclusive, `to` exclusive. */
+interface Span {
+  from: number;
+  to: number;
+}
+interface Diagnostic extends Span {
+  severity: 'error' | 'warning';
+  message: string;
+  /** 1-based, like an editor shows them. */
+  line: number;
+  column: number;
+  /** A short suggestion shown under the mark: "did you mean "orders"?". */
+  hint?: string;
+}
+/** Collects diagnostics and turns offsets into lines and columns. */
+declare class Reporter {
+  readonly source: string;
+  readonly list: Diagnostic[];
+  private seen;
+  private starts;
+  constructor(source: string);
+  error(at: Span, message: string, hint?: string): void;
+  warning(at: Span, message: string, hint?: string): void;
+  /** The 1-based line and column of an offset. */
+  position(offset: number): {
+    line: number;
+    column: number;
+  };
+  get failed(): boolean;
+  private add;
+}
+/**
+ * One diagnostic as a terminal shows it:
+ *
+ *     checkout.loadmap:24:17 error: unknown flow "order"
+ *       24 |   demand: flows.order + flows.events
+ *          |                 ^^^^^ did you mean "orders"?
+ */
+declare function formatDiagnostic(d: Diagnostic, source: string, file?: string): string;
+/** The closest of `options` to `name`, when it is close enough to be a typo. */
+declare function closest(name: string, options: Iterable<string>): string | undefined;
+declare function didYouMean(name: string, options: Iterable<string>): string | undefined;
+interface Ident extends Span {
+  name: string;
+}
+type Expr = Span & ({
+  t: 'num';
+  value: number;
+} | {
+  t: 'str';
+  value: string;
+} | {
+  t: 'bool';
+  value: boolean;
+} | {
+  t: 'tpl';
+  quasis: string[];
+  parts: Expr[];
+} | {
+  t: 'id';
+  name: string;
+} | {
+  t: 'member';
+  object: Ident;
+  prop: Ident;
+} | {
+  t: 'call';
+  callee: Ident;
+  args: Expr[];
+} | {
+  t: 'unary';
+  op: '-' | '+' | '!';
+  arg: Expr;
+} | {
+  t: 'bin';
+  op: BinOp;
+  left: Expr;
+  right: Expr;
+} | {
+  t: 'cond';
+  test: Expr;
+  then: Expr;
+  else: Expr;
+} | {
+  t: 'array';
+  items: Expr[];
+} |
+/** `value ± within`, `value ± within%`: only as the first value of measured(…) or estimated(…). */
+{
+  t: 'pm';
+  value: Expr;
+  within: Expr;
+  percent: boolean;
+} | {
+  t: 'error';
+});
+type BinOp = '||' | '&&' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '+' | '-' | '*' | '/' | '%';
+/** `key: value`. A value is a formula, or a chain of names (`a -> b -> c`) for a route. */
+interface Property extends Span {
+  kind: 'prop';
+  key: Ident;
+  value: Expr;
+  chain?: Ident[];
+}
+/** `keyword args… [= init] [{ body }]`: every statement that declares something. */
+interface Decl extends Span {
+  kind: 'decl';
+  keyword: Ident;
+  /** Names, labels, numbers: what follows the keyword on its line. */
+  args: Expr[];
+  init?: Expr;
+  body?: Stmt[];
+  /** The braces, for finding the block a cursor sits in. */
+  bodySpan?: Span;
+}
+/** `a -> b -> c [: label] [{ body }]`: edges, and in a fan-out its branches (`flow -> stage: share`). */
+interface Edge extends Span {
+  kind: 'edge';
+  chain: Ident[];
+  value?: Expr;
+  body?: Stmt[];
+  bodySpan?: Span;
+}
+/** A line of numbers: a data point of a fit. */
+interface Row extends Span {
+  kind: 'row';
+  values: Expr[];
+}
+type Stmt = Property | Decl | Edge | Row;
+interface Document {
+  body: Stmt[];
+}
+type Type = 'number' | 'boolean' | 'string' | 'capacity' | 'any';
+/** A host's own functions: the escape hatch for what formulas cannot say. Each is called with plain values. */
+type HostFunctions = Readonly<Record<string, (...args: any[]) => unknown>>;
+/** A formula failed while the model ran: where, and why. */
+declare class FormulaError extends Error {
+  readonly span: Span;
+  constructor(span: Span, message: string);
+}
+interface Builtin {
+  args: Type[];
+  /** The rest of the arguments have the last type. */
+  variadic?: boolean;
+  min?: number;
+  result: Type;
+  fn: (...a: any[]) => unknown;
+}
+declare const BUILTINS: Readonly<Record<string, Builtin>>;
+/** The version of the language this package reads: the number on a definition's first line. */
+declare const LANGUAGE_VERSION = 1;
+/** Counts that size the drawing; larger ones would hang the layout, so a shared link cannot ask for them. */
+declare const LIMITS: {
+  readonly members: 64;
+  readonly pods: 256;
+  readonly perPod: 256;
+  readonly partitions: 1024;
+};
+interface CompileOptions {
+  /** Functions formulas may call beyond the built-in ones: the escape hatch for what formulas cannot say. */
+  functions?: HostFunctions;
+}
+/** What the definition sets beyond the model and the view: props of `<Loadmap>`. */
+interface DefinitionOptions {
+  speed?: number;
+  direction?: Direction;
+  assumptions: string[];
+}
+interface Definition {
+  model: Model;
+  view: View;
+  options: DefinitionOptions;
+}
+/** A name the definition declares, where: for autocomplete, and for finding a node's source. */
+interface DslSymbol {
+  kind: 'param' | 'let' | 'fit' | 'flow' | 'node' | 'stage' | 'component' | 'scenario';
+  id: string;
+  /** The id where it is written (or the keyword, for an id taken from its box). */
+  span: Span;
+  /** The whole statement. */
+  decl: Span;
+  /** For a stage, its box; for a node, its kind. */
+  detail?: string;
+}
+/** An `expect` line: where it is and whether it holds. */
+interface ExpectationResult {
+  /** The keyword and the label. */
+  at: Span;
+  line: number;
+  column: number;
+  result: CheckResult;
+}
+interface CompileResult {
+  ok: boolean;
+  diagnostics: Diagnostic[];
+  /** Only when there are no errors. */
+  definition?: Definition;
+  /** Each `expect` line, tested on the pessimistic edge; empty when the definition has errors. */
+  expectations: ExpectationResult[];
+  symbols: DslSymbol[];
+  doc: Document;
+}
+/** Reads a definition: parses, checks, and builds the model and view `<Loadmap>` takes. Never throws. */
+declare function compile(source: string, o?: CompileOptions): CompileResult;
+/**
+ * The diagnostics and every failing expectation, in source order: an editor marks a failure as a warning (the
+ * diagram still shows), `loadmap check` as an error.
+ */
+declare function problems(r: CompileResult, failed?: Diagnostic['severity']): Diagnostic[];
+export { Reporter as C, formatDiagnostic as D, didYouMean as E, Diagnostic as S, closest as T, Expr as _, DslSymbol as a, Row as b, LIMITS as c, BUILTINS as d, FormulaError as f, Edge as g, Document as h, DefinitionOptions as i, compile as l, Decl as m, CompileResult as n, ExpectationResult as o, HostFunctions as p, Definition as r, LANGUAGE_VERSION as s, CompileOptions as t, problems as u, Ident as v, Span as w, Stmt as x, Property as y };

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import { D as formatDiagnostic, S as Diagnostic, a as DslSymbol, f as FormulaError, i as DefinitionOptions, l as compile, n as CompileResult, o as ExpectationResult, p as HostFunctions, r as Definition, s as LANGUAGE_VERSION, t as CompileOptions, u as problems, w as Span } from "./compile-C2Kdi-Ul.js";
+import { ParamValue } from "@loadmap/core";
+interface Completion {
+  label: string;
+  type: 'keyword' | 'property' | 'variable' | 'function' | 'constant' | 'type';
+  /** A few words next to the label. */
+  detail?: string;
+  /** The longer help shown beside the list. */
+  info?: string;
+  /** What to insert, when it differs from the label: "rate: ". */
+  apply?: string;
+}
+interface Completions {
+  /** The word being completed: replace source[from, to). */
+  from: number;
+  to: number;
+  options: Completion[];
+}
+/**
+ * What may be typed at `offset`: the properties and statements of the block the cursor is in, the ids a route or an
+ * edge can name, the names a formula can read. Editor-agnostic; pass the last compile result to save a compile.
+ */
+export declare function completions(source: string, offset: number, compiled?: CompileResult): Completions;
+/** A link is refused when its source would unpack to more than this: a small link must not fill the memory. */
+export declare const MAX_SHARED_BYTES = 1000000;
+export declare function encodeShare(source: string, values?: Readonly<Record<string, ParamValue>>): Promise<string>;
+/**
+ * `values` are the texts the link holds: only the model knows whether "20" is a number or the option "20", so the
+ * page reads them by each parameter's kind.
+ */
+type Shared = {
+  source: string;
+  values: Record<string, string>;
+} | {
+  error: string;
+};
+/** Reads a link's hash (with or without its "#"). Never throws: a broken link gives `{ error }`. */
+export declare function decodeShare(hash: string): Promise<Shared>;
+export { type CompileOptions, type CompileResult, type Completion, type Completions, type Definition, type DefinitionOptions, type Diagnostic, type DslSymbol, type ExpectationResult, FormulaError, type HostFunctions, LANGUAGE_VERSION, type Shared, type Span, compile, formatDiagnostic, problems };

package/dist/index.js

@@ -0,0 +1,262 @@
+import { C as formatDiagnostic, _ as SCHEMA, d as BUILTINS, f as FormulaError, g as EDGE_PROPS, i as problems, m as COLORS, r as compile, t as LANGUAGE_VERSION, y as own } from "./compile-6wNrbYqA.js";
+// src/complete.ts
+/**
+* What may be typed at `offset`: the properties and statements of the block the cursor is in, the ids a route or an
+* edge can name, the names a formula can read. Editor-agnostic; pass the last compile result to save a compile.
+*/
+function completions(source, offset, compiled) {
+	const r = compiled ?? compile(source);
+	let from = offset;
+	while (from > 0 && /\w/.test(source[from - 1])) from--;
+	const out = (options) => ({
+		from,
+		to: offset,
+		options
+	});
+	const ids = (kind) => [...new Set(r.symbols.filter((s) => s.kind === kind).map((s) => s.id))];
+	if (source[from - 1] === ".") {
+		let t = from - 1;
+		while (t > 0 && /\w/.test(source[t - 1])) t--;
+		const table = source.slice(t, from - 1);
+		return out((table === "flows" ? ids("flow") : table === "demand" || table === "util" ? ids("component") : table === "derived" ? ids("let") : []).map((label) => ({
+			label,
+			type: "variable",
+			detail: table
+		})));
+	}
+	const { spec, edgeBody } = blockAt(r.doc.body, offset);
+	const lineStart = source.lastIndexOf("\n", from - 1) + 1;
+	const before = source.slice(lineStart, from).replace(/^.*[{;]/, "").trimStart();
+	const stages = () => [...ids("stage").map((label) => ({
+		label,
+		type: "variable",
+		detail: "stage"
+	})), ...singleStageBoxes(r.symbols).map((label) => ({
+		label,
+		type: "variable",
+		detail: "box"
+	}))];
+	const nodes = () => ids("node").map((label) => ({
+		label,
+		type: "variable",
+		detail: "node"
+	}));
+	if (before === "") {
+		if (edgeBody) return out(props(EDGE_PROPS));
+		const list = [...props(spec.props), ...statements(spec)];
+		if (spec.open?.names === "values" || spec.open?.names === "params") list.push(...[...spec.open.names === "values" ? ["load"] : [], ...ids("param")].map((label) => ({
+			label,
+			type: "variable",
+			apply: `${label}: `
+		})));
+		if (spec.open?.names === "flows") list.push(...ids("flow").map((label) => ({
+			label,
+			type: "variable",
+			apply: `${label}: `
+		})));
+		if (spec.edges === "edges") list.push(...nodes());
+		if (spec.edges === "branches") list.push(...ids("flow").map((label) => ({
+			label,
+			type: "variable"
+		})));
+		return out(list);
+	}
+	const chain = /^(\w+)(\s*->\s*\w+)*\s*->\s*$/.test(before);
+	const prop = /^(\w+)\s*:\s*(.*)$/.exec(before);
+	if (chain && !prop) return out(spec.edges === "branches" ? stages() : nodes());
+	if (prop) {
+		const p = edgeBody ? own(EDGE_PROPS, prop[1]) : own(spec.props, prop[1]);
+		const kind = p?.value;
+		if (kind === "route") return out(stages());
+		if (kind === "node") return out(nodes());
+		if (kind === "component") return out(ids("component").map((label) => ({
+			label,
+			type: "variable"
+		})));
+		if (kind === "scenario") return out(ids("scenario").map((label) => ({
+			label,
+			type: "constant",
+			apply: /^[A-Za-z_]\w*$/.test(label) ? label : JSON.stringify(label)
+		})));
+		if (kind === "enum") return out((prop[1] === "color" ? COLORS : p?.values ?? []).map((label) => ({
+			label,
+			type: "constant"
+		})));
+		if (kind === "boolean" && p?.scope === "const") return out([{
+			label: "true",
+			type: "constant"
+		}, {
+			label: "false",
+			type: "constant"
+		}]);
+		if (p?.scope === "const") return out([]);
+		return out(formulaNames(r, p?.scope ?? "ctx"));
+	}
+	if (/^\w+(\s*->\s*\w+)+\s*:/.test(before) || /^let\s+\w+\s*=/.test(before)) return out(formulaNames(r, "ctx"));
+	return out([]);
+}
+function props(p) {
+	return Object.entries(p).map(([label, s]) => ({
+		label,
+		type: "property",
+		apply: `${label}: `,
+		detail: s.required ? "required" : void 0,
+		info: s.doc
+	}));
+}
+function statements(spec) {
+	return spec.children.filter((k) => k !== "loadmap").map((k) => ({
+		label: k,
+		type: "keyword",
+		info: `${SCHEMA[k].doc}\n\n${SCHEMA[k].example}`
+	}));
+}
+function formulaNames(r, scope) {
+	if (scope === "i" || scope === "value") return [{
+		label: scope,
+		type: "variable"
+	}];
+	const list = [{
+		label: "load",
+		type: "variable",
+		detail: "× today"
+	}, ...r.symbols.filter((s) => s.kind === "param").map((s) => s.id).map((label) => ({
+		label,
+		type: "variable",
+		detail: "parameter"
+	}))];
+	if (scope === "values") return list;
+	list.push(...r.symbols.filter((s) => s.kind === "let").map((s) => ({
+		label: s.id,
+		type: "variable",
+		detail: "let"
+	})), ...[
+		"flows",
+		"demand",
+		"util",
+		"derived"
+	].map((label) => ({
+		label,
+		type: "type",
+		apply: `${label}.`
+	})), ...r.symbols.filter((s) => s.kind === "fit").map((s) => ({
+		label: s.id,
+		type: "function",
+		detail: "fit"
+	})), ...Object.keys(BUILTINS).map((label) => ({
+		label,
+		type: "function"
+	})), {
+		label: "true",
+		type: "constant"
+	}, {
+		label: "false",
+		type: "constant"
+	});
+	return list;
+}
+function singleStageBoxes(symbols) {
+	const count = /* @__PURE__ */ new Map();
+	for (const s of symbols) if (s.kind === "stage" && s.detail) count.set(s.detail, (count.get(s.detail) ?? 0) + 1);
+	const stages = new Set(symbols.filter((s) => s.kind === "stage").map((s) => s.id));
+	return [...count].filter(([box, n]) => n === 1 && !stages.has(box)).map(([box]) => box);
+}
+/** The innermost block whose braces hold `offset`. */
+function blockAt(body, offset) {
+	let spec = SCHEMA[""];
+	let list = body;
+	for (;;) {
+		const inside = list.find((s) => (s.kind === "decl" || s.kind === "edge") && !!s.bodySpan && s.bodySpan.from < offset && offset < s.bodySpan.to);
+		if (!inside?.body) return {
+			spec,
+			edgeBody: false
+		};
+		if (inside.kind === "edge") return {
+			spec,
+			edgeBody: true
+		};
+		const next = own(SCHEMA, inside.keyword.name);
+		if (!next) return {
+			spec,
+			edgeBody: false
+		};
+		spec = next;
+		list = inside.body;
+	}
+}
+// src/share.ts
+/**
+* A definition in a link: `#v1.` + base64url(deflate-raw(source)), then the values that differ from the defaults
+* (`&load=30&pods=6`). The hash never reaches a server, and the source carries its own language version, so old links
+* keep opening. Compression is the platform's CompressionStream: no dependency.
+*/
+const PREFIX = "v1.";
+/** A link is refused when its source would unpack to more than this: a small link must not fill the memory. */
+const MAX_SHARED_BYTES = 1e6;
+async function encodeShare(source, values = {}) {
+	const packed = await pipe(new TextEncoder().encode(source), new CompressionStream("deflate-raw"));
+	const rest = new URLSearchParams(Object.entries(values).map(([k, v]) => [k, String(v)])).toString();
+	return `${PREFIX}${base64url(packed)}${rest ? `&${rest}` : ""}`;
+}
+/** Reads a link's hash (with or without its "#"). Never throws: a broken link gives `{ error }`. */
+async function decodeShare(hash) {
+	const h = hash.replace(/^#/, "");
+	const amp = h.indexOf("&");
+	const head = amp < 0 ? h : h.slice(0, amp);
+	if (!head.startsWith(PREFIX)) return { error: "this link holds no loadmap definition" };
+	let bytes;
+	try {
+		bytes = unbase64url(head.slice(3));
+	} catch {
+		return { error: "this link is cut or garbled" };
+	}
+	let source;
+	try {
+		const raw = await pipe(bytes, new DecompressionStream("deflate-raw"), MAX_SHARED_BYTES);
+		source = new TextDecoder("utf-8", { fatal: true }).decode(raw);
+	} catch (err) {
+		return { error: err instanceof TooLarge ? err.message : "this link is cut or garbled" };
+	}
+	const values = Object.fromEntries(new URLSearchParams(amp < 0 ? "" : h.slice(amp + 1)));
+	return {
+		source,
+		values
+	};
+}
+var TooLarge = class extends Error {};
+async function pipe(input, through, max = Infinity) {
+	const writer = through.writable.getWriter();
+	writer.write(input).catch(() => {});
+	writer.close().catch(() => {});
+	const reader = through.readable.getReader();
+	const chunks = [];
+	let size = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		size += value.byteLength;
+		if (size > max) {
+			await reader.cancel();
+			throw new TooLarge(`this link unpacks to more than ${max / 1e6} MB`);
+		}
+		chunks.push(value);
+	}
+	const out = new Uint8Array(size);
+	let at = 0;
+	for (const c of chunks) {
+		out.set(c, at);
+		at += c.byteLength;
+	}
+	return out;
+}
+function base64url(bytes) {
+	let bin = "";
+	for (let i = 0; i < bytes.length; i += 32768) bin += String.fromCharCode(...bytes.subarray(i, i + 32768));
+	return btoa(bin).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function unbase64url(s) {
+	if (!/^[A-Za-z0-9_-]*$/.test(s)) throw new Error("not base64url");
+	const bin = atob(s.replaceAll("-", "+").replaceAll("_", "/"));
+	return Uint8Array.from(bin, (c) => c.charCodeAt(0));
+}
+export { FormulaError, LANGUAGE_VERSION, MAX_SHARED_BYTES, compile, completions, decodeShare, encodeShare, formatDiagnostic, problems };

package/dist/internal.d.ts

@@ -0,0 +1,94 @@
+import { C as Reporter, E as didYouMean, T as closest, _ as Expr, b as Row, c as LIMITS, d as BUILTINS, g as Edge, h as Document, m as Decl, v as Ident, w as Span, x as Stmt, y as Property } from "./compile-C2Kdi-Ul.js";
+/** What a formula may read: everything, only the parameters, a local (`i`, `value`) or nothing (a constant). */
+type Scope = 'ctx' | 'values' | 'i' | 'value' | 'const';
+type ValueKind = 'number' | 'boolean' | 'string' | 'capacity' |
+/** A word from `values`, written bare or quoted: `shape: cylinder`. */
+'enum' |
+/** Names joined by "->": `route: gateway -> topic -> workers`. */
+'route' |
+/** The id of a node, a component, a flow. */
+'node' | 'component' |
+/** A scenario's label, bare or quoted: `scenario: Proposed`. */
+'scenario' |
+/** A list of options: `[2, 3, 4]`. */
+'options' |
+/** A number, a switch or an option: a parameter's default. */
+'value';
+interface PropSpec {
+  value: ValueKind;
+  scope: Scope;
+  doc: string;
+  required?: boolean;
+  values?: readonly string[];
+  /** May appear more than once; each adds to a list. */
+  repeat?: boolean;
+}
+interface ArgSpec {
+  name: 'id' | 'label' | 'sub' | 'version' | 'x' | 'y';
+  kind: 'id' | 'text' | 'number';
+  optional?: boolean;
+  /** A text that may be a template computed from the model. */
+  dynamic?: boolean;
+}
+interface BlockSpec {
+  doc: string;
+  /** An example line, shown by autocomplete. */
+  example: string;
+  args: readonly ArgSpec[];
+  /** `let x = …`. */
+  init?: boolean;
+  props: Readonly<Record<string, PropSpec>>;
+  /** Keywords of the statements it may hold. */
+  children: readonly string[];
+  /** Its properties are named by the model: the load and parameters in a preset, parameters only in a scenario, flows in partitions. */
+  open?: {
+    names: 'values' | 'params' | 'flows';
+    spec: PropSpec;
+  };
+  /** It holds `a -> b` lines: edges at the top, branches in a fan-out. */
+  edges?: 'edges' | 'branches';
+  /** It holds rows of numbers. */
+  rows?: boolean;
+}
+/** A component's properties: on a box, or in a `component` block. */
+export declare const COMPONENT_PROPS: Readonly<Record<string, PropSpec>>;
+export declare const COLORS: readonly ['accent', 'alt', 'ok', 'warn', 'drop', 'muted'];
+export declare const SCHEMA: Readonly<Record<string, BlockSpec>>;
+/** The properties of an edge's block: `a -> b { label: …; when: … }`. */
+export declare const EDGE_PROPS: Readonly<Record<string, PropSpec>>;
+export declare const BOXES: readonly ['node', 'cluster', 'pool'];
+export declare const STAGES: readonly ['pass', 'store', 'sink', 'queue', 'workers', 'fanout'];
+type TokenKind = 'ident' | 'number' | 'string' | 'template' | 'punct' | 'newline' | 'eof';
+interface Token extends Span {
+  kind: TokenKind;
+  /** The source text: an identifier's name, a punctuation mark. */
+  text: string;
+  /** A number's value, a string's cooked text. */
+  value?: number | string;
+  /** A template's cooked text pieces and, between them, the source ranges of its `${…}` parts. */
+  quasis?: string[];
+  parts?: Span[];
+}
+/** The token kinds and marks an editor needs to highlight the language like the parser reads it. */
+export declare const LEXICON: {
+  readonly punct: string[];
+  readonly comment: '#';
+};
+/**
+ * Splits `source[from, to)` into tokens. Newlines end statements, except inside parentheses and brackets, so a long
+ * formula can wrap there. `#` starts a comment to the end of the line.
+ */
+export declare function lex(source: string, report: Reporter, from?: number, to?: number): Token[];
+/** Deeper formulas are refused: a shared link must not be able to exhaust the stack. */
+export declare const MAX_DEPTH = 64;
+/** Longer sources are refused before parsing. */
+export declare const MAX_SOURCE = 200000;
+/** Parses a definition into statements. Never throws: errors go to the reporter, and parsing goes on at the next line. */
+export declare function parse(source: string, report?: Reporter): {
+  doc: Document;
+  report: Reporter;
+};
+/** Parses one formula on its own, e.g. a template's `${…}` part. */
+export declare function parseExpression(source: string, from: number, to: number, report: Reporter, depth?: number): Expr;
+export declare function reference(): string;
+export { BUILTINS, type Decl, type Document, type Edge, type Expr, type Ident, LIMITS, type PropSpec, type Property, Reporter, type Row, type Stmt, type Token, closest, didYouMean };

package/dist/internal.js

@@ -0,0 +1,44 @@
+import { S as didYouMean, _ as SCHEMA, a as MAX_DEPTH, b as Reporter, c as parseExpression, d as BUILTINS, g as EDGE_PROPS, h as COMPONENT_PROPS, l as LEXICON, m as COLORS, n as LIMITS, o as MAX_SOURCE, p as BOXES, s as parse, u as lex, v as STAGES, x as closest } from "./compile-6wNrbYqA.js";
+// src/reference.ts
+const SCOPE = {
+	ctx: "formula",
+	values: "formula of parameters",
+	i: "formula of `i`",
+	value: "formula of `value`",
+	const: "constant"
+};
+/** The statement reference of docs/dsl.md, written from the schema table, so the two cannot drift apart. */
+const OPEN = {
+	values: "parameters (and `load`)",
+	params: "parameters (not `load`)",
+	flows: "flows"
+};
+function reference() {
+	const out = [];
+	const table = (props) => {
+		if (!Object.keys(props).length) return;
+		out.push("| Property | Value | |", "| --- | --- | --- |");
+		for (const [k, p] of Object.entries(props)) {
+			const value = p.values ? p.values.map((v) => `\`${v}\``).join(" \\| ") : `${p.value}, ${SCOPE[p.scope]}`;
+			out.push(`| \`${k}\`${p.required ? " (required)" : ""} | ${value} | ${p.doc.replaceAll("|", "\\|")} |`);
+		}
+		out.push("");
+	};
+	const block = (name, spec) => {
+		out.push(`### ${name || "The top level"}`, "", spec.doc, "");
+		if (spec.example) out.push("```", spec.example, "```", "");
+		if (spec.args.length) out.push(`After the keyword: ${spec.args.map((a) => a.optional ? `[${a.name}]` : a.name).join(" ")}${spec.init ? " = formula" : ""}.`, "");
+		table(spec.props);
+		const holds = spec.children.filter((c) => c !== "loadmap");
+		if (holds.length) out.push(`Holds: ${holds.map((c) => `\`${c}\``).join(", ")}.`, "");
+		if (spec.open) out.push(`Its properties are named by ${OPEN[spec.open.names]}.`, "");
+		if (spec.edges === "edges") out.push("Holds edges: `a -> b`, `a -> b: label`, `a -> b { label: …; when: … }`.", "");
+		if (spec.edges === "branches") out.push("Holds branches: `flow -> stage: copies per unit`.", "");
+	};
+	for (const [name, spec] of Object.entries(SCHEMA)) block(name, spec);
+	out.push("### Edges", "", "A line between two nodes: `a -> b`, a chain `a -> b -> c`, or with a label `a -> b: \"…\"`.", "");
+	table(EDGE_PROPS);
+	out.push("### Functions", "", Object.keys(BUILTINS).map((f) => `\`${f}\``).join(", "), "");
+	return out.join("\n");
+}
+export { BOXES, BUILTINS, COLORS, COMPONENT_PROPS, EDGE_PROPS, LEXICON, LIMITS, MAX_DEPTH, MAX_SOURCE, Reporter, SCHEMA, STAGES, closest, didYouMean, lex, parse, parseExpression, reference };