@jigs.design/compiler 0.0.0-stage → 0.1.1

package/dist/patch.d.ts

@@ -0,0 +1,55 @@
+//#region src/patch.d.ts
+export interface Edit {
+  replace: string;
+  search: string;
+}
+export declare const SEARCH_MARKER = "<<<<<<< SEARCH";
+/**
+ * Whether a reply is a set of edits rather than a full document. Null while
+ * too little has arrived to tell (Pickle can also start with `<`).
+ */
+export declare function isEditReply(text: string): boolean | null;
+/** Complete SEARCH/REPLACE blocks in `text`; a block still being written is skipped. */
+export declare function parseEdits(text: string): Array<Edit>;
+/**
+ * Why an edit was rejected. `missing`: its SEARCH is not in the document.
+ * `ambiguous`: its SEARCH is there more than once. `malformed`: the block
+ * itself is broken. `broken`: it applied, but the result needs parser repairs
+ * the document did not (see `editBreakage`); the server reports this one.
+ */
+export type EditFailureReason = "ambiguous" | "broken" | "malformed" | "missing";
+export interface EditFailure {
+  /** For `broken`: the repairs the edited document needs and the base did not. */
+  breakage?: ReadonlyArray<{
+    line: number;
+    message: string;
+  }>;
+  failed: Edit;
+  /** For `ambiguous`: the line each match starts on. */
+  lines?: ReadonlyArray<number>;
+  reason: EditFailureReason;
+}
+export type ApplyResult = (EditFailure & {
+  ok: false;
+}) | {
+  ok: true;
+  text: string;
+};
+/**
+ * Applies edits in order. Each SEARCH must appear in the document exactly
+ * once, exactly or ignoring indentation; an empty SEARCH appends. Stops at
+ * the first edit that doesn't match, matches more than once, or whose
+ * REPLACE still contains edit markers.
+ */
+export declare function applyEdits(base: string, edits: ReadonlyArray<Edit>): ApplyResult;
+/**
+ * The parser repairs an edited document needs that its base did not: an
+ * edit that leaves a tag unclosed or closes one twice. Diagnostics are
+ * matched by code and message, not line, since an edit moves lines; a
+ * repair the base already needed is not new, however many times it moves.
+ */
+export declare function editBreakage<T extends {
+  code: string;
+  message: string;
+}>(base: ReadonlyArray<T>, edited: ReadonlyArray<T>): Array<T>;
+//#endregion

package/dist/patch.js

@@ -0,0 +1,140 @@
+//#region src/patch.ts
+const SEARCH_MARKER = "<<<<<<< SEARCH";
+const DIVIDER = "=======";
+const REPLACE_MARKER = ">>>>>>> REPLACE";
+const FENCE = /^`{3}[\w-]*$/;
+/**
+* Whether a reply is a set of edits rather than a full document. Null while
+* too little has arrived to tell (Pickle can also start with `<`).
+*/
+function isEditReply(text) {
+	const start = text.trimStart().replace(/^`{3}[\w-]*\n/, "");
+	if (start.startsWith("<<<<<<< SEARCH")) return true;
+	return "<<<<<<< SEARCH".startsWith(start) ? null : false;
+}
+/** Complete SEARCH/REPLACE blocks in `text`; a block still being written is skipped. */
+function parseEdits(text) {
+	const edits = [];
+	let state = "outside";
+	let search = [];
+	let replace = [];
+	for (const line of text.split("\n")) {
+		const marker = line.trim();
+		if (state === "outside") {
+			if (marker === "<<<<<<< SEARCH") {
+				state = "search";
+				search = [];
+			}
+		} else if (state === "search") {
+			if (marker === DIVIDER) {
+				state = "replace";
+				replace = [];
+			} else search.push(line);
+		} else if (marker === REPLACE_MARKER) {
+			edits.push({
+				replace: replace.join("\n"),
+				search: search.join("\n")
+			});
+			state = "outside";
+		} else if (!FENCE.test(marker)) replace.push(line);
+	}
+	return edits;
+}
+/** Starts of every line range in `lines` matching `search` when leading and trailing whitespace is ignored. */
+function findLoose(lines, search) {
+	const target = search.map((line) => line.trim());
+	const starts = [];
+	for (let start = 0; start + target.length <= lines.length; start++) if (target.every((line, offset) => lines[start + offset]?.trim() === line)) starts.push(start);
+	return starts;
+}
+/** Every index at which `search` occurs in `text`, without overlaps. */
+function findExact(text, search) {
+	const indexes = [];
+	for (let index = text.indexOf(search); index !== -1; index = text.indexOf(search, index + search.length)) indexes.push(index);
+	return indexes;
+}
+const lineAt = (text, index) => text.slice(0, index).split("\n").length;
+const MARKERS = /* @__PURE__ */ new Set([
+	DIVIDER,
+	REPLACE_MARKER,
+	SEARCH_MARKER
+]);
+const hasMarker = (text) => text.split("\n").some((line) => MARKERS.has(line.trim()));
+/**
+* Applies edits in order. Each SEARCH must appear in the document exactly
+* once, exactly or ignoring indentation; an empty SEARCH appends. Stops at
+* the first edit that doesn't match, matches more than once, or whose
+* REPLACE still contains edit markers.
+*/
+function applyEdits(base, edits) {
+	let text = base;
+	for (const edit of edits) {
+		if (hasMarker(edit.replace)) return {
+			failed: edit,
+			ok: false,
+			reason: "malformed"
+		};
+		if (edit.search.trim() === "") {
+			text = `${text.trimEnd()}\n${edit.replace}`;
+			continue;
+		}
+		const exact = findExact(text, edit.search);
+		if (exact.length > 1) return {
+			failed: edit,
+			lines: exact.map((index) => lineAt(text, index)),
+			ok: false,
+			reason: "ambiguous"
+		};
+		const [index] = exact;
+		if (index !== void 0) {
+			text = text.slice(0, index) + edit.replace + text.slice(index + edit.search.length);
+			continue;
+		}
+		const lines = text.split("\n");
+		const searchLines = edit.search.split("\n");
+		const starts = findLoose(lines, searchLines);
+		if (starts.length > 1) return {
+			failed: edit,
+			lines: starts.map((start) => start + 1),
+			ok: false,
+			reason: "ambiguous"
+		};
+		const [start] = starts;
+		if (start === void 0) return {
+			failed: edit,
+			ok: false,
+			reason: "missing"
+		};
+		lines.splice(start, searchLines.length, ...edit.replace.split("\n"));
+		text = lines.join("\n");
+	}
+	return {
+		ok: true,
+		text
+	};
+}
+/** Diagnostic codes the parser reports when it changed the source to make it parse. */
+const PARSER_REPAIRS = /* @__PURE__ */ new Set(["repaired", "unclosed"]);
+/**
+* The parser repairs an edited document needs that its base did not: an
+* edit that leaves a tag unclosed or closes one twice. Diagnostics are
+* matched by code and message, not line, since an edit moves lines; a
+* repair the base already needed is not new, however many times it moves.
+*/
+function editBreakage(base, edited) {
+	const had = /* @__PURE__ */ new Map();
+	for (const diagnostic of base) if (PARSER_REPAIRS.has(diagnostic.code)) {
+		const key = `${diagnostic.code}\n${diagnostic.message}`;
+		had.set(key, (had.get(key) ?? 0) + 1);
+	}
+	return edited.filter((diagnostic) => {
+		if (!PARSER_REPAIRS.has(diagnostic.code)) return false;
+		const key = `${diagnostic.code}\n${diagnostic.message}`;
+		const left = had.get(key) ?? 0;
+		if (left === 0) return true;
+		had.set(key, left - 1);
+		return false;
+	});
+}
+//#endregion
+export { SEARCH_MARKER, applyEdits, editBreakage, isEditReply, parseEdits };

package/dist/script.d.ts

@@ -0,0 +1,14 @@
+//#region src/script.d.ts
+/** A `useQuery(...)`, `useMutation(...)` or stray `useAction(...)` call, wherever it sits. */
+export interface ProcedureCall {
+  /** Just past it, counted as `offset` is. */
+  end: number;
+  /** `useAction` is not a hook; it is recorded so the server can say to write `useMutation`. */
+  hook: "useAction" | "useMutation" | "useQuery";
+  /** The first argument when it is a plain string; null when it is computed or missing. */
+  name: string | null;
+  offset: number;
+  /** The first argument is an object: TanStack Query's options form. */
+  tanstack: boolean;
+}
+//#endregion