@abaplint/transpiler-cli 2.14.1 → 2.14.2

package/README.md

@@ -22,6 +22,7 @@ basename of `folder` for a local-only library. Set `libs[].name` to override it:
 {
   "input_folder": ["src", "extra"],
   "output_folder": "output",
+  "incremental_output": true,
   "libs": [
     {"url": "https://github.com/open-abap/open-abap-core"},
     {"folder": "./deps/utilities", "name": "utilities"}
@@ -55,15 +56,28 @@ are rejected by default; a project object replaces a library object of the same
 
 Class locals, test classes, function groups, MIME data, and
 source maps follow their owning object. Source maps include ABAP source content,
-including libraries loaded from temporary Git checkouts. Imports and registered
-MIME filenames reference the new paths.
+including libraries loaded from temporary Git checkouts; they use stable
+library-qualified paths and do not expose the temporary checkout location.
+Imports and registered MIME filenames reference the new paths.
 
 Shared initialization scripts and test runners remain at the output root.
 Run programs with `node output/project/zapp.prog.mjs`; run project unit tests
 with `node output/index.mjs`. When migrating from flat output, rebuild a clean
 generated output directory and update scripts that reference individual
-modules or assets. The CLI does not remove old generated files or unrelated
-files automatically.
+modules or assets.
+
+Set `incremental_output` to `true` to skip writing unchanged files, replace
+changed generated files, and remove obsolete files recorded in
+`output/.abap-transpile-manifest.json`. The CLI preserves files it did not
+generate, including custom setup scripts and other user data. Existing output
+from runs before this option was enabled has no ownership inventory; do one
+clean build when adopting the option to remove legacy stale files. Set the
+option to `false` (the default) to restore unconditional writes. Files
+generated while it is disabled are not added to the inventory.
+
+The manifest is updated atomically and retained as a recovery aid if a run
+fails. This does not make the entire output tree transactional. Use one
+transpiler process per output directory.
 
 The transpiler library retains flat output unless its caller supplies an output
 folder map as the third argument to `Transpiler.run()`. This layout is enabled
@@ -93,5 +107,7 @@ DDIC types, available methods, and runtime behavior, or cause syntax errors in
 code expecting the skipped version. This option does not check that copies are
 equivalent or suppress syntax checking. Put the intended provider first and
 run your application's tests. For selective control, use `libs[].exclude_filter`
-to exclude only the unwanted object's files instead. Use a clean generated
-output directory when changing providers, since old output is not removed.
+to exclude only the unwanted object's files instead. With `incremental_output`
+enabled, changing providers removes obsolete files tracked in the manifest.
+Use a clean generated output directory when changing providers in legacy mode
+or when untracked stale output remains from earlier builds.

package/build/bundle.js

@@ -71,6 +71,7 @@ class TranspilerConfig {
             input_folder: "src",
             input_filter: [],
             output_folder: "output",
+            incremental_output: false,
             libs: [
                 { "url": "https://github.com/open-abap/open-abap-core" },
             ],
@@ -314,14 +315,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-const fs = __importStar(__webpack_require__(/*! fs */ "fs"));
-const path = __importStar(__webpack_require__(/*! path */ "path"));
 const progress_1 = __importDefault(__webpack_require__(/*! progress */ "./node_modules/progress/index.js"));
 const Transpiler = __importStar(__webpack_require__(/*! @abaplint/transpiler */ "./node_modules/@abaplint/transpiler/build/src/index.js"));
 const config_1 = __webpack_require__(/*! ./config */ "./build/config.js");
 const file_operations_1 = __webpack_require__(/*! ./file_operations */ "./build/file_operations.js");
 const libraries_1 = __webpack_require__(/*! ./libraries */ "./build/libraries.js");
 const write_objects_1 = __webpack_require__(/*! ./write_objects */ "./build/write_objects.js");
+const output_writer_1 = __webpack_require__(/*! ./output_writer */ "./build/output_writer.js");
 class Progress {
     bar;
     set(total, _text) {
@@ -351,23 +351,23 @@ async function run() {
     console.log("\nBuilding");
     const { output, sources } = await build(config, files);
     console.log("\nOutput");
-    const outputFolder = config.output_folder;
-    if (!fs.existsSync(outputFolder)) {
-        fs.mkdirSync(outputFolder, { recursive: true });
-    }
-    await (0, write_objects_1.writeObjects)(output.objects, config, sources);
-    console.log(output.objects.length + " objects written to disk");
+    const artifacts = (0, write_objects_1.collectObjectFiles)(output.objects, config, sources);
     if (config.write_unit_tests === true) {
-        // breaking change? rename this output file,
-        fs.writeFileSync(outputFolder + path.sep + "index.mjs", output.unitTestScript);
-        fs.writeFileSync(outputFolder + path.sep + "_unit_open.mjs", output.unitTestScriptOpen);
+        artifacts.push({ path: "index.mjs", contents: output.unitTestScript });
+        artifacts.push({ path: "_unit_open.mjs", contents: output.unitTestScriptOpen });
+    }
+    artifacts.push({ path: "init.mjs", contents: output.initializationScript });
+    artifacts.push({ path: "_init.mjs", contents: output.initializationScript2 });
+    artifacts.push({ path: "_top.mjs", contents: `import runtime from "@abaplint/runtime";
+globalThis.abap = new runtime.ABAP();` });
+    const written = await (0, output_writer_1.writeOutput)(config.output_folder, artifacts, config.incremental_output === true);
+    if (config.incremental_output === true) {
+        console.log("Output files: " + written.created + " created, " +
+            written.updated + " updated, " + written.unchanged + " unchanged, " + written.deleted + " deleted");
+    }
+    else {
+        console.log(`Output files: ${written.updated} written`);
     }
-    // breaking change? rename this output file,
-    fs.writeFileSync(outputFolder + path.sep + "init.mjs", output.initializationScript);
-    // new static referenced imports,
-    fs.writeFileSync(outputFolder + path.sep + "_init.mjs", output.initializationScript2);
-    fs.writeFileSync(outputFolder + path.sep + "_top.mjs", `import runtime from "@abaplint/runtime";
-globalThis.abap = new runtime.ABAP();`);
 }
 run().then(() => {
     process.exit();
@@ -491,6 +491,11 @@ const abaplint = __importStar(__webpack_require__(/*! @abaplint/core */ "./node_
 const file_operations_1 = __webpack_require__(/*! ./file_operations */ "./build/file_operations.js");
 const git_clone_1 = __webpack_require__(/*! ./git_clone */ "./build/git_clone.js");
 const lib_folder_1 = __webpack_require__(/*! ./lib_folder */ "./build/lib_folder.js");
+function logicalLibrarySource(library, directory, filename) {
+    const relative = path.relative(directory, filename).split(path.sep)
+        .map(segment => encodeURIComponent(segment)).join("/");
+    return "abaplint://" + encodeURIComponent(library) + "/" + relative;
+}
 function libraryNames(libs) {
     const used = new Set(["project"]);
     return libs.map(lib => {
@@ -514,6 +519,7 @@ async function loadLibraries(config) {
     const names = libraryNames(libs);
     const result = [];
     for (const [index, lib] of libs.entries()) {
+        const libraryName = names[index];
         let dir;
         let cleanupFolder = false;
         const folder = (0, lib_folder_1.resolveLibFolder)(lib.folder, process.cwd());
@@ -547,8 +553,15 @@ async function loadLibraries(config) {
                     filesToRead.add(filename);
                 }
             }
-            const files = await file_operations_1.FileOperations.readAllFiles([...filesToRead], config.output_folder);
-            result.push({ name: names[index], files });
+            const filenames = [...filesToRead];
+            const files = await file_operations_1.FileOperations.readAllFiles(filenames, config.output_folder);
+            if (cleanupFolder) {
+                for (const [index, file] of files.entries()) {
+                    file.sourceMapPath = logicalLibrarySource(libraryName, dir, filenames[index]);
+                    delete file.relative;
+                }
+            }
+            result.push({ name: libraryName, files });
             console.log("\t" + files.length + " files added from lib");
         }
         finally {
@@ -604,6 +617,347 @@ function libraryRegistry(files, libraries, skipDuplicateDependencies = false) {
 
 /***/ },
 
+/***/ "./build/output_writer.js"
+/*!********************************!*\
+  !*** ./build/output_writer.js ***!
+  \********************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.writeOutput = writeOutput;
+const fsPromises = __importStar(__webpack_require__(/*! node:fs/promises */ "node:fs/promises"));
+const os = __importStar(__webpack_require__(/*! node:os */ "node:os"));
+const path = __importStar(__webpack_require__(/*! node:path */ "node:path"));
+const file_operations_1 = __webpack_require__(/*! ./file_operations */ "./build/file_operations.js");
+const MANIFEST = ".abap-transpile-manifest.json";
+function concurrency() {
+    return Math.max(1, Math.min(8, os.cpus().length));
+}
+async function forEachLimit(items, task, limit = concurrency()) {
+    let next = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (next < items.length) {
+            const index = next++;
+            await task(items[index]);
+        }
+    });
+    const results = await Promise.allSettled(workers);
+    const failed = results.find(result => result.status === "rejected");
+    if (failed?.status === "rejected") {
+        throw failed.reason;
+    }
+}
+function normalizeRelative(filename, label) {
+    if (filename.length === 0 || filename.startsWith("/") || filename.includes("\\")
+        || /^[a-zA-Z]:/.test(filename)) {
+        throw new Error("Invalid " + label + " path: " + filename);
+    }
+    const segments = filename.split("/");
+    if (segments.some(segment => segment.length === 0 || segment === "." || segment === "..")) {
+        throw new Error("Invalid " + label + " path: " + filename);
+    }
+    return segments.join("/");
+}
+function validatePaths(filenames, label) {
+    const paths = new Map();
+    for (const filename of filenames) {
+        if (typeof filename !== "string") {
+            throw new Error("Invalid " + label + " path");
+        }
+        const relative = normalizeRelative(filename, label);
+        const key = relative.toLowerCase();
+        if (key === MANIFEST || key.startsWith(MANIFEST + "/")) {
+            throw new Error("Reserved " + label + " path: " + relative);
+        }
+        const existing = paths.get(key);
+        if (existing !== undefined) {
+            throw new Error("Conflicting " + label + " paths: " + existing + " and " + relative);
+        }
+        paths.set(key, relative);
+    }
+    for (const filename of paths.values()) {
+        const segments = filename.split("/");
+        for (let index = 1; index < segments.length; index++) {
+            if (paths.has(segments.slice(0, index).join("/").toLowerCase())) {
+                throw new Error("Conflicting " + label + " file and directory paths: " + filename);
+            }
+        }
+    }
+    return [...paths.values()];
+}
+function validateArtifactPaths(artifacts) {
+    const paths = validatePaths(artifacts.map(artifact => artifact.path.replace(/\\/g, "/")), "output");
+    return artifacts.map((artifact, index) => ({
+        ...artifact,
+        relative: paths[index],
+        byteLength: Buffer.byteLength(artifact.contents, file_operations_1.FileOperations.isBinaryFilename(paths[index]) ? "latin1" : "utf8"),
+        binary: file_operations_1.FileOperations.isBinaryFilename(paths[index]),
+    }));
+}
+function parseManifest(contents) {
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch (error) {
+        throw new Error("Invalid incremental output manifest JSON: " + String(error));
+    }
+    if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || !("files" in parsed)
+        || parsed.version !== 1 || !Array.isArray(parsed.files)) {
+        throw new Error("Unsupported incremental output manifest");
+    }
+    return { version: 1, files: validatePaths(parsed.files, "incremental output manifest") };
+}
+function serializeManifest(files) {
+    return JSON.stringify({ version: 1, files: [...files].sort() }, null, 2) + "\n";
+}
+async function lstatOrMissing(filename) {
+    try {
+        return await fsPromises.lstat(filename);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function isBelowRoot(root, filename) {
+    const relative = path.relative(root, filename);
+    return relative !== "" && relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative);
+}
+async function inspectPaths(root, relativePaths, rootStats, ioConcurrency) {
+    const metadata = new Map();
+    const nodes = new Map();
+    for (const filename of relativePaths) {
+        const segments = filename.split("/");
+        for (let index = 1; index <= segments.length; index++) {
+            const relative = segments.slice(0, index).join("/");
+            const isDirectory = index < segments.length;
+            nodes.set(relative, (nodes.get(relative) ?? false) || isDirectory);
+        }
+    }
+    if (rootStats !== undefined) {
+        const byDepth = new Map();
+        for (const relative of nodes.keys()) {
+            const depth = relative.split("/").length;
+            const group = byDepth.get(depth) ?? [];
+            group.push(relative);
+            byDepth.set(depth, group);
+        }
+        for (const depth of [...byDepth.keys()].sort((a, b) => a - b)) {
+            const candidates = byDepth.get(depth).filter(relative => {
+                const parent = path.posix.dirname(relative);
+                return depth === 1 || metadata.get(parent)?.isDirectory() === true;
+            });
+            await forEachLimit(candidates, async (relative) => {
+                const absolute = path.resolve(root, ...relative.split("/"));
+                const stat = await lstatOrMissing(absolute);
+                if (stat?.isSymbolicLink()) {
+                    throw new Error("Output path must not traverse a symlink: " + relative);
+                }
+                if (stat !== undefined && nodes.get(relative) === true && !stat.isDirectory()) {
+                    throw new Error("Output path parent is not a directory: " + relative);
+                }
+                if (stat !== undefined && nodes.get(relative) === false && !stat.isFile()) {
+                    throw new Error("Generated output path is not a regular file: " + relative);
+                }
+                metadata.set(relative, stat);
+            }, ioConcurrency);
+        }
+    }
+    else {
+        for (const relative of nodes.keys()) {
+            metadata.set(relative, undefined);
+        }
+    }
+    return metadata;
+}
+async function atomicWriteManifest(root, contents, current) {
+    if (current === contents) {
+        return;
+    }
+    await fsPromises.mkdir(root, { recursive: true });
+    const temporary = path.join(root, MANIFEST + ".tmp-" + process.pid + "-" + Math.random().toString(36).slice(2));
+    try {
+        await fsPromises.writeFile(temporary, contents, { flag: "wx", encoding: "utf8" });
+        await fsPromises.rename(temporary, path.join(root, MANIFEST));
+    }
+    catch (error) {
+        try {
+            await fsPromises.unlink(temporary);
+        }
+        catch {
+            // The temporary file can be absent when creation failed.
+        }
+        throw error;
+    }
+}
+async function writeOutput(rootFolder, artifacts, incremental, ioConcurrency = concurrency()) {
+    const root = path.resolve(rootFolder);
+    const prepared = validateArtifactPaths(artifacts);
+    const result = {
+        created: 0, updated: 0, unchanged: 0, deleted: 0,
+    };
+    if (!incremental) {
+        const files = prepared.map(file => ({ path: path.resolve(root, file.relative), contents: file.contents }));
+        await file_operations_1.FileOperations.writeFiles(files);
+        result.updated = files.length;
+        return result;
+    }
+    const manifestPath = path.join(root, MANIFEST);
+    const rootStats = await lstatOrMissing(root);
+    if (rootStats?.isSymbolicLink()) {
+        throw new Error("Output folder must not be a symlink: " + root);
+    }
+    if (rootStats !== undefined && !rootStats.isDirectory()) {
+        throw new Error("Output folder is not a directory: " + root);
+    }
+    let manifestContents;
+    let previous = [];
+    if (rootStats !== undefined) {
+        const manifestStat = await lstatOrMissing(manifestPath);
+        if (manifestStat?.isSymbolicLink() || (manifestStat !== undefined && !manifestStat.isFile())) {
+            throw new Error("Incremental output manifest must be a regular file");
+        }
+        if (manifestStat !== undefined) {
+            const contents = await fsPromises.readFile(manifestPath, "utf8");
+            manifestContents = contents;
+            previous = parseManifest(contents).files;
+        }
+    }
+    // A path can belong to both inventories; each inventory rejects its own duplicates.
+    validatePaths([...new Set([...prepared.map(file => file.relative), ...previous])], "incremental output");
+    const previousPaths = new Set(previous);
+    const current = new Set(prepared.map(file => file.relative));
+    const stale = previous.filter(filename => !current.has(filename));
+    const additions = prepared.some(file => !previousPaths.has(file.relative));
+    const pathsToInspect = [...new Set([...prepared.map(file => file.relative), ...stale])];
+    const metadata = await inspectPaths(root, pathsToInspect, rootStats, ioConcurrency);
+    await forEachLimit(prepared, async (file) => {
+        const stat = metadata.get(file.relative);
+        file.existed = stat !== undefined;
+        if (stat === undefined || stat.size !== file.byteLength) {
+            file.changed = true;
+            return;
+        }
+        let existing;
+        try {
+            existing = await fsPromises.readFile(path.resolve(root, ...file.relative.split("/")));
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                file.existed = false;
+                file.changed = true;
+                return;
+            }
+            throw error;
+        }
+        const generated = Buffer.from(file.contents, file.binary ? "latin1" : "utf8");
+        file.changed = !existing.equals(generated);
+    }, ioConcurrency);
+    if (additions) {
+        const union = serializeManifest(new Set([...previous, ...current]));
+        await atomicWriteManifest(root, union, manifestContents);
+        manifestContents = union;
+    }
+    const toWrite = prepared.filter(file => file.changed);
+    const directories = new Map();
+    for (const file of toWrite) {
+        const segments = file.relative.split("/");
+        for (let index = 1; index < segments.length; index++) {
+            const relative = segments.slice(0, index).join("/");
+            if (metadata.get(relative) === undefined) {
+                directories.set(relative, index);
+            }
+        }
+    }
+    const directoryDepths = [...new Set(directories.values())].sort((a, b) => a - b);
+    for (const depth of directoryDepths) {
+        const atDepth = [...directories.entries()].filter(([, candidateDepth]) => candidateDepth === depth)
+            .map(([relative]) => path.resolve(root, ...relative.split("/")));
+        await forEachLimit(atDepth, async (directory) => {
+            await fsPromises.mkdir(directory);
+        }, ioConcurrency);
+    }
+    await forEachLimit(toWrite, async (file) => {
+        await fsPromises.writeFile(path.resolve(root, ...file.relative.split("/")), file.contents, file.binary ? { encoding: "latin1" } : undefined);
+    }, ioConcurrency);
+    const staleFiles = stale.map(filename => path.resolve(root, ...filename.split("/")));
+    const removedDirectories = new Set();
+    for (const filename of staleFiles) {
+        try {
+            await fsPromises.unlink(filename);
+            result.deleted++;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        let directory = path.dirname(filename);
+        while (isBelowRoot(root, directory)) {
+            removedDirectories.add(directory);
+            directory = path.dirname(directory);
+        }
+    }
+    await forEachLimit([...removedDirectories].sort((a, b) => b.length - a.length), async (directory) => {
+        try {
+            await fsPromises.rmdir(directory);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST") {
+                throw error;
+            }
+        }
+    });
+    const finalManifest = serializeManifest(current);
+    await atomicWriteManifest(root, finalManifest, manifestContents);
+    result.created = prepared.filter(file => file.changed && !file.existed).length;
+    result.updated = prepared.filter(file => file.changed && file.existed).length;
+    result.unchanged = prepared.filter(file => !file.changed).length;
+    return result;
+}
+//# sourceMappingURL=output_writer.js.map
+
+/***/ },
+
 /***/ "./build/write_objects.js"
 /*!********************************!*\
   !*** ./build/write_objects.js ***!
@@ -646,28 +1000,16 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.writeObjects = writeObjects;
+exports.collectObjectFiles = collectObjectFiles;
 const path = __importStar(__webpack_require__(/*! path */ "path"));
 const url_1 = __webpack_require__(/*! url */ "url");
 const transpiler_1 = __webpack_require__(/*! @abaplint/transpiler */ "./node_modules/@abaplint/transpiler/build/src/index.js");
-const file_operations_1 = __webpack_require__(/*! ./file_operations */ "./build/file_operations.js");
-async function writeObjects(outputFiles, config, files) {
+function collectObjectFiles(outputFiles, config, files) {
     const root = path.resolve(config.output_folder);
     const filesToWrite = [];
-    const destinations = new Set();
     const sources = new Map(files.map(file => [file.filename.toLowerCase(), file]));
     const add = (filename, contents) => {
-        const target = path.resolve(root, filename);
-        const relative = path.relative(root, target);
-        if (relative === "" || relative.startsWith(".." + path.sep) || relative === ".." || path.isAbsolute(relative)) {
-            throw new Error("Output file escapes output_folder: " + filename);
-        }
-        const key = target.toLowerCase();
-        if (destinations.has(key)) {
-            throw new Error("Conflicting output file: " + filename);
-        }
-        destinations.add(key);
-        filesToWrite.push({ path: target, contents });
+        filesToWrite.push({ path: filename.replace(/\\/g, "/"), contents });
     };
     for (const output of outputFiles) {
         const type = output.object.type.toUpperCase();
@@ -688,21 +1030,24 @@ async function writeObjects(outputFiles, config, files) {
                 if (file === undefined) {
                     continue;
                 }
-                if (file.relative !== undefined) {
+                if (file.sourceMapPath !== undefined) {
+                    sourcePaths[filename] = file.sourceMapPath;
+                }
+                else if (file.relative !== undefined) {
                     const source = path.resolve(root, file.relative, file.filename);
                     const relative = path.relative(mapDirectory, source);
                     // Sources on another Windows drive cannot be expressed as relative paths.
                     sourcePaths[filename] = path.isAbsolute(relative) ? (0, url_1.pathToFileURL)(source).href
                         : relative.split(path.sep).map(segment => encodeURIComponent(segment)).join("/");
                 }
-                // Include sources for local and cloned libraries; clones are removed before emission.
+                // Embedding source text keeps maps useful after temporary checkouts are removed.
                 sourceContents[filename] = file.contents;
             }
             add(name, output.chunk.getMap(path.basename(output.filename), { generatedLineOffset, sourcePaths, sourceContents }));
         }
         add(output.filename, contents);
     }
-    await file_operations_1.FileOperations.writeFiles(filesToWrite);
+    return filesToWrite;
 }
 //# sourceMappingURL=write_objects.js.map
 
@@ -127819,6 +128164,11 @@ run().then(() => {
                         }
                         methods.push(m.name);
                     }
+                    if (methods.length === 0) {
+                        // FOR TESTING helper class without test methods, nothing to run; it might also
+                        // live in locals_imp, which is not exported from the .testclasses module
+                        continue;
+                    }
                     tests.push({
                         obj,
                         filename: `${(0, output_layout_1.importPath)("index.mjs", this.layout.objectModule(obj, ".testclasses"))}`,

package/build/types.d.ts

@@ -12,6 +12,8 @@ export interface ITranspilerConfig {
     exclude_filter?: string[];
     /** @minLength 1 */
     output_folder: string;
+    /** Skip unchanged generated files and remove tracked obsolete output */
+    incremental_output?: boolean;
     /** experimental */
     converter?: {
         /** @uniqueItems true */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler-cli",
-  "version": "2.14.1",
+  "version": "2.14.2",
   "description": "Transpiler - Command Line Interface",
   "funding": "https://github.com/sponsors/larshp",
   "bin": {
@@ -28,7 +28,7 @@
   "license": "MIT",
   "devDependencies": {
     "@abaplint/core": "^2.120.71",
-    "@abaplint/transpiler": "^2.14.1",
+    "@abaplint/transpiler": "^2.14.2",
     "@types/glob": "^9.0.0",
     "@types/node": "^26.6.2",
     "@types/progress": "^2.0.7",