@intentius/chant 0.124.12 → 0.124.14

package/dist/workspace/json-edit.js

@@ -0,0 +1,221 @@
+/**
+ * Edit one property of a JSON or JSONC document in place (#3308), for the
+ * write commands that change a field of the workspace declaration.
+ *
+ * Only the text of the property changed is touched: the rest of the file
+ * keeps its indentation, key order, line endings, comments and trailing
+ * commas. A new property goes after the last one of its object, indented
+ * like it. The caller re-parses the result and compares it with the value it
+ * meant to write, so an edit this module gets wrong is never written.
+ */
+import { parseJsonText, pointerToken } from "./jsonc.js";
+export class JsonEditError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "JsonEditError";
+    }
+}
+function parse(text, jsonc) {
+    const r = parseJsonText(text, { jsonc });
+    if (!r.ok)
+        throw new JsonEditError(`the file does not parse: ${r.message} at line ${r.location.line}, column ${r.location.column}`);
+    return r;
+}
+/** The value at a JSON Pointer, or undefined. */
+export function valueAt(root, pointer) {
+    if (pointer === "")
+        return root;
+    let at = root;
+    for (const raw of pointer.slice(1).split("/")) {
+        const token = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+        if (at === null || typeof at !== "object")
+            return undefined;
+        if (Array.isArray(at))
+            at = at[Number(token)];
+        else
+            at = Object.prototype.hasOwnProperty.call(at, token) ? at[token] : undefined;
+    }
+    return at;
+}
+const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+/** The text's line ending, and the indentation one level adds (the first indented line's, else two spaces). */
+function style(text) {
+    const eol = text.includes("\r\n") ? "\r\n" : "\n";
+    const m = /\n([ \t]+)\S/.exec(text);
+    return { eol, unit: m ? (m[1].startsWith("\t") ? "\t" : m[1]) : "  " };
+}
+function lineStart(text, offset) {
+    return text.lastIndexOf("\n", offset - 1) + 1;
+}
+function lineIndent(text, offset) {
+    const start = lineStart(text, offset);
+    return /^[ \t]*/.exec(text.slice(start))[0];
+}
+/** The offset of the next character after `from` that is not whitespace or a comment. */
+function skipTrivia(text, from) {
+    let i = from;
+    for (;;) {
+        const c = text[i];
+        if (c === " " || c === "\t" || c === "\n" || c === "\r")
+            i++;
+        else if (c === "/" && text[i + 1] === "/") {
+            while (i < text.length && text[i] !== "\n")
+                i++;
+        }
+        else if (c === "/" && text[i + 1] === "*") {
+            const end = text.indexOf("*/", i + 2);
+            i = end < 0 ? text.length : end + 2;
+        }
+        else
+            return i;
+    }
+}
+function render(value, indent, unit, eol) {
+    return JSON.stringify(value, null, unit).split("\n").join(eol + indent);
+}
+/**
+ * Set `key` of the object at `objectPointer` to `value`: replace the value's
+ * text when the key is there, else add the key after the object's last one.
+ * Throws a {@link JsonEditError} when there is no object at the pointer.
+ */
+export function setProperty(text, jsonc, objectPointer, key, value) {
+    const r = parse(text, jsonc);
+    const parent = valueAt(r.value, objectPointer);
+    if (!isObject(parent))
+        throw new JsonEditError(`there is no object at ${objectPointer || "the root"}`);
+    const { eol, unit } = style(text);
+    const child = r.span(`${objectPointer}/${pointerToken(key)}`);
+    if (child)
+        return text.slice(0, child.start) + render(value, lineIndent(text, child.key ?? child.start), unit, eol) + text.slice(child.end);
+    const obj = r.span(objectPointer);
+    const parentIndent = lineIndent(text, obj.key ?? obj.start);
+    const keys = Object.keys(parent);
+    if (keys.length === 0) {
+        const indent = parentIndent + unit;
+        return `${text.slice(0, obj.start)}{${eol}${indent}${JSON.stringify(key)}: ${render(value, indent, unit, eol)}${eol}${parentIndent}}${text.slice(obj.end)}`;
+    }
+    const last = r.span(`${objectPointer}/${pointerToken(keys[keys.length - 1])}`);
+    const next = skipTrivia(text, last.end);
+    const trailingComma = text[next] === ",";
+    if (lineStart(text, last.key) === lineStart(text, obj.start)) {
+        // An object on one line stays on one line.
+        const entry = `${JSON.stringify(key)}: ${JSON.stringify(value)}`;
+        return trailingComma ? `${text.slice(0, next + 1)} ${entry},${text.slice(next + 1)}` : `${text.slice(0, last.end)}, ${entry}${text.slice(last.end)}`;
+    }
+    const indent = lineIndent(text, last.key);
+    const after = trailingComma ? next + 1 : last.end;
+    // After a comment that ends the last property's line, so the comment stays with it.
+    const eolAt = text.indexOf("\n", after);
+    const lineEnd = eolAt < 0 ? text.length : text[eolAt - 1] === "\r" ? eolAt - 1 : eolAt;
+    const at = /^[ \t]*(\/\/.*)?$/.test(text.slice(after, lineEnd)) ? lineEnd : after;
+    const entry = `${eol}${indent}${JSON.stringify(key)}: ${render(value, indent, unit, eol)}`;
+    if (trailingComma)
+        return `${text.slice(0, at)}${entry},${text.slice(at)}`;
+    return `${text.slice(0, last.end)},${text.slice(last.end, at)}${entry}${text.slice(at)}`;
+}
+/** Remove `key` from the object at `objectPointer`, with the comma that went with it. Unchanged when the key is not there. */
+export function removeProperty(text, jsonc, objectPointer, key) {
+    const r = parse(text, jsonc);
+    const parent = valueAt(r.value, objectPointer);
+    if (!isObject(parent))
+        throw new JsonEditError(`there is no object at ${objectPointer || "the root"}`);
+    const child = r.span(`${objectPointer}/${pointerToken(key)}`);
+    if (!child)
+        return text;
+    const keys = Object.keys(parent);
+    const obj = r.span(objectPointer);
+    if (keys.length === 1)
+        return `${text.slice(0, obj.start)}{}${text.slice(obj.end)}`;
+    const next = skipTrivia(text, child.end);
+    if (text[next] === ",") {
+        const start = lineStart(text, child.key);
+        const ownLine = /^[ \t]*$/.test(text.slice(start, child.key));
+        let to = next + 1;
+        const eolAt = text.indexOf("\n", to);
+        if (ownLine && /^[ \t\r]*$/.test(text.slice(to, eolAt < 0 ? text.length : eolAt)))
+            to = eolAt < 0 ? text.length : eolAt + 1;
+        else
+            while (text[to] === " ")
+                to++;
+        return text.slice(0, ownLine ? start : child.key) + text.slice(to);
+    }
+    // The last property, with no trailing comma: remove from the comma after the one before it.
+    const prev = r.span(`${objectPointer}/${pointerToken(keys[keys.indexOf(key) - 1])}`);
+    const comma = skipTrivia(text, prev.end);
+    return text.slice(0, comma) + text.slice(child.end);
+}
+/**
+ * Add `value` to the end of the array at `arrayPointer` (#3596), indented
+ * like the element before it, or on its own line in an empty array. An array
+ * on one line stays on one line. Throws a {@link JsonEditError} when there is
+ * no array at the pointer.
+ */
+export function appendElement(text, jsonc, arrayPointer, value) {
+    const r = parse(text, jsonc);
+    const arr = valueAt(r.value, arrayPointer);
+    if (!Array.isArray(arr))
+        throw new JsonEditError(`there is no array at ${arrayPointer || "the root"}`);
+    const { eol, unit } = style(text);
+    const span = r.span(arrayPointer);
+    const parentIndent = lineIndent(text, span.key ?? span.start);
+    if (arr.length === 0) {
+        // Inside the brackets, after anything already there, such as a comment.
+        const indent = parentIndent + unit;
+        const inside = text.slice(span.start + 1, span.end - 1).replace(/\s+$/, "");
+        return `${text.slice(0, span.start)}[${inside}${eol}${indent}${render(value, indent, unit, eol)}${eol}${parentIndent}]${text.slice(span.end)}`;
+    }
+    const last = r.span(`${arrayPointer}/${arr.length - 1}`);
+    const next = skipTrivia(text, last.end);
+    const trailingComma = text[next] === ",";
+    if (lineStart(text, last.start) === lineStart(text, span.start)) {
+        const entry = JSON.stringify(value);
+        return trailingComma ? `${text.slice(0, next + 1)} ${entry},${text.slice(next + 1)}` : `${text.slice(0, last.end)}, ${entry}${text.slice(last.end)}`;
+    }
+    const indent = lineIndent(text, last.start);
+    const after = trailingComma ? next + 1 : last.end;
+    const eolAt = text.indexOf("\n", after);
+    const lineEnd = eolAt < 0 ? text.length : text[eolAt - 1] === "\r" ? eolAt - 1 : eolAt;
+    const at = /^[ \t]*(\/\/.*)?$/.test(text.slice(after, lineEnd)) ? lineEnd : after;
+    const entry = `${eol}${indent}${render(value, indent, unit, eol)}`;
+    if (trailingComma)
+        return `${text.slice(0, at)}${entry},${text.slice(at)}`;
+    return `${text.slice(0, last.end)},${text.slice(last.end, at)}${entry}${text.slice(at)}`;
+}
+/** Replace the element at `index` of the array at `arrayPointer` with `value` (#3596). Throws a {@link JsonEditError} when there is none. */
+export function setElement(text, jsonc, arrayPointer, index, value) {
+    const r = parse(text, jsonc);
+    const arr = valueAt(r.value, arrayPointer);
+    if (!Array.isArray(arr) || index < 0 || index >= arr.length)
+        throw new JsonEditError(`there is no element ${index} in an array at ${arrayPointer || "the root"}`);
+    const { eol, unit } = style(text);
+    const span = r.span(arrayPointer);
+    const child = r.span(`${arrayPointer}/${index}`);
+    const value_ = lineStart(text, child.start) === lineStart(text, span.start) ? JSON.stringify(value) : render(value, lineIndent(text, child.start), unit, eol);
+    return text.slice(0, child.start) + value_ + text.slice(child.end);
+}
+/** Remove the element at `index` of the array at `arrayPointer`, with the comma that went with it (#3596). Throws a {@link JsonEditError} when there is none. */
+export function removeElement(text, jsonc, arrayPointer, index) {
+    const r = parse(text, jsonc);
+    const arr = valueAt(r.value, arrayPointer);
+    if (!Array.isArray(arr) || index < 0 || index >= arr.length)
+        throw new JsonEditError(`there is no element ${index} in an array at ${arrayPointer || "the root"}`);
+    const child = r.span(`${arrayPointer}/${index}`);
+    const next = skipTrivia(text, child.end);
+    if (text[next] === "," || arr.length === 1) {
+        const start = lineStart(text, child.start);
+        const ownLine = /^[ \t]*$/.test(text.slice(start, child.start));
+        // The only element may have no comma after it.
+        let to = text[next] === "," ? next + 1 : child.end;
+        const eolAt = text.indexOf("\n", to);
+        if (ownLine && /^[ \t\r]*$/.test(text.slice(to, eolAt < 0 ? text.length : eolAt)))
+            to = eolAt < 0 ? text.length : eolAt + 1;
+        else
+            while (text[to] === " ")
+                to++;
+        return text.slice(0, ownLine ? start : child.start) + text.slice(to);
+    }
+    // The last element, with no trailing comma: remove from the comma after the one before it.
+    const prev = r.span(`${arrayPointer}/${index - 1}`);
+    const comma = skipTrivia(text, prev.end);
+    return text.slice(0, comma) + text.slice(child.end);
+}

package/dist/workspace/jsonc.js

@@ -0,0 +1,235 @@
+/**
+ * A small JSON reader that keeps positions, for the workspace declaration
+ * (#2534). `chant.workspace.json` is strict JSON; `chant.workspace.jsonc` also
+ * allows `//` and `/* *\/` comments and trailing commas.
+ *
+ * `JSON.parse` would do for the strict file, but it reports neither a line
+ * nor a column in every runtime, it accepts duplicate keys by keeping the last
+ * one, and it can't say where a value sits once parsed. A schema error has to
+ * name the line it comes from, so this reader records where each value and
+ * each key starts, by JSON Pointer.
+ */
+class JsonSyntaxError extends Error {
+    constructor(message, offset) {
+        super(message);
+        this.offset = offset;
+    }
+}
+/** Escape one reference token for a JSON Pointer (RFC 6901). */
+export function pointerToken(token) {
+    return String(token).replace(/~/g, "~0").replace(/\//g, "~1");
+}
+export function parseJsonText(text, options) {
+    const lineStarts = [0];
+    for (let i = 0; i < text.length; i++)
+        if (text.charCodeAt(i) === 10)
+            lineStarts.push(i + 1);
+    const toLocation = (offset) => {
+        let lo = 0;
+        let hi = lineStarts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (lineStarts[mid] <= offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return { line: lo + 1, column: offset - lineStarts[lo] + 1 };
+    };
+    const values = new Map();
+    const ends = new Map();
+    const keys = new Map();
+    let i = text.charCodeAt(0) === 0xfeff ? 1 : 0;
+    const fail = (message, offset = i) => {
+        throw new JsonSyntaxError(message, offset);
+    };
+    const describe = (offset) => offset >= text.length ? "the end of the file" : `${JSON.stringify(text[offset])}`;
+    function skip() {
+        for (;;) {
+            const c = text[i];
+            if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+                i++;
+            }
+            else if (c === "/" && (text[i + 1] === "/" || text[i + 1] === "*")) {
+                if (!options.jsonc)
+                    fail("comments are only allowed in chant.workspace.jsonc");
+                if (text[i + 1] === "/") {
+                    while (i < text.length && text[i] !== "\n")
+                        i++;
+                }
+                else {
+                    const end = text.indexOf("*/", i + 2);
+                    if (end < 0)
+                        fail("unterminated /* comment");
+                    i = end + 2;
+                }
+            }
+            else {
+                return;
+            }
+        }
+    }
+    function parseString() {
+        const start = i;
+        i++;
+        for (;;) {
+            if (i >= text.length)
+                fail("unterminated string", start);
+            const c = text.charCodeAt(i);
+            if (c === 0x22)
+                break;
+            if (c < 0x20)
+                fail("control character in a string; escape it", i);
+            i += c === 0x5c ? 2 : 1;
+        }
+        i++;
+        try {
+            return JSON.parse(text.slice(start, i));
+        }
+        catch {
+            return fail("invalid escape in a string", start);
+        }
+    }
+    function parseValue(pointer) {
+        skip();
+        values.set(pointer, i);
+        const value = parseAt(pointer);
+        ends.set(pointer, i);
+        return value;
+    }
+    function parseAt(pointer) {
+        const c = text[i];
+        if (c === "{")
+            return parseObject(pointer);
+        if (c === "[")
+            return parseArray(pointer);
+        if (c === '"')
+            return parseString();
+        for (const [word, value] of [
+            ["true", true],
+            ["false", false],
+            ["null", null],
+        ]) {
+            if (text.startsWith(word, i)) {
+                i += word.length;
+                return value;
+            }
+        }
+        const m = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(text.slice(i, i + 64));
+        if (m) {
+            i += m[0].length;
+            return Number(m[0]);
+        }
+        return fail(`expected a value, found ${describe(i)}`);
+    }
+    function parseObject(pointer) {
+        const obj = {};
+        const seen = new Set();
+        i++;
+        skip();
+        if (text[i] === "}") {
+            i++;
+            return obj;
+        }
+        for (;;) {
+            skip();
+            if (text[i] !== '"')
+                fail(`expected a quoted key, found ${describe(i)}`);
+            const keyAt = i;
+            const key = parseString();
+            if (seen.has(key))
+                fail(`duplicate key ${JSON.stringify(key)}`, keyAt);
+            seen.add(key);
+            const child = `${pointer}/${pointerToken(key)}`;
+            keys.set(child, keyAt);
+            skip();
+            if (text[i] !== ":")
+                fail(`expected ":" after key ${JSON.stringify(key)}, found ${describe(i)}`);
+            i++;
+            // defineProperty, so a "__proto__" key is data and never a prototype.
+            Object.defineProperty(obj, key, { value: parseValue(child), enumerable: true, writable: true, configurable: true });
+            skip();
+            if (text[i] === ",") {
+                i++;
+                skip();
+                if (text[i] === "}") {
+                    if (!options.jsonc)
+                        fail("trailing comma; only chant.workspace.jsonc allows one");
+                    i++;
+                    return obj;
+                }
+                continue;
+            }
+            if (text[i] === "}") {
+                i++;
+                return obj;
+            }
+            fail(`expected "," or "}", found ${describe(i)}`);
+        }
+    }
+    function parseArray(pointer) {
+        const arr = [];
+        i++;
+        skip();
+        if (text[i] === "]") {
+            i++;
+            return arr;
+        }
+        for (;;) {
+            arr.push(parseValue(`${pointer}/${arr.length}`));
+            skip();
+            if (text[i] === ",") {
+                i++;
+                skip();
+                if (text[i] === "]") {
+                    if (!options.jsonc)
+                        fail("trailing comma; only chant.workspace.jsonc allows one");
+                    i++;
+                    return arr;
+                }
+                continue;
+            }
+            if (text[i] === "]") {
+                i++;
+                return arr;
+            }
+            fail(`expected "," or "]", found ${describe(i)}`);
+        }
+    }
+    try {
+        skip();
+        if (i >= text.length)
+            fail("the file is empty");
+        const value = parseValue("");
+        skip();
+        if (i < text.length)
+            fail(`unexpected ${describe(i)} after the value`);
+        return {
+            ok: true,
+            value,
+            locate(pointer, key) {
+                if (key && keys.has(pointer))
+                    return toLocation(keys.get(pointer));
+                for (let p = pointer;; p = p.slice(0, p.lastIndexOf("/"))) {
+                    const at = values.get(p);
+                    if (at !== undefined)
+                        return toLocation(at);
+                    if (p === "")
+                        return toLocation(0);
+                }
+            },
+            span(pointer) {
+                const start = values.get(pointer);
+                const end = ends.get(pointer);
+                if (start === undefined || end === undefined)
+                    return undefined;
+                return { key: keys.get(pointer) ?? null, start, end };
+            },
+        };
+    }
+    catch (err) {
+        if (!(err instanceof JsonSyntaxError))
+            throw err;
+        return { ok: false, message: err.message, location: toLocation(err.offset) };
+    }
+}

package/dist/workspace/kind-readers.js

@@ -0,0 +1,103 @@
+/**
+ * Reader projects for members of a package's kind (#2874).
+ *
+ * `chant workspace graph` runs `chant graph` in each member. A `terraform` or
+ * `choudoufu` member is a directory of `.tf` files with no chant config, so
+ * there is nothing for it to run. The kind's `graph` block in the package's
+ * kinds file says how to read one instead: a lexicon and that lexicon's
+ * config namespace. For each such member chant writes a reader project of its
+ * own, outside the workspace, and the member runs there:
+ *
+ * - `chant.config.json` declares the lexicon, and puts the kind's config under
+ *   the lexicon's key with `{member}`, `{dir}` and `{workspace}` substituted
+ *   (`substituteGraphConfig`). The terraform lexicon's config names one root
+ *   after the member, at the member's directory, with `moduleRoot` at the
+ *   workspace root, so a member that calls `../modules/x` keeps its modules.
+ * - `node_modules` links to the `node_modules` directory holding the lexicon
+ *   package, found from the workspace root as the kind's pin was. The lexicon
+ *   chant loads is then the one the declaration pins.
+ *
+ * Nothing is written under the workspace, and the projects are removed when
+ * the read ends. A lexicon that can't be found where its pin says fails the
+ * member with `command-failed` and says what to install; the other members
+ * still run.
+ */
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { findInstalledPackage, lexiconPackageName, substituteGraphConfig } from "./kinds.js";
+/** The `node_modules` directory an installed package sits in. */
+function nodeModulesOf(packageDir, name) {
+    let dir = packageDir;
+    for (let i = 0; i < name.split("/").length; i++)
+        dir = join(dir, "..");
+    return dir;
+}
+function real(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}
+/** Why a unit's lexicon can't be loaded from `root`, or the `node_modules` to link. */
+function lexiconModules(unit, root) {
+    const reader = unit.reader;
+    const name = lexiconPackageName(reader.lexicon);
+    const installed = findInstalledPackage(name, root);
+    if (!installed) {
+        return {
+            message: `kind ${unit.kind} is read by the ${reader.lexicon} lexicon, and ${name} is not installed in a node_modules at or above ${root}; install it there to read this member`,
+        };
+    }
+    if (real(installed) !== real(reader.packageDir)) {
+        return {
+            message: `kind ${unit.kind} comes from ${reader.packageDir}, and the ${name} found from ${root} is ${real(installed)}; install the pinned package where the workspace resolves it`,
+        };
+    }
+    return { modules: nodeModulesOf(installed, name) };
+}
+/**
+ * Write a reader project for every unit of `plan` that has a `reader`, and
+ * point the unit's `abs` at it. Units that can't get one leave the plan and
+ * are returned in `failed`. `root` is the directory the plan was made from,
+ * the exported tree for `--at`.
+ */
+export function prepareKindReaders(plan, root) {
+    const failed = [];
+    let scratch;
+    const cleanup = () => {
+        if (scratch)
+            rmSync(scratch, { recursive: true, force: true });
+        scratch = undefined;
+    };
+    try {
+        for (const group of plan.groups) {
+            group.units = group.units.filter((unit) => {
+                if (!unit.reader)
+                    return true;
+                const found = lexiconModules(unit, root);
+                if ("message" in found) {
+                    failed.push({ name: unit.member, dir: unit.dir, kind: unit.kind, reason: { code: "command-failed", message: found.message } });
+                    return false;
+                }
+                scratch ?? (scratch = mkdtempSync(join(tmpdir(), "chant-ws-reader-")));
+                const project = join(scratch, unit.id);
+                mkdirSync(project, { recursive: true });
+                const config = substituteGraphConfig(unit.reader.config, { member: unit.member, dir: unit.abs, workspace: root });
+                writeFileSync(join(project, "chant.config.json"), `${JSON.stringify({ lexicons: [unit.reader.lexicon], [unit.reader.lexicon]: config }, null, 2)}\n`);
+                symlinkSync(found.modules, join(project, "node_modules"), "dir");
+                unit.abs = project;
+                return true;
+            });
+        }
+        plan.groups = plan.groups.filter((g) => g.units.length > 0);
+    }
+    catch (err) {
+        cleanup();
+        throw err;
+    }
+    plan.unreadable.push(...failed);
+    return { failed, cleanup };
+}