@jigs.design/compiler 0.0.0-stage → 0.1.1

package/dist/hoist.d.ts

@@ -0,0 +1,20 @@
+//#region src/hoist.d.ts
+/** A document with the page's `{@body}` lines moved to the top. */
+export interface Hoisted {
+  /** How many `{@body}` lines moved. */
+  moved: number;
+  text: string;
+}
+/**
+ * Moves the page's `{@body}` lines to the top of `source`: the top-level
+ * ones and those in tags that share the page's scope, not those in `<each>`,
+ * `<if>` or `<define>`. They go in `statementOrder`, each after the lines it
+ * reads, or as written when there is none. A finished document runs them all
+ * before it renders, so the program does the same; only the order a
+ * streaming page sees them in changes. A line that moved leaves a
+ * blank line behind where Markdown text would otherwise join across it, as
+ * the `{@body}` line kept it apart. Null when nothing would move, or when a
+ * line has text after its closing `}`.
+ */
+export declare function hoistDeclarations(source: string): Hoisted | null;
+//#endregion

package/dist/hoist.js

@@ -0,0 +1,76 @@
+import { lineAt } from "./offsets.js";
+import { statementOrder } from "./check-code.js";
+import { parsePickle } from "./parse.js";
+//#region src/hoist.ts
+const blank = (line) => (line ?? "").trim() === "";
+/** Tags whose `{@body}` lines are their own, not the page's. */
+const OWN_SCOPE = /* @__PURE__ */ new Set([
+	"define",
+	"each",
+	"if"
+]);
+/** The page's `{@body}` lines inside tags that share its scope, such as `<card>`. */
+function nested(nodes) {
+	return nodes.flatMap((node) => {
+		if (node.type === "statement") return [node];
+		return node.type === "element" && !OWN_SCOPE.has(node.name) ? nested(node.children) : [];
+	});
+}
+/**
+* Moves the page's `{@body}` lines to the top of `source`: the top-level
+* ones and those in tags that share the page's scope, not those in `<each>`,
+* `<if>` or `<define>`. They go in `statementOrder`, each after the lines it
+* reads, or as written when there is none. A finished document runs them all
+* before it renders, so the program does the same; only the order a
+* streaming page sees them in changes. A line that moved leaves a
+* blank line behind where Markdown text would otherwise join across it, as
+* the `{@body}` line kept it apart. Null when nothing would move, or when a
+* line has text after its closing `}`.
+*/
+function hoistDeclarations(source) {
+	const lines = source.split("\n");
+	/** Each statement's first and last line, 0-based. */
+	const spans = [];
+	const document = parsePickle(source);
+	const statements = [...document.statements, ...nested(document.children)].toSorted((a, b) => a.start - b.start);
+	for (const statement of statements) {
+		const last = lineAt(source, statement.end - 1) - 1;
+		const lineEnd = source.indexOf("\n", statement.end);
+		const after = source.slice(statement.end, lineEnd === -1 ? source.length : lineEnd);
+		if (!blank(after)) return null;
+		spans.push({
+			first: lineAt(source, statement.start) - 1,
+			last
+		});
+	}
+	let top = 0;
+	const kept = [];
+	for (const span of spans) {
+		while (top < span.first && blank(lines[top])) top++;
+		if (top !== span.first) break;
+		kept.push(span);
+		top = span.last + 1;
+	}
+	const moving = spans.slice(kept.length);
+	if (moving.length === 0) return null;
+	const head = (kept.at(-1)?.last ?? -1) + 1;
+	const order = statementOrder(statements) ?? statements.map((_, index) => index);
+	const moved = new Set(moving.flatMap((span) => Array.from({ length: span.last - span.first + 1 }, (_, offset) => span.first + offset)));
+	const rest = [];
+	for (let index = head; index < lines.length; index++) {
+		const line = lines[index];
+		if (!moved.has(index)) {
+			if (!(moved.has(index - 1) && blank(line) && blank(rest.at(-1)))) rest.push(line ?? "");
+		} else if (!moved.has(index + 1) && !blank(rest.at(-1)) && !blank(lines[index + 1])) rest.push("");
+	}
+	const hoisted = order.flatMap((index) => {
+		const span = spans[index];
+		return span === void 0 ? [] : lines.slice(span.first, span.last + 1);
+	});
+	return {
+		moved: order.filter((index, place) => index >= kept.length || index !== place).length,
+		text: [...hoisted, ...rest].join("\n")
+	};
+}
+//#endregion
+export { hoistDeclarations };

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { columnAt, lineAt } from "./offsets.js";
+import { PickleNode, Statement } from "./ast.js";
+import { CompileCatalog, ComponentSpec, PropSpec } from "./spec.js";
+import { ProgramOutput } from "./codegen.js";
+import { CompileOptions, CompileResult, CompiledDefine, Diagnostic, Library, Program, Recipe, RenderNode, compileLibrary, compilePickle } from "./compile.js";
+import { DataRead, ELEMENT, ProcedureUse } from "./check-code.js";
+import { Hoisted, hoistDeclarations } from "./hoist.js";
+import { parsePickle } from "./parse.js";
+import { nearest } from "./suggest.js";
+import { recipeSignature } 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 DataRead, type Diagnostic, ELEMENT, type Edit, type EditFailure, type EditFailureReason, type Hoisted, type Library, type PickleNode, type ProcedureUse, type Program, type ProgramOutput, type PropSpec, type Recipe, type RenderNode, SEARCH_MARKER, type Statement, applyEdits, columnAt, compileLibrary, compilePickle, editBreakage, hoistDeclarations, isEditReply, lineAt, nearest, parseEdits, parsePickle, recipeSignature };

package/dist/index.js

@@ -0,0 +1,9 @@
+import { columnAt, lineAt } from "./offsets.js";
+import { nearest } from "./suggest.js";
+import { ELEMENT } from "./check-code.js";
+import { parsePickle } from "./parse.js";
+import { hoistDeclarations } from "./hoist.js";
+import { compileLibrary, compilePickle } from "./compile.js";
+import { recipeSignature } from "./signature.js";
+import { SEARCH_MARKER, applyEdits, editBreakage, isEditReply, parseEdits } from "./patch.js";
+export { ELEMENT, SEARCH_MARKER, applyEdits, columnAt, compileLibrary, compilePickle, editBreakage, hoistDeclarations, isEditReply, lineAt, nearest, parseEdits, parsePickle, recipeSignature };

package/dist/offsets.d.ts

@@ -0,0 +1,18 @@
+//#region src/offsets.d.ts
+/**
+ * Where text the parser cut out sits in the source. Each entry is
+ * `[index, offset]`: from `index` in the text on, characters sit in the
+ * source from `offset`, until the next entry. The parser trims and joins
+ * lines, so text that spans lines has an entry per line.
+ */
+export type OffsetMap = ReadonlyArray<readonly [index: number, offset: number]>;
+/** A source range: the offset of its first character, and just past its last. */
+export interface Range {
+  end: number;
+  start: number;
+}
+/** The 1-based column of `offset` in `source`. */
+export declare function columnAt(source: string, offset: number): number;
+/** The 1-based line of `offset` in `source`. */
+export declare function lineAt(source: string, offset: number): number;
+//#endregion

package/dist/offsets.js

@@ -0,0 +1,40 @@
+//#region src/offsets.ts
+/** Adds an entry to `map`, unless the text already continues there. */
+function extendMap(map, index, offset) {
+	if (map.length === 0 || sourceOffset(map, index) !== offset) map.push([index, offset]);
+}
+/** The source offset of `index` in the text `map` describes. */
+function sourceOffset(map, index) {
+	let found = map[0] ?? [0, 0];
+	for (const entry of map) {
+		if (entry[0] > index) break;
+		found = entry;
+	}
+	return found[1] + index - found[0];
+}
+/** The source range of `[from, to)` in the text `map` describes. */
+function sourceRange(map, from, to) {
+	const start = sourceOffset(map, from);
+	return {
+		end: to > from ? sourceOffset(map, to - 1) + 1 : start,
+		start
+	};
+}
+/** The map of the text from `from` on, so its index 0 is `from` here. */
+function sliceMap(map, from) {
+	const sliced = [[0, sourceOffset(map, from)]];
+	for (const [index, offset] of map) if (index > from) extendMap(sliced, index - from, offset);
+	return sliced;
+}
+/** The 1-based column of `offset` in `source`. */
+function columnAt(source, offset) {
+	return offset === 0 ? 1 : offset - source.lastIndexOf("\n", offset - 1);
+}
+/** The 1-based line of `offset` in `source`. */
+function lineAt(source, offset) {
+	let line = 1;
+	for (let newline = source.indexOf("\n"); newline !== -1 && newline < offset; newline = source.indexOf("\n", newline + 1)) line++;
+	return line;
+}
+//#endregion
+export { columnAt, extendMap, lineAt, sliceMap, sourceOffset, sourceRange };

package/dist/parse.d.ts

@@ -0,0 +1,16 @@
+import { PickleDocument } from "./ast.js";
+//#region src/parse.d.ts
+/**
+ * Parses Pickle: Markdown blocks, catalog tags and `{@body ...}` statements.
+ *
+ * Never throws. Partial input (a response that is still being written) is
+ * repaired: open elements are closed and a trailing incomplete tag, expression
+ * or statement is dropped. Each fix is recorded in `repairs`.
+ *
+ * An unclosed tag, `{` or statement stops at the next tag line or `{@body`
+ * line rather than swallowing the rest of the document; a tag also stops at a
+ * blank line, unless one of its attributes has a `{` still open. Since that text can't be
+ * finished by more streaming, it is reported in `errors`.
+ */
+export declare function parsePickle(source: string): PickleDocument;
+//#endregion