@abaplint/transpiler-cli 2.14.0 → 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"}
@@ -51,20 +52,62 @@ output/
 Names must be valid single directory names on Windows and POSIX. Names are
 unique without regard to case, and `project` is reserved. A conflicting derived
 name needs an explicit `libs[].name`. Duplicate ABAP objects across libraries
-are rejected; a project object replaces a library object of the same type/name.
+are rejected by default; a project object replaces a library object of the same type/name.
 
 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
 automatically by the CLI.
+
+## Duplicate dependencies
+
+By default, two libraries defining the same ABAP object (type and name) cause
+an `Ambiguous dependency object` error. To keep existing dependency repositories
+and skip later copies, set this top-level option in `abap_transpile.json`:
+
+```json
+{
+  "skip_duplicate_dependencies": true
+}
+```
+
+The first library in `libs` containing an object wins. Every file of that
+object in later libraries is skipped, including metadata, class locals, and
+binary assets. The CLI warns once per skipped object per library, naming the
+selected library. Imports, output folders, and source maps use the selected
+copy. Project objects still take precedence over dependencies, and shared
+`package.devc.xml` metadata keeps its existing behavior.
+
+Library order now affects generated output. Different definitions can change
+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. 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) {
@@ -340,7 +340,7 @@ async function build(config, files) {
         options.ignoreSourceMap = true;
     }
     const t = new Transpiler.Transpiler(options);
-    const { reg, folders, sources } = (0, libraries_1.libraryRegistry)(files, libraries);
+    const { reg, folders, sources } = (0, libraries_1.libraryRegistry)(files, libraries, config.skip_duplicate_dependencies);
     const output = await t.run(reg, new Progress(), folders);
     return { output, sources };
 }
@@ -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 {
@@ -559,13 +572,14 @@ async function loadLibraries(config) {
     }
     return result;
 }
-function libraryRegistry(files, libraries) {
+function libraryRegistry(files, libraries, skipDuplicateDependencies = false) {
     const reg = new abaplint.Registry();
     const folders = new Map();
     const objects = new Map();
     const sources = new Map();
     // Libraries first: addFile() then replaces a dependency object with the project's object.
     for (const lib of libraries) {
+        const skipped = new Set();
         for (const file of lib.files) {
             const memory = new abaplint.MemoryFile(file.filename, file.contents);
             const type = memory.getObjectType()?.toUpperCase();
@@ -576,6 +590,14 @@ function libraryRegistry(files, libraries) {
             const owner = objects.get(key);
             // abapGit repeats package.devc.xml across repositories; the registry keeps the last copy.
             if (key !== "DEVC:PACKAGE" && owner !== undefined && owner !== lib.name) {
+                if (skipDuplicateDependencies === true) {
+                    if (!skipped.has(key)) {
+                        console.warn("Skipping duplicate dependency object " + key + " in " + lib.name + "; using " + owner);
+                        skipped.add(key);
+                    }
+                    // Skip every file of the losing object, including locals, metadata, and binary assets.
+                    continue;
+                }
                 throw new Error("Ambiguous dependency object " + key + " in " + owner + " and " + lib.name);
             }
             objects.set(key, lib.name);
@@ -595,6 +617,347 @@ function libraryRegistry(files, libraries) {
 
 /***/ },
 
+/***/ "./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 ***!
@@ -637,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();
@@ -679,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
 
@@ -127810,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 */
@@ -33,6 +35,8 @@ export interface ITranspilerConfig {
          */
         exclude_filter?: string[];
     }[];
+    /** skip duplicate dependency objects after the first library in libs, with a warning; defaults to false */
+    skip_duplicate_dependencies?: boolean;
     write_unit_tests?: boolean;
     write_source_map?: boolean;
     options: ITranspilerOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler-cli",
-  "version": "2.14.0",
+  "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.0",
+    "@abaplint/transpiler": "^2.14.2",
     "@types/glob": "^9.0.0",
     "@types/node": "^26.6.2",
     "@types/progress": "^2.0.7",

package/schema.json

@@ -5,6 +5,35 @@
     "ITranspilerConfig": {
       "additionalProperties": false,
       "properties": {
+        "converter": {
+          "additionalProperties": false,
+          "description": "experimental",
+          "properties": {
+            "input_folder": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "items": {
+                    "type": "string"
+                  },
+                  "type": "array"
+                }
+              ],
+              "uniqueItems": true
+            },
+            "output_folder": {
+              "minLength": 1,
+              "type": "string"
+            }
+          },
+          "required": [
+            "input_folder",
+            "output_folder"
+          ],
+          "type": "object"
+        },
         "exclude_filter": {
           "description": "list of regex, case insensitive",
           "items": {
@@ -13,6 +42,10 @@
           "type": "array",
           "uniqueItems": true
         },
+        "incremental_output": {
+          "description": "Skip unchanged generated files and remove tracked obsolete output",
+          "type": "boolean"
+        },
         "input_filter": {
           "description": "list of regex, case insensitive, empty gives all files, positive list",
           "items": {
@@ -32,7 +65,8 @@
               },
               "type": "array"
             }
-          ]
+          ],
+          "uniqueItems": true
         },
         "libs": {
           "items": {
@@ -60,6 +94,12 @@
                 ]
               },
               "folder": {
+                "description": "relative to the current working directory",
+                "type": "string"
+              },
+              "name": {
+                "description": "output directory name; defaults to the repository or local folder name",
+                "minLength": 1,
                 "type": "string"
               },
               "url": {
@@ -74,8 +114,13 @@
           "$ref": "#/definitions/ITranspilerOptions"
         },
         "output_folder": {
+          "minLength": 1,
           "type": "string"
         },
+        "skip_duplicate_dependencies": {
+          "description": "skip duplicate dependency objects after the first library in libs, with a warning; defaults to false",
+          "type": "boolean"
+        },
         "write_source_map": {
           "type": "boolean"
         },