@jigs.design/compiler 0.3.4 → 0.3.6

package/dist/compile.d.ts

@@ -116,6 +116,12 @@ export interface CompiledDefine {
   procedures: ReadonlyArray<ProcedureUse>;
   props: Array<DefineProp>;
   statements: Array<Statement>;
+  /**
+   * The tags a library jig's body draws: components and the jigs it
+   * calls. Empty for a document's own define: those are on the
+   * document's result.
+   */
+  tags: ReadonlySet<string>;
 }
 /** One component the document actually renders, and how often it is written. */
 interface DefineUse {
@@ -168,7 +174,36 @@ export interface CompileResult {
    * source with the fixes applied. It names every tag the program draws.
    */
   source: string;
+  /**
+   * The tags the program draws, from its tree and its own defines'
+   * bodies, fixes included: each component and each jig it calls, not
+   * the tags those jigs draw (on the library's defines). Nothing in prose
+   * or in string literals counts.
+   */
+  tags: ReadonlySet<string>;
 }
+/** The language's own tags: no component or define may take these names. */
+export declare const RESERVED_TAGS: ReadonlySet<string>;
+/** What `extendLibrary` built, and what it found in each jig. */
+export interface ExtendedLibrary {
+  /**
+   * Each jig's diagnostics, by name, numbered by its own source. A name
+   * here but not in `library` was dropped.
+   */
+  diagnostics: ReadonlyMap<string, ReadonlyArray<Diagnostic$1>>;
+  /** `base`, then each jig that entered, in order. */
+  library: Library;
+}
+/**
+ * `base` extended by `jigs`, in order, leniently: a jig may use `base`
+ * and the jigs before it. Never throws. A jig enters when its source has
+ * exactly one `<define>`, of its name, whose name is not already in the
+ * library, and none of its findings leave code that cannot run (an
+ * `undefined_reference`, an `invalid_statement`, an `unclosed` tag). A
+ * jig with other findings, such as an unknown component or prop, enters
+ * with what still compiles, and its diagnostics say what was removed.
+ */
+export declare function extendLibrary(base: Library, jigs: ReadonlyArray<Jig>, catalog: CompileCatalog): ExtendedLibrary;
 /**
  * Compiles `jigs` against `catalog`, in order: a jig may use the ones
  * before it. Throws when a jig has any diagnostic. Cached per catalog and

package/dist/compile.js

@@ -7,6 +7,7 @@ import { parseJigs } from "./parse.js";
 import { isValidValue } from "./spec.js";
 import { blockHoists } from "./block-hoist.js";
 //#region src/compile.ts
+/** The language's own tags: no component or define may take these names. */
 const RESERVED_TAGS = /* @__PURE__ */ new Set([
 	"define",
 	"each",
@@ -196,7 +197,8 @@ function readDefine(node, findings, libraryNames, components) {
 		origin: "doc",
 		procedures: [],
 		props,
-		statements: []
+		statements: [],
+		tags: /* @__PURE__ */ new Set()
 	};
 }
 function lookupHint(name, candidates) {
@@ -707,6 +709,14 @@ function describeNumber(spec) {
 	if (spec.kind === "number" && spec.min !== void 0 && spec.max !== void 0) return `a number from ${spec.min} to ${spec.max}`;
 	return `a ${spec.kind} value`;
 }
+/** Each component `nodes` draw and each jig they call, by name, added to `into`. */
+function collectTags(nodes, into) {
+	for (const node of nodes) {
+		if (node.type === "element") into.add(node.component);
+		else if (node.type === "call") into.add(node.name);
+		if (node.type === "call" || node.type === "each" || node.type === "element" || node.type === "if") collectTags(node.children, into);
+	}
+}
 function visitRender(nodes, visit) {
 	for (const node of nodes) if (node.type === "call") {
 		visit(node);
@@ -848,6 +858,9 @@ function compileDocument(source, library, components) {
 	findings.push(...generated.findings);
 	for (const finding of findings) if (finding.start !== void 0) finding.line = lineAt(source, finding.start);
 	findings.sort((a, b) => a.line - b.line);
+	const drawn = /* @__PURE__ */ new Set();
+	collectTags(tree, drawn);
+	for (const def of docDefines) collectTags(def.body, drawn);
 	return {
 		defines: docDefines,
 		fields: uses.fields,
@@ -861,7 +874,8 @@ function compileDocument(source, library, components) {
 			tree
 		},
 		reads: uses.reads,
-		source
+		source,
+		tags: drawn
 	};
 }
 function buildLibrary(list, components) {
@@ -877,11 +891,67 @@ function buildLibrary(list, components) {
 		built.set(def.name, {
 			...def,
 			origin: "library",
-			procedures: result.procedures
+			procedures: result.procedures,
+			tags: result.tags
 		});
 	}
 	return built;
 }
+/** Findings that leave a define whose code cannot run: it is dropped. */
+const UNRUNNABLE = /* @__PURE__ */ new Set([
+	"invalid_statement",
+	"unclosed",
+	"undefined_reference"
+]);
+/**
+* `base` extended by `jigs`, in order, leniently: a jig may use `base`
+* and the jigs before it. Never throws. A jig enters when its source has
+* exactly one `<define>`, of its name, whose name is not already in the
+* library, and none of its findings leave code that cannot run (an
+* `undefined_reference`, an `invalid_statement`, an `unclosed` tag). A
+* jig with other findings, such as an unknown component or prop, enters
+* with what still compiles, and its diagnostics say what was removed.
+*/
+function extendLibrary(base, jigs, catalog) {
+	const built = new Map(base);
+	const diagnostics = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const refuse = (jig, found, message) => {
+		diagnostics.set(jig.name, [...found, {
+			code: "invalid_define",
+			message,
+			severity: "error",
+			span: { line: 1 }
+		}]);
+	};
+	for (const jig of jigs) {
+		if (seen.has(jig.name)) continue;
+		seen.add(jig.name);
+		if (built.has(jig.name)) {
+			refuse(jig, [], `<${jig.name}> is already in the library; this one was dropped`);
+			continue;
+		}
+		const result = compileDocument(jig.source, built, catalog);
+		const found = result.findings.map((finding) => toDiagnostic(jig.source, finding));
+		const def = result.defines[0];
+		if (result.defines.length !== 1 || def?.name !== jig.name) {
+			refuse(jig, found, `The source must be one <define name="${jig.name}">; it was dropped`);
+			continue;
+		}
+		diagnostics.set(jig.name, found);
+		if (result.findings.some((finding) => finding.severity === "error" && UNRUNNABLE.has(finding.code))) continue;
+		built.set(def.name, {
+			...def,
+			origin: "library",
+			procedures: result.procedures,
+			tags: result.tags
+		});
+	}
+	return {
+		diagnostics,
+		library: built
+	};
+}
 /**
 * Compiles `jigs` against `catalog`, in order: a jig may use the ones
 * before it. Throws when a jig has any diagnostic. Cached per catalog and
@@ -969,4 +1039,4 @@ function compileJigs(source, options) {
 	} : finding));
 }
 //#endregion
-export { compileJigs, compileLibrary };
+export { RESERVED_TAGS, compileJigs, compileLibrary, extendLibrary };

package/dist/index.d.ts

@@ -2,11 +2,11 @@ import { columnAt, lineAt, rangeIn, spanIn } from "./offsets.js";
 import { JigsNode, Statement } from "./ast.js";
 import { CompileCatalog, ComponentSpec, PropSpec } from "./spec.js";
 import { ProgramOutput } from "./codegen.js";
-import { CompileOptions, CompileResult, CompiledDefine, Diagnostic, Jig, Library, Program, RenderNode, compileJigs, compileLibrary } from "./compile.js";
+import { CompileOptions, CompileResult, CompiledDefine, Diagnostic, ExtendedLibrary, Jig, Library, Program, RESERVED_TAGS, RenderNode, compileJigs, compileLibrary, extendLibrary } from "./compile.js";
 import { DataFields, DataRead, ELEMENT, ProcedureUse } from "./check-code.js";
 import { Hoisted, hoistDeclarations } from "./hoist.js";
 import { parseJigs } from "./parse.js";
 import { nearest } from "./suggest.js";
 import { jigSignature } from "./signature.js";
 import { Edit, EditFailure, EditFailureReason, SEARCH_MARKER, applyEdits, editBreakage, isEditReply, parseEdits } from "./patch.js";
-export { type CompileCatalog, type CompileOptions, type CompileResult, type CompiledDefine, type ComponentSpec, type DataFields, type DataRead, type Diagnostic, ELEMENT, type Edit, type EditFailure, type EditFailureReason, type Hoisted, type Jig, type JigsNode, type Library, type ProcedureUse, type Program, type ProgramOutput, type PropSpec, type RenderNode, SEARCH_MARKER, type Statement, applyEdits, columnAt, compileJigs, compileLibrary, editBreakage, hoistDeclarations, isEditReply, jigSignature, lineAt, nearest, parseEdits, parseJigs, rangeIn, spanIn };
+export { type CompileCatalog, type CompileOptions, type CompileResult, type CompiledDefine, type ComponentSpec, type DataFields, type DataRead, type Diagnostic, ELEMENT, type Edit, type EditFailure, type EditFailureReason, type ExtendedLibrary, type Hoisted, type Jig, type JigsNode, type Library, type ProcedureUse, type Program, type ProgramOutput, type PropSpec, RESERVED_TAGS, type RenderNode, SEARCH_MARKER, type Statement, applyEdits, columnAt, compileJigs, compileLibrary, editBreakage, extendLibrary, hoistDeclarations, isEditReply, jigSignature, lineAt, nearest, parseEdits, parseJigs, rangeIn, spanIn };

package/dist/index.js

@@ -3,7 +3,7 @@ import { nearest } from "./suggest.js";
 import { ELEMENT } from "./check-code.js";
 import { parseJigs } from "./parse.js";
 import { hoistDeclarations } from "./hoist.js";
-import { compileJigs, compileLibrary } from "./compile.js";
+import { RESERVED_TAGS, compileJigs, compileLibrary, extendLibrary } from "./compile.js";
 import { jigSignature } from "./signature.js";
 import { SEARCH_MARKER, applyEdits, editBreakage, isEditReply, parseEdits } from "./patch.js";
-export { ELEMENT, SEARCH_MARKER, applyEdits, columnAt, compileJigs, compileLibrary, editBreakage, hoistDeclarations, isEditReply, jigSignature, lineAt, nearest, parseEdits, parseJigs, rangeIn, spanIn };
+export { ELEMENT, RESERVED_TAGS, SEARCH_MARKER, applyEdits, columnAt, compileJigs, compileLibrary, editBreakage, extendLibrary, hoistDeclarations, isEditReply, jigSignature, lineAt, nearest, parseEdits, parseJigs, rangeIn, spanIn };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jigs.design/compiler",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "The Jigs compiler: parser, checker against a catalog, code generator, jig libraries, and the edit helpers. It evolves in place, behind the server API.",
   "license": "MIT",
   "repository": {
@@ -26,6 +26,6 @@
   },
   "dependencies": {
     "acorn": "8.19.0",
-    "@jigs.design/protocol": "0.3.4"
+    "@jigs.design/protocol": "0.3.6"
   }
 }