@ui5/task-adaptation 1.6.5-rc.2 → 1.6.5-rc.4

package/dist/repositories/html5Repository.js

@@ -18,31 +18,21 @@ export default class HTML5Repository {
         this.configuration = configuration;
         this.validator.validateConfiguration(configuration);
     }
-    async getAppVariantIdHierarchy(appId) {
-        const metadata = await this.getMetadata();
+    async getAppVariantIdHierarchy(_appId) {
+        const { appName, appVersion, appHostId } = this.configuration;
+        if (!appName || !appVersion || !appHostId) {
+            throw new Error("Missing required configuration properties appName, appVersion or appHostId");
+        }
         return [{
-                repoName: this.configuration.appName,
-                appVariantId: appId,
-                cachebusterToken: metadata.changedOn
+                appName,
+                cacheBusterToken: this.getMetadata().then(metadata => metadata.changedOn),
+                appVersion,
+                appHostId,
             }];
     }
-    async fetch(_repoName, _cachebusterToken) {
+    async fetch(resource) {
         const { token, baseUri } = await this.getHtml5RepoInfo();
-        const appData = {
-            appName: this.configuration.appName,
-            appVersion: this.configuration.appVersion,
-            appHostId: this.configuration.appHostId
-        };
-        return this.getAppZipEntries(appData, baseUri, token);
-    }
-    async fetchReuseLib(_libName, _cachebusterToken, lib) {
-        const { token, baseUri } = await this.getHtml5RepoInfo();
-        const libAppData = {
-            appName: lib.html5AppName,
-            appVersion: lib.html5AppVersion,
-            appHostId: lib.html5AppHostId
-        };
-        return this.getAppZipEntries(libAppData, baseUri, token);
+        return this.getAppZipEntries(resource, baseUri, token);
     }
     async getMetadata() {
         const { token, baseUri } = await this.getHtml5RepoInfo();
@@ -66,17 +56,17 @@ export default class HTML5Repository {
     async getHTML5Credentials(spaceGuid) {
         log.verbose("Getting HTML5 Repo Runtime credentials from space " + spaceGuid);
         const PLAN_NAME = "app-runtime";
-        const SERVIСE_INSTANCE_NAME = "html5-apps-repo-runtime";
+        const SERVICE_INSTANCE_NAME = "html5-apps-repo-runtime";
         const getParams = {
             spaceGuids: [spaceGuid],
             planNames: [PLAN_NAME],
-            names: [SERVIСE_INSTANCE_NAME]
+            names: [SERVICE_INSTANCE_NAME]
         };
         const createParams = {
             spaceGuid,
             planName: PLAN_NAME,
             serviceName: "html5-apps-repo",
-            serviceInstanceName: SERVIСE_INSTANCE_NAME,
+            serviceInstanceName: SERVICE_INSTANCE_NAME,
             tags: ["html5-apps-repo-rt"]
         };
         const serviceKeys = await CFUtil.getServiceInstanceKeys(getParams, createParams);
@@ -107,9 +97,10 @@ export default class HTML5Repository {
         const metadata = await RequestUtil.get(uri, requestOptions);
         return metadata.find((item) => item.appHostId === appHostId && item.applicationName === appName && item.applicationVersion === appVersion);
     }
-    async getAppZipEntries(app, html5RepoBaseUri, token) {
-        const uri = `${html5RepoBaseUri}/applications/content/${app.appName}-${app.appVersion}/`;
-        const zip = await this.download(token, app.appHostId, uri);
+    async getAppZipEntries(resource, html5RepoBaseUri, token) {
+        const { appName, appVersion, appHostId } = resource;
+        const uri = `${html5RepoBaseUri}/applications/content/${appName}-${appVersion}/`;
+        const zip = await this.download(token, appHostId, uri);
         return unzipZipEntries(zip);
     }
     async download(token, appHostId, uri) {
@@ -133,7 +124,4 @@ export default class HTML5Repository {
 __decorate([
     cached()
 ], HTML5Repository.prototype, "fetch", null);
-__decorate([
-    cached()
-], HTML5Repository.prototype, "fetchReuseLib", null);
 //# sourceMappingURL=html5Repository.js.map

package/dist/repositories/localRepository.d.ts

@@ -1,16 +1,12 @@
-import { IAppVariantIdHierarchyItem } from "../model/appVariantIdHierarchyItem.js";
-import { IConfiguration } from "../model/configuration.js";
-import { IReuseLibInfo } from "../model/types.js";
 import IRepository from "./repository.js";
+import ICachedResource from "../cache/cachedResource.js";
+export interface ILocalResource extends ICachedResource {
+    absolutePath: string;
+}
 export default class LocalRepository implements IRepository {
-    private configuration;
-    constructor(configuration: IConfiguration);
     downloadAnnotationFile(_uri: string): Promise<Map<string, string>>;
-    getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
-    fetch(appId: string, cachebusterToken: string): Promise<Map<string, string>>;
-    fetchReuseLib(libName: string, cachebusterToken: string, _lib: IReuseLibInfo): Promise<Map<string, string>>;
-    private collectAppVariantIdHierarchyItems;
-    private getExistingManifestPath;
-    private readFilesInBaseAppDir;
-    private getLocalFilesDirectory;
+    getAppVariantIdHierarchy(appId: string): Promise<ILocalResource[]>;
+    fetch(resource: ILocalResource): Promise<Map<string, Buffer>>;
+    private buildManifestIndex;
+    private getLocalFilesDir;
 }

package/dist/repositories/localRepository.js

@@ -1,67 +1,77 @@
 import { getLogger } from "@ui5/logger";
 import path from "node:path";
 import fs from "node:fs/promises";
+import { glob } from "glob";
 import FsUtil from "../util/fsUtil.js";
 const log = getLogger("@ui5/task-adaptation::LocalRepository");
 export default class LocalRepository {
-    configuration;
-    constructor(configuration) {
-        this.configuration = configuration;
-    }
     async downloadAnnotationFile(_uri) {
         log.verbose("Downloading annotation files is not supported in LocalRepository.");
         return new Map();
     }
     async getAppVariantIdHierarchy(appId) {
         const items = [];
-        await this.collectAppVariantIdHierarchyItems(appId, items);
+        const baseDir = this.getLocalFilesDir();
+        const index = await this.buildManifestIndex(baseDir);
+        const visited = new Set();
+        let currentAppId = appId;
+        while (currentAppId) {
+            if (visited.has(currentAppId)) {
+                throw new Error(`Cycle detected in app variant hierarchy: '${currentAppId}' was already visited. Visited IDs: ${[...visited].join(" -> ")} -> ${currentAppId}`);
+            }
+            visited.add(currentAppId);
+            const entry = index.get(currentAppId);
+            if (!entry) {
+                throw new Error(`App '${currentAppId}' not found in local directory '${baseDir}'.`);
+            }
+            items.push({
+                appName: currentAppId,
+                cacheBusterToken: Promise.resolve("local"),
+                absolutePath: entry.absolutePath,
+            });
+            if (entry.isVariant) {
+                if (!entry.reference || typeof entry.reference !== "string") {
+                    throw new Error(`Invalid or missing 'reference' for app variant '${currentAppId}': expected a non-empty string but got '${entry.reference}'`);
+                }
+                currentAppId = entry.reference;
+            }
+            else {
+                currentAppId = undefined;
+            }
+        }
         return items;
     }
-    fetch(appId, cachebusterToken) {
-        return this.readFilesInBaseAppDir(appId, cachebusterToken);
-    }
-    fetchReuseLib(libName, cachebusterToken, _lib) {
-        return this.readFilesInBaseAppDir(libName, cachebusterToken);
+    fetch(resource) {
+        log.verbose(`Fetching base app files from local directory: ${resource.absolutePath}`);
+        return FsUtil.readFilesRecursively(resource.absolutePath);
     }
-    async collectAppVariantIdHierarchyItems(appId, items) {
-        const appDir = this.getLocalFilesDirectory(appId);
-        const filenames = [
-            ["manifest.json"],
-            ["manifest.appdescr_variant"],
-            ["webapp", "manifest.json"],
-            ["webapp", "manifest.appdescr_variant"],
-        ];
-        const filepaths = filenames.map((filename) => path.join(appDir, ...filename));
-        const existingManifestPath = await this.getExistingManifestPath(filepaths);
-        items.push({
-            appVariantId: appId,
-            repoName: appId,
-            cachebusterToken: path.dirname(existingManifestPath)
-        });
-        if (existingManifestPath.endsWith("manifest.appdescr_variant")) {
-            const manifestContent = await fs.readFile(existingManifestPath, "utf-8");
-            const manifest = JSON.parse(manifestContent);
-            await this.collectAppVariantIdHierarchyItems(manifest.reference, items);
+    async buildManifestIndex(baseDir) {
+        const index = new Map();
+        const manifestPaths = await glob("**/manifest.{json,appdescr_variant}", { cwd: baseDir, absolute: true, dot: true });
+        for (const manifestPath of manifestPaths) {
+            const content = await fs.readFile(manifestPath, "utf-8");
+            const manifest = JSON.parse(content);
+            const isVariant = manifestPath.endsWith("manifest.appdescr_variant");
+            const id = isVariant ? manifest.id : manifest["sap.app"]?.id;
+            if (typeof id === "string" && id) {
+                index.set(id, {
+                    absolutePath: path.dirname(manifestPath),
+                    reference: manifest.reference,
+                    isVariant,
+                });
+            }
         }
+        return index;
     }
-    async getExistingManifestPath(filePaths) {
-        const existenceChecks = await Promise.all(filePaths.map((filePath) => FsUtil.exists(filePath)));
-        const existingIndex = existenceChecks.findIndex((exists) => exists);
-        if (existingIndex !== -1) {
-            return filePaths[existingIndex];
+    getLocalFilesDir() {
+        const adpDirConfigured = process.env.ADP_BUILDER_DIR;
+        if (adpDirConfigured && path.isAbsolute(adpDirConfigured)) {
+            return path.normalize(adpDirConfigured);
         }
-        throw new Error(`None of the paths exist: '${filePaths.join("', '")}'.`);
-    }
-    readFilesInBaseAppDir(_appId, cachebusterToken) {
-        log.verbose(`Fetching base app files from local directory: ${cachebusterToken}`);
-        return FsUtil.readFilesRecursively(cachebusterToken);
-    }
-    getLocalFilesDirectory(appId) {
-        const adpDirConfigured = process.env.ADP_BUILDER_DIR || this.configuration.adpDir;
         const adpDir = adpDirConfigured
             ? path.normalize(adpDirConfigured).replace(/\\/g, "/").replace(/\/+$/, "").split("/")
             : [".."];
-        return path.join(process.cwd(), ...adpDir, appId);
+        return path.join(process.cwd(), ...adpDir);
     }
 }
 //# sourceMappingURL=localRepository.js.map

package/dist/repositories/repository.d.ts

@@ -1,8 +1,6 @@
-import { IAppVariantIdHierarchyItem } from "../model/appVariantIdHierarchyItem.js";
-import { IReuseLibInfo } from "../model/types.js";
+import ICachedResource from "../cache/cachedResource.js";
 export default interface IRepository {
-    getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
-    fetch(repoName: string, cachebusterToken: string): Promise<Map<string, string>>;
-    fetchReuseLib(libName: string, cachebusterToken: string, lib: IReuseLibInfo): Promise<Map<string, string>>;
+    getAppVariantIdHierarchy(appId: string): Promise<ICachedResource[]>;
+    fetch(resource: ICachedResource): Promise<Map<string, Buffer>>;
     downloadAnnotationFile(uri: string): Promise<Map<string, string>>;
 }

package/dist/util/cf/xsAppJsonUtil.d.ts

@@ -1,4 +1,17 @@
-import { IConfiguration, ServiceCredentials } from "../../model/types.js";
+import { ServiceCredentials } from "../../model/types.js";
+export type XsApp = {
+    welcomeFile?: string;
+    authenticationMethod: "none" | "route";
+    routes: Route[];
+};
+export type Route = {
+    source: string;
+    target: string;
+    service?: string;
+    destination?: string;
+    authenticationType?: string;
+    localDir?: string;
+};
 export declare const XSAPP_JSON_FILENAME = "xs-app.json";
 /**
  * Merges multiple xs-app.json contents into one. AppVariant and Reuse Library
@@ -10,5 +23,5 @@ export declare const XSAPP_JSON_FILENAME = "xs-app.json";
  */
 export declare function merge(xsAppFiles: string[]): string | undefined;
 export declare function enhanceRoutesWithEndpointAndService(xsAppJsonContent: string, serviceCredentials: ServiceCredentials): string;
-export declare function enhanceRoutes(serviceCredentials: ServiceCredentials, baseRoutes: any): any;
-export declare function fetchCredentialsAndEnhanceRoutes(xsAppJson: string, { serviceInstanceName, space, appName }: IConfiguration): Promise<string>;
+export declare function enhanceRoutes(serviceCredentials: ServiceCredentials, baseRoutes: Route[]): Route[];
+export declare function fetchCredentialsAndEnhanceRoutes(xsAppJson: string, serviceCredentialsPromise: Promise<ServiceCredentials | undefined>): Promise<string>;

package/dist/util/cf/xsAppJsonUtil.js

@@ -1,5 +1,4 @@
 import { getLogger } from "@ui5/logger";
-import CFUtil from "../cfUtil.js";
 const log = getLogger("@ui5/task-adaptation::XSAppJsonUtil");
 export const XSAPP_JSON_FILENAME = "xs-app.json";
 /**
@@ -63,7 +62,7 @@ export function enhanceRoutes(serviceCredentials, baseRoutes) {
         return acc;
     }, {});
     return baseRoutes.map((route) => {
-        const endpointName = destinationToEndpoint[route.destination];
+        const endpointName = route.destination && destinationToEndpoint[route.destination];
         if (endpointName) {
             // There is a matching endpoint: remove destination and add endpoint/service
             const { destination: _destination, ...rest } = route;
@@ -79,22 +78,12 @@ export function enhanceRoutes(serviceCredentials, baseRoutes) {
         }
     });
 }
-export async function fetchCredentialsAndEnhanceRoutes(xsAppJson, { serviceInstanceName, space, appName }) {
-    if (!serviceInstanceName) {
-        throw new Error(`Service instance name must be specified in ui5.yaml configuration for app '${appName}'`);
+export async function fetchCredentialsAndEnhanceRoutes(xsAppJson, serviceCredentialsPromise) {
+    const serviceCredentials = await serviceCredentialsPromise;
+    if (!serviceCredentials) {
+        log.verbose(`No service credentials available. Skipping xs-app.json update.`);
+        return xsAppJson;
     }
-    let serviceCredentials;
-    try {
-        // Get valid service keys with proper endpoints structure
-        serviceCredentials = await CFUtil.getOrCreateServiceKeyWithEndpoints(serviceInstanceName, space);
-    }
-    catch (error) {
-        throw new Error(`Failed to get valid service keys for app '${appName}': ${error.message}`);
-    }
-    if (serviceCredentials) {
-        return enhanceRoutesWithEndpointAndService(xsAppJson, serviceCredentials);
-    }
-    log.info(`No endpoints found for app '${appName}'. xs-app.json will not be updated.`);
-    return xsAppJson;
+    return enhanceRoutesWithEndpointAndService(xsAppJson, serviceCredentials);
 }
 //# sourceMappingURL=xsAppJsonUtil.js.map

package/dist/util/commonUtil.d.ts

@@ -1,5 +1,6 @@
 import { IConfiguration } from "../model/types.js";
 import Language from "../model/language.js";
+import AppVariant from "../appVariant.js";
 export declare function dotToUnderscore(value: string): string;
 export declare function validateConfiguration<T extends object>(options: T, properties: Array<keyof T>): void;
 export declare function validateObject<T extends object>(options: T, properties: Array<keyof T>, message: string): void;
@@ -12,3 +13,8 @@ export declare function logBuilderVersion(): void;
 export declare function logBetaUsage(): void;
 export declare function getUniqueName(existingNames: string[], template: string): string;
 export declare function isManifestChange(filename: string, content: string): boolean;
+/**
+ * 4p. Reference map contains searchTerm as key and replacement as value. Base
+ * id and app variant ids are renamed to adaptation project id.
+ */
+export declare function getReferences(appVariants: AppVariant[], adaptationProjectId: string): Map<string, string>;

package/dist/util/commonUtil.js

@@ -98,4 +98,21 @@ export function isManifestChange(filename, content) {
     }
     return false;
 }
+/**
+ * 4p. Reference map contains searchTerm as key and replacement as value. Base
+ * id and app variant ids are renamed to adaptation project id.
+ */
+export function getReferences(appVariants, adaptationProjectId) {
+    const references = new Map();
+    appVariants.forEach((variant, i) => {
+        if (i === 0) {
+            references.set(variant.reference, adaptationProjectId);
+        }
+        if (variant.id !== adaptationProjectId) {
+            references.set(variant.id, adaptationProjectId);
+        }
+        variant.getRenamingForMovedFiles().forEach((value, key) => references.set(key, value));
+    });
+    return references;
+}
 //# sourceMappingURL=commonUtil.js.map

package/dist/util/fsUtil.d.ts

@@ -1,11 +1,10 @@
 export default class FsUtil {
-    static readInProject(filepath: string): Promise<string>;
+    static readInProject(filepath: string, encoding?: BufferEncoding): Promise<Buffer | string>;
     /**
      * Check whether a file or directory exists (non-throwing).
      * @param filePath Absolute or relative path
      * @returns true if the path exists, false if not
      */
     private static fileExists;
-    static readFilesRecursively(rootDirectory: string): Promise<Map<string, string>>;
-    static exists(filePath: string): Promise<boolean>;
+    static readFilesRecursively(rootDirectory: string): Promise<Map<string, Buffer>>;
 }

package/dist/util/fsUtil.js

@@ -7,9 +7,9 @@ export default class FsUtil {
      * @param filepath The relative file path from the project root (e.g. 'ui5AppInfo.json').
      * @returns A promise that resolves to the file content as a string.
      */
-    static async readInProject(filepath) {
+    static async readInProject(filepath, encoding) {
         try {
-            return await fs.readFile(path.join(process.cwd(), filepath), "utf-8");
+            return await fs.readFile(path.join(process.cwd(), filepath), encoding);
         }
         catch (error) {
             const isProjectRoot = await FsUtil.fileExists(path.join(process.cwd(), "ui5.yaml"));
@@ -37,38 +37,17 @@ export default class FsUtil {
         }
     }
     static async readFilesRecursively(rootDirectory) {
-        const directoriesToScan = [rootDirectory];
-        const fileReadTasks = [];
-        while (directoriesToScan.length > 0) {
-            const currentDirectory = directoriesToScan.pop();
-            if (!currentDirectory) {
-                continue;
-            }
-            const entries = await fs.readdir(currentDirectory, { withFileTypes: true });
-            for (const entry of entries) {
-                const entryPath = path.join(currentDirectory, entry.name);
-                if (entry.isDirectory()) {
-                    directoriesToScan.push(entryPath);
-                }
-                else if (entry.isFile()) {
-                    fileReadTasks.push((async () => {
-                        const relativeFilePath = path.relative(rootDirectory, entryPath);
-                        const content = await fs.readFile(entryPath, "utf-8");
-                        return [relativeFilePath, content];
-                    })());
-                }
-            }
-        }
+        const entries = await fs.readdir(rootDirectory, { withFileTypes: true, recursive: true });
+        const fileReadTasks = entries
+            .filter(entry => entry.isFile())
+            .map(async (entry) => {
+            const parentPath = entry.parentPath ?? entry.path;
+            const entryPath = path.join(parentPath, entry.name);
+            const relativeFilePath = path.relative(rootDirectory, entryPath).replaceAll("\\", "/");
+            const content = await fs.readFile(entryPath);
+            return [relativeFilePath, content];
+        });
         return new Map(await Promise.all(fileReadTasks));
     }
-    static async exists(filePath) {
-        try {
-            await fs.access(filePath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
 }
 //# sourceMappingURL=fsUtil.js.map

package/dist/util/renamingUtil.js

@@ -14,98 +14,66 @@ export function renameMap(content, references, ignoreInStrings) {
     if (ignoredReferenceKeys.length > 0) {
         log.info(`Ignored renaming: ${ignoredReferenceKeys.join(", ")}`);
     }
-    const searchTerms = [...references.keys()];
+    const searchTerms = [...references.keys()].filter(key => key.length > 0);
     if (!content || !searchTerms || searchTerms.length === 0) {
         return content;
     }
-    const dotToSlash = (str) => str.replaceAll(".", "\/");
-    // We don't want to replace in adaptation project ids
-    ignoreInStrings.push(...ignoreInStrings, ...ignoreInStrings.map(dotToSlash));
-    let start = 0;
-    while (true) {
-        // If we don't replace some strings in the content - we find all of them
-        // and then don't replace inside their start and end indices.
-        const ignoredStrings = ignoreInStrings.map(string => {
-            return findAllOccurrences(content, string, start).map(i => ({ start: i, end: i + string.length }));
-        }).filter(arr => arr.length > 0) || [];
-        // We find the next search index with dots and slashes. Then we replace
-        // the nearest one and start search again in the next loop step.
-        const indices = new Array();
-        for (const searchTerm of searchTerms) {
-            const searchTermSlash = dotToSlash(searchTerm);
-            indices.push({
-                i: content.indexOf(searchTerm, start),
-                replacement: references.get(searchTerm),
-                searchTerm
-            }, {
-                i: content.indexOf(searchTermSlash, start),
-                replacement: dotToSlash(references.get(searchTerm)),
-                searchTerm: searchTermSlash
-            });
+    const dotToSlash = (str) => str.replaceAll(".", "/");
+    const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    // Build replacement lookup: pattern → replacement string (both dot and slash variants).
+    // Empty keys are skipped to avoid infinite zero-width regex matches.
+    const replacementMap = new Map();
+    for (const term of searchTerms) {
+        if (!term) {
+            continue;
         }
-        const found = indices.filter(({ i }) => i > -1);
-        if (found.length === 0) {
-            return content;
+        const repl = references.get(term);
+        replacementMap.set(term, repl);
+        const slashTerm = dotToSlash(term);
+        if (slashTerm !== term) {
+            replacementMap.set(slashTerm, dotToSlash(repl));
         }
-        const inBetween = (intervals, i) => {
-            for (const interval of intervals) {
-                for (const { start, end } of interval) {
-                    if (i >= start && i <= end) {
-                        return { start, end };
-                    }
-                }
-            }
-        };
-        // If we found two strings with the same index, we take the longest one
-        // to replace, e.g.: app.variant and app.variant2 has the same index,
-        // but we don't want to replace the first one with customer.app.variant,
-        // otherwise we get customer.app.variant2, which we don't need. We need
-        // to replace the whole app.variant2 with customer.app.variant. 
-        const findCurrentReplace = (found) => {
-            const result = new Map();
-            for (const entry of found) {
-                const existing = result.get(entry.i);
-                if (!existing || entry.searchTerm.length >= existing.searchTerm.length) {
-                    result.set(entry.i, entry);
-                }
-            }
-            return [...result.values()].sort((a, b) => a.i - b.i)[0];
-        };
-        // Ignore if search is in i18n key: replace "id" in "{{id.key}}" with
-        // "customer.id" and we need only the next one in string
-        found.forEach(index => index.inBetween = inBetween(ignoredStrings, index.i));
-        // There might be a situation when we found something in ignored
-        // substrings and the index could be the nearest, but after that the
-        // next index might be the actual find to replace, so we first of all
-        // ignore all the ignored substring findings and get the next actual
-        // replacement. But if there are only ignored substrings found, we take
-        // the first one just to skip it and go further.
-        const currentReplace = findCurrentReplace(found);
-        if (currentReplace.inBetween) {
-            start = currentReplace.inBetween.end;
+    }
+    // Build deduplicated ignore set with slash variants
+    const ignoreSet = new Set();
+    for (const ignoredString of ignoreInStrings) {
+        if (ignoredString) {
+            ignoreSet.add(ignoredString);
+            ignoreSet.add(dotToSlash(ignoredString));
         }
-        else {
-            content = content.substring(0, currentReplace.i)
-                + currentReplace.replacement
-                + content.substring(currentReplace.i + currentReplace.searchTerm.length);
-            start = currentReplace.i + currentReplace.replacement.length;
+    }
+    // When a string appears in both replacementMap and ignoreSet, ignoreSet
+    // takes precedence — the match is skipped rather than replaced. Remove such
+    // keys from replacementMap so the intent is explicit instead of relying on
+    // runtime check order.
+    for (const ignored of ignoreSet) {
+        replacementMap.delete(ignored);
+    }
+    // Collect all unique patterns sorted by length descending (longest match first).
+    // V8 compiles alternation of literal strings into an Aho-Corasick automaton
+    // internally, giving us O(n + P + z) single-pass matching in native C++ code.
+    const allPatterns = new Set([...replacementMap.keys(), ...ignoreSet]);
+    const sorted = [...allPatterns].sort((a, b) => b.length - a.length);
+    const regex = new RegExp(sorted.map(escapeRegex).join("|"), "g");
+    // Single-pass: find all matches, skip ignored ones, batch-replace the rest
+    const parts = [];
+    let lastEnd = 0;
+    let m;
+    while ((m = regex.exec(content)) !== null) {
+        const matched = m[0];
+        if (ignoreSet.has(matched))
+            continue;
+        const replacement = replacementMap.get(matched);
+        if (replacement !== undefined) {
+            parts.push(content.substring(lastEnd, m.index));
+            parts.push(replacement);
+            lastEnd = m.index + matched.length;
         }
     }
+    parts.push(content.substring(lastEnd));
+    return parts.join("");
 }
 export function renameResources(files, search, replacement) {
     return new Map([...files].map(([filepath, content]) => [filepath, rename(content, search, replacement)]));
 }
-function findAllOccurrences(string, substring, start) {
-    if (!substring) {
-        return [];
-    }
-    const indices = [];
-    let index = start;
-    while ((index = string.indexOf(substring, index)) !== -1) {
-        indices.push(index);
-        index += substring.length; // shift from current finding
-    }
-    return indices;
-}
-;
 //# sourceMappingURL=renamingUtil.js.map

package/dist/util/resourceUtil.d.ts

@@ -1,14 +1,30 @@
+/**
+ * Extensions of files whose contents are processed by the adaptation
+ * pipeline as text. Anything outside this whitelist is treated as binary
+ * (e.g. images, fonts) and is saved to the workspace verbatim by WorkspaceManager.
+ *
+ * Kept in sync with EXTENSIONS_TO_PROCESS in appVariant.ts.
+ */
+export declare const TEXT_EXTENSIONS: ReadonlySet<string>;
 export default class ResourceUtil {
     static getRootFolder(projectNamespace?: string): string;
     static relativeToRoot(resourcePath: string, projectNamespace?: string): string;
     static getResourcePath(projectNamespace?: string, ...paths: string[]): string;
-    static write(dir: string, files: Map<string, string>): Promise<void[]>;
-    static writeInProject(dir: string, files: Map<string, string>): Promise<void[]>;
-    static byGlob(dir: string, pattern: string, excludes?: string[]): Promise<Map<string, string>>;
-    static byGlobInProject(pattern: string, excludes?: string[]): Promise<Map<string, string>>;
+    static write(dir: string, files: Map<string, Buffer>): Promise<void[]>;
+    static writeInProject(dir: string, files: Map<string, Buffer>): Promise<void[]>;
+    static byGlob(dir: string, pattern: string, excludes?: string[]): Promise<Map<string, Buffer>>;
+    static byGlobInProject(pattern: string, excludes?: string[]): Promise<Map<string, Buffer>>;
     static getString(resource: any): Promise<string>;
     static getJson(resource: any): Promise<any>;
     static setString(resource: any, str: string): void;
-    static createResource(filename: string, projectNamespace: string, content: string): any;
+    static createResource(filename: string, projectNamespace: string, content: string | Buffer): any;
+    private static createResourceFromContent;
     static toFileMap(resources: ReadonlyArray<Resource>, projectNamespace?: string): Promise<Map<string, string>>;
+    /**
+     * Decodes the text-extension files of a buffer map to UTF-8 strings.
+     * Binary files (e.g. images, fonts) are dropped — they are expected to
+     * have been written to the workspace separately and are not relevant
+     * to the in-memory text pipeline.
+     */
+    static toTextMap(buffers: ReadonlyMap<string, Buffer>): ReadonlyMap<string, string>;
 }