modwright 0.1.0

package/dist/core/scaffold/emit.js

@@ -0,0 +1,356 @@
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { pathExists } from "../fsutil.js";
+import { cloneJson, isJsonArray, isJsonObject, parseJson, walkJson } from "../text/json.js";
+import { renumberHandles } from "../text/handles.js";
+import { deleteAtPath, getAtPath, setAtPath } from "./jsonpath.js";
+import { interpolate, interpolateDeep, reindentBlock } from "./render.js";
+const CR2W_RESOURCE_EXT_RE = /\.(ent|app|mesh|mi|mlsetup|streamingsector|streamingblock|inkatlas|csv|json)\.json$/i;
+function looksLikeCr2wJson(filePath) {
+    return CR2W_RESOURCE_EXT_RE.test(path.basename(filePath).toLowerCase()) || path.basename(filePath).toLowerCase().endsWith(".streamingsector.json");
+}
+function xmlEscape(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function resolvePath(raw, scope, projectRoot) {
+    const abs = resolveAnyPath(raw, scope, projectRoot);
+    const rel = path.relative(projectRoot, abs);
+    if (rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) {
+        throw new Error(`scaffold path "${raw}" resolves to ${abs}, outside the project ${projectRoot}; scaffolds only write inside the project.`);
+    }
+    return abs;
+}
+function resolveAnyPath(raw, scope, projectRoot) {
+    const rendered = interpolate(raw, scope);
+    return path.resolve(projectRoot, rendered);
+}
+function whenHolds(when, scope) {
+    if ("templateDefined" in when)
+        return scope.template[when.templateDefined] !== undefined;
+    if ("templateUndefined" in when)
+        return scope.template[when.templateUndefined] === undefined;
+    if ("inputDefined" in when)
+        return scope.input[when.inputDefined] !== undefined;
+    return scope.input[when.inputUndefined] === undefined;
+}
+function canonical(value) {
+    if (isJsonArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (isJsonObject(value)) {
+        return `{${Object.keys(value)
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function interpolateValue(value, scope) {
+    return (typeof value === "string" ? interpolate(value, scope) : interpolateDeep(value, scope));
+}
+function findMatches(root, match) {
+    const out = [];
+    const entries = Object.entries(match);
+    walkJson(root, (node, at) => {
+        if (!isJsonObject(node))
+            return;
+        if (entries.every(([k, v]) => getAtPath(node, k) === v))
+            out.push({ node, at });
+    });
+    return out;
+}
+function appendTarget(pointer) {
+    if (pointer === "-")
+        return "";
+    return pointer.endsWith(".-") ? pointer.slice(0, -2) : undefined;
+}
+function finishJson(definitionId, root, renumber, absPath) {
+    let finalRoot = root;
+    if (renumber) {
+        const result = renumberHandles(root);
+        if (result.danglingRefs.length > 0) {
+            const list = result.danglingRefs.map((d) => `${d.ref} at ${d.path}`).join("; ");
+            throw new Error(`scaffold "${definitionId}": ${absPath} has a HandleRefId with no HandleId before it in the document (${list}); WolvenKit cannot deserialize a reference ahead of its handle.`);
+        }
+        finalRoot = result.root;
+    }
+    return `${JSON.stringify(finalRoot, null, 2)}\n`;
+}
+async function currentText(absPath, pending) {
+    if (pending.has(absPath))
+        return pending.get(absPath);
+    if (await pathExists(absPath))
+        return fs.readFile(absPath, "utf8");
+    return undefined;
+}
+async function currentJson(absPath, pending) {
+    const text = await currentText(absPath, pending);
+    if (text === undefined)
+        return undefined;
+    return parseJson(text, absPath);
+}
+export async function renderEmits(definition, scope, projectRoot) {
+    const ops = [];
+    const content = new Map();
+    const mkdirs = new Set();
+    const authoringManifestEntries = [];
+    const projectPatch = { sources: [], steps: [], deployTargets: [], dependencies: [], outDir: undefined, toolchain: {} };
+    const guardSkipped = [];
+    for (const emit of definition.emits) {
+        await applyOne(emit);
+    }
+    return { ops, content, mkdirs, authoringManifestEntries, projectPatch, guardSkipped };
+    async function applyOne(emit) {
+        if (emit.when && !whenHolds(emit.when, scope)) {
+            const reason = "templateDefined" in emit.when
+                ? `guarded by when.templateDefined: "${emit.when.templateDefined}", which is not set in this run`
+                : "templateUndefined" in emit.when
+                    ? `guarded by when.templateUndefined: "${emit.when.templateUndefined}", which is set in this run`
+                    : "inputDefined" in emit.when
+                        ? `guarded by when.inputDefined: "${emit.when.inputDefined}", which was not provided in this run`
+                        : `guarded by when.inputUndefined: "${emit.when.inputUndefined}", which was provided in this run`;
+            guardSkipped.push({
+                op: emit.op,
+                path: "path" in emit ? resolvePath(emit.path, scope, projectRoot) : undefined,
+                reason,
+            });
+            return;
+        }
+        switch (emit.op) {
+            case "ensure-dir": {
+                const abs = resolvePath(emit.path, scope, projectRoot);
+                mkdirs.add(abs);
+                ops.push({ kind: "mkdir", absPath: abs });
+                return;
+            }
+            case "write-text": {
+                const abs = resolvePath(emit.path, scope, projectRoot);
+                const existing = await currentText(abs, content);
+                if (existing !== undefined && emit.ifExists !== "overwrite") {
+                    if (emit.ifExists === "skip") {
+                        ops.push({ kind: "skip", absPath: abs, reason: "already exists; ifExists: skip" });
+                        return;
+                    }
+                    throw new Error(`scaffold "${definition.id}": write-text target already exists: ${abs} (ifExists: fail).`);
+                }
+                const body = interpolate(emit.body, scope);
+                const withBom = emit.bom ? `${body}` : body;
+                content.set(abs, withBom);
+                ops.push({ kind: existing === undefined ? "create" : "overwrite", absPath: abs, content: withBom, sizeBytes: Buffer.byteLength(withBom, "utf8") });
+                return;
+            }
+            case "insert-block": {
+                const abs = resolvePath(emit.path, scope, projectRoot);
+                let current = await currentText(abs, content);
+                const isNew = current === undefined;
+                if (current === undefined) {
+                    if (emit.createIfMissing === undefined) {
+                        throw new Error(`scaffold "${definition.id}": insert-block target does not exist and no createIfMissing was given: ${abs}.`);
+                    }
+                    current = interpolate(emit.createIfMissing, scope);
+                }
+                const rawBody = interpolate(emit.body, scope);
+                const body = emit.indent !== undefined ? reindentBlock(rawBody, emit.indent) : rawBody;
+                let next;
+                if (emit.anchor === "before-first-entry") {
+                    const lines = current.split("\n");
+                    const headerLen = current.startsWith(current.split("\n")[0] ?? "") ? 1 : 0;
+                    next = [...lines.slice(0, headerLen), body, ...lines.slice(headerLen)].join("\n");
+                }
+                else if (emit.anchor === "before-last-line") {
+                    if (emit.anchorPattern === undefined) {
+                        throw new Error(`scaffold "${definition.id}": insert-block anchor "before-last-line" needs an anchorPattern.`);
+                    }
+                    const re = new RegExp(emit.anchorPattern);
+                    const lines = current.split("\n");
+                    let idx = -1;
+                    for (let i = lines.length - 1; i >= 0; i--) {
+                        if (re.test(lines[i])) {
+                            idx = i;
+                            break;
+                        }
+                    }
+                    if (idx === -1) {
+                        throw new Error(`scaffold "${definition.id}": insert-block found no line matching /${emit.anchorPattern}/ to insert before in ${abs}.`);
+                    }
+                    next = [...lines.slice(0, idx), body, ...lines.slice(idx)].join("\n");
+                }
+                else {
+                    next = current.endsWith("\n") || current.length === 0 ? `${current}${body}` : `${current}\n${body}`;
+                }
+                content.set(abs, next);
+                ops.push({ kind: isNew ? "create" : "overwrite", absPath: abs, content: next, sizeBytes: Buffer.byteLength(next, "utf8") });
+                return;
+            }
+            case "insert-loca-row": {
+                const abs = resolvePath(emit.path, scope, projectRoot);
+                const current = await currentText(abs, content);
+                if (current === undefined) {
+                    throw new Error(`scaffold "${definition.id}": insert-loca-row target does not exist: ${abs}. A loca file must already exist (this scaffold, or an earlier one, creates it).`);
+                }
+                const rawHandle = interpolate(emit.handle, scope);
+                const text = interpolate(emit.text, scope);
+                const suffix = /^(.*?);(\d+)$/.exec(rawHandle);
+                const handle = suffix ? suffix[1] : rawHandle;
+                const version = suffix ? Number.parseInt(suffix[2], 10) : emit.version;
+                const row = `    <content contentuid="${handle}" version="${version}">${xmlEscape(text)}</content>`;
+                const marker = "</contentList>";
+                const idx = current.lastIndexOf(marker);
+                if (idx === -1) {
+                    throw new Error(`scaffold "${definition.id}": ${abs} has no </contentList> to insert before.`);
+                }
+                const before = current.slice(0, idx).replace(/\n?$/, "\n");
+                const next = `${before}${row}\n${current.slice(idx)}`;
+                content.set(abs, next);
+                ops.push({ kind: "overwrite", absPath: abs, content: next, sizeBytes: Buffer.byteLength(next, "utf8") });
+                return;
+            }
+            case "insert-xl-entry": {
+                const abs = resolvePath(emit.path, scope, projectRoot);
+                const pointer = interpolate(emit.pointer, scope);
+                const value = interpolateDeep(emit.value, scope);
+                const existingJson = await currentJson(abs, content);
+                const isNew = existingJson === undefined;
+                const root = existingJson ?? {};
+                const listPath = appendTarget(pointer);
+                if (emit.unique && listPath !== undefined && existingJson !== undefined) {
+                    const list = listPath === "" ? root : getAtPath(root, listPath);
+                    if (isJsonArray(list) && list.some((item) => canonical(item) === canonical(value))) {
+                        ops.push({ kind: "skip", absPath: abs, reason: `${listPath || "(root)"} already holds this entry; unique: true` });
+                        return;
+                    }
+                }
+                setAtPath(root, pointer, value);
+                let finalRoot = root;
+                if (looksLikeCr2wJson(abs)) {
+                    finalRoot = renumberHandles(root).root;
+                }
+                const text = `${JSON.stringify(finalRoot, null, 2)}\n`;
+                content.set(abs, text);
+                ops.push({ kind: isNew ? "create" : "overwrite", absPath: abs, content: text, sizeBytes: Buffer.byteLength(text, "utf8") });
+                return;
+            }
+            case "insert-csv-row": {
+                const abs = resolvePath(emit.path, scope, projectRoot);
+                const row = interpolateDeep(emit.row, scope);
+                const keys = Object.keys(row);
+                const line = keys.map((k) => (row[k].includes(",") ? `"${row[k].replace(/"/g, '""')}"` : row[k])).join(",");
+                const current = await currentText(abs, content);
+                const isNew = current === undefined;
+                const header = keys.join(",");
+                const next = current === undefined ? `${header}\n${line}\n` : current.endsWith("\n") ? `${current}${line}\n` : `${current}\n${line}\n`;
+                content.set(abs, next);
+                ops.push({ kind: isNew ? "create" : "overwrite", absPath: abs, content: next, sizeBytes: Buffer.byteLength(next, "utf8") });
+                return;
+            }
+            case "write-json": {
+                const abs = resolvePath(emit.path, scope, projectRoot);
+                const existing = await currentText(abs, content);
+                if (existing !== undefined && emit.ifExists !== "overwrite") {
+                    if (emit.ifExists === "skip") {
+                        ops.push({ kind: "skip", absPath: abs, reason: "already exists; ifExists: skip" });
+                        return;
+                    }
+                    throw new Error(`scaffold "${definition.id}": write-json target already exists: ${abs} (ifExists: fail).`);
+                }
+                const text = finishJson(definition.id, interpolateValue(emit.value, scope), emit.renumberHandles, abs);
+                content.set(abs, text);
+                ops.push({ kind: existing === undefined ? "create" : "overwrite", absPath: abs, content: text, sizeBytes: Buffer.byteLength(text, "utf8") });
+                return;
+            }
+            case "write-json-from-template": {
+                const abs = resolvePath(emit.path, scope, projectRoot);
+                const templateEntry = definition.templates.find((t) => t.ref === emit.template);
+                if (!templateEntry) {
+                    throw new Error(`scaffold "${definition.id}": write-json-from-template names template "${emit.template}", which is not in this definition's templates[].`);
+                }
+                const templateAbs = resolveAnyPath(templateEntry.from, scope, projectRoot);
+                const templateText = await fs.readFile(templateAbs, "utf8");
+                const templateSha256 = createHash("sha256").update(templateText).digest("hex");
+                const root = parseJson(templateText, templateAbs);
+                for (const req of emit.require) {
+                    const match = {};
+                    for (const [k, v] of Object.entries(req.match))
+                        match[k] = interpolate(v, scope);
+                    const found = findMatches(root, match).length;
+                    if (found < (req.minMatches ?? 1)) {
+                        throw new Error(`scaffold "${definition.id}": template "${emit.template}" has ${found} object(s) where ${JSON.stringify(match)}. ${interpolate(req.reason, scope)}`);
+                    }
+                }
+                const rewrittenPaths = [];
+                for (const r of emit.rewrite) {
+                    const value = interpolateValue(r.value, scope);
+                    if (!r.match) {
+                        setAtPath(root, r.path, value);
+                        rewrittenPaths.push(r.path);
+                        continue;
+                    }
+                    const match = {};
+                    for (const [k, v] of Object.entries(r.match))
+                        match[k] = interpolate(v, scope);
+                    const hits = findMatches(root, match);
+                    const min = r.minMatches ?? 1;
+                    if (hits.length < min) {
+                        throw new Error(`scaffold "${definition.id}": rewrite of "${r.path}" matched ${hits.length} object(s) in template "${emit.template}" where ${JSON.stringify(match)}, and needs at least ${min}. The template is not the kind this scaffold expects, or the match is wrong.`);
+                    }
+                    for (const hit of hits) {
+                        setAtPath(hit.node, r.path, cloneJson(value));
+                        rewrittenPaths.push(`${hit.at.replace(/^\$\.?/, "")}.${r.path}`);
+                    }
+                }
+                for (const s of emit.strip)
+                    deleteAtPath(root, s);
+                const text = finishJson(definition.id, root, emit.renumberHandles, abs);
+                const isNew = !content.has(abs) && !(await pathExists(abs));
+                content.set(abs, text);
+                const authoredSha256 = createHash("sha256").update(text).digest("hex");
+                ops.push({ kind: isNew ? "create" : "overwrite", absPath: abs, content: text, sizeBytes: Buffer.byteLength(text, "utf8") });
+                const provenance = templateEntry.provenanceFrom
+                    ? (scope.template[`${templateEntry.provenanceFrom}.provenance`] ?? "authored")
+                    : "authored";
+                const permission = templateEntry.provenanceFrom
+                    ? (scope.template[`${templateEntry.provenanceFrom}.permission`] ?? "maintainer-own")
+                    : "maintainer-own";
+                const derivedFrom = templateEntry.provenanceFrom
+                    ? (scope.template[`${templateEntry.provenanceFrom}.ref`] ?? templateEntry.ref)
+                    : templateEntry.ref;
+                authoringManifestEntries.push({
+                    path: path.relative(projectRoot, abs).split(path.sep).join("/"),
+                    derivedFrom,
+                    provenance,
+                    permission,
+                    templateSha256,
+                    authoredSha256,
+                    rewrittenPaths,
+                    scaffold: definition.id,
+                    writtenAt: new Date().toISOString(),
+                });
+                return;
+            }
+            case "patch-project": {
+                projectPatch.sources.push(...interpolateDeep(emit.add.sources, scope));
+                projectPatch.steps.push(...interpolateDeep(emit.add.steps, scope));
+                projectPatch.deployTargets.push(...interpolateDeep(emit.add.deployTargets, scope));
+                projectPatch.dependencies.push(...interpolateDeep(emit.add.dependencies, scope));
+                if (emit.add.outDir !== undefined)
+                    projectPatch.outDir = interpolate(emit.add.outDir, scope);
+                for (const [toolId, raw] of Object.entries(emit.add.toolchain ?? {})) {
+                    const value = interpolate(raw, scope).trim();
+                    if (value)
+                        projectPatch.toolchain[toolId] = value;
+                }
+                return;
+            }
+        }
+    }
+}
+export function pathsTouchedBy(definition, scope, projectRoot) {
+    const out = new Set();
+    for (const emit of definition.emits) {
+        if (emit.when && !whenHolds(emit.when, scope))
+            continue;
+        if ("path" in emit)
+            out.add(resolvePath(emit.path, scope, projectRoot));
+    }
+    return [...out];
+}