@ui5/task-adaptation 1.4.3 → 1.5.0

package/dist/processors/cfProcessor.js

@@ -1,14 +1,27 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import HTML5RepoManager from "../repositories/html5RepoManager.js";
+import { cached } from "../cache/cacheHolder.js";
 import { validateObject } from "../util/commonUtil.js";
 export default class CFProcessor {
     configuration;
-    cacheManager;
-    constructor(configuration, cacheManager) {
+    constructor(configuration) {
         this.configuration = configuration;
-        this.cacheManager = cacheManager;
     }
-    async getBaseAppFiles() {
-        return this.cacheManager.getFiles(() => HTML5RepoManager.getMetadata(this.configuration), () => HTML5RepoManager.getBaseAppFiles(this.configuration));
+    async getAppVariantIdHierarchy(appId) {
+        const metadata = await HTML5RepoManager.getMetadata(this.configuration);
+        return [{
+                repoName: this.configuration.appName,
+                appVariantId: appId,
+                cachebusterToken: metadata.changedOn
+            }];
+    }
+    fetch(_repoName, _cachebusterToken) {
+        return HTML5RepoManager.getBaseAppFiles(this.configuration);
     }
     validateConfiguration() {
         validateObject(this.configuration, ["appHostId", "appName", "appVersion"], "should be specified in ui5.yaml configuration");
@@ -16,20 +29,20 @@ export default class CFProcessor {
     async updateLandscapeSpecificContent(renamedBaseAppManifest) {
         this.updateCloudPlatform(renamedBaseAppManifest);
     }
-    updateCloudPlatform(renamedBaseAppManifest) {
-        const sapCloudService = renamedBaseAppManifest["sap.cloud"]?.service;
-        const sapPlatformCf = renamedBaseAppManifest["sap.platform.cf"];
+    updateCloudPlatform(baseAppManifest) {
+        const sapCloudService = baseAppManifest["sap.cloud"]?.service;
+        const sapPlatformCf = baseAppManifest["sap.platform.cf"];
         if (sapPlatformCf?.oAuthScopes && sapCloudService) {
             sapPlatformCf.oAuthScopes = sapPlatformCf.oAuthScopes.map((scope) => scope.replace(`$XSAPPNAME.`, `$XSAPPNAME('${sapCloudService}').`));
         }
         if (this.configuration.sapCloudService) {
-            if (renamedBaseAppManifest["sap.cloud"] == null) {
-                renamedBaseAppManifest["sap.cloud"] = {};
+            if (baseAppManifest["sap.cloud"] == null) {
+                baseAppManifest["sap.cloud"] = {};
             }
-            renamedBaseAppManifest["sap.cloud"].service = this.configuration.sapCloudService;
+            baseAppManifest["sap.cloud"].service = this.configuration.sapCloudService;
         }
         else {
-            delete renamedBaseAppManifest["sap.cloud"];
+            delete baseAppManifest["sap.cloud"];
         }
     }
     getConfigurationType() {
@@ -42,4 +55,7 @@ export default class CFProcessor {
         };
     }
 }
+__decorate([
+    cached()
+], CFProcessor.prototype, "fetch", null);
 //# sourceMappingURL=cfProcessor.js.map

package/dist/processors/processor.d.ts

@@ -1,7 +1,9 @@
+import IAppVariantIdHierarchyItem from "../model/appVariantIdHierarchyItem.js";
 import { IConfiguration } from "../model/types.js";
 export default interface IProcessor {
+    getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
+    fetch(repoName: string, cachebusterToken: string): Promise<Map<string, string>>;
     createAppVariantHierarchyItem(appVariantId: string, version: string): void;
-    getBaseAppFiles(baseAppId: string): Promise<Map<string, string>>;
-    updateLandscapeSpecificContent(renamedBaseAppManifest: any, baseAppFiles?: Map<string, string>): Promise<void>;
+    updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: ReadonlyMap<string, string>, appVariantId: string): Promise<void>;
 }
 export declare function determineProcessor(configuration: IConfiguration): IProcessor;

package/dist/processors/processor.js

@@ -1,15 +1,13 @@
 import AbapProcessor from "./abapProcessor.js";
 import AbapRepoManager from "../repositories/abapRepoManager.js";
 import AnnotationManager from "../annotationManager.js";
-import BaseAppFilesCacheManager from "../cache/baseAppFilesCacheManager.js";
 import CFProcessor from "./cfProcessor.js";
 export function determineProcessor(configuration) {
-    const cacheManager = new BaseAppFilesCacheManager(configuration);
     const abapRepoManager = new AbapRepoManager(configuration);
     const annotationManager = new AnnotationManager(configuration, abapRepoManager);
     const processors = [
-        new CFProcessor(configuration, cacheManager),
-        new AbapProcessor(configuration, cacheManager, abapRepoManager, annotationManager)
+        new CFProcessor(configuration),
+        new AbapProcessor(configuration, abapRepoManager, annotationManager)
     ];
     let processor = processors.find(processor => processor.getConfigurationType() === configuration.type);
     if (processor) {

package/dist/repositories/abapRepoManager.d.ts

@@ -1,11 +1,13 @@
 import { IConfiguration, IMetadata } from "../model/types.js";
 import AbapProvider from "./abapProvider.js";
+import IAppVariantIdHierarchyItem from "../model/appVariantIdHierarchyItem.js";
 export default class AbapRepoManager {
     private configuration;
     private abapProvider;
     constructor(configuration: IConfiguration, abapProvider?: AbapProvider);
+    getAppVariantIdHierarchy(id: string): Promise<IAppVariantIdHierarchyItem[]>;
     getAnnotationMetadata(uri: string): Promise<IMetadata>;
     downloadAnnotationFile(uri: string): Promise<Map<string, any>>;
     getMetadata(id: string): Promise<IMetadata>;
-    downloadBaseAppFiles(): Promise<Map<string, string>>;
+    fetch(repoName: string): Promise<Map<string, string>>;
 }

package/dist/repositories/abapRepoManager.js

@@ -20,6 +20,26 @@ export default class AbapRepoManager {
         this.configuration = configuration;
         this.abapProvider = abapProvider ? abapProvider : new AbapProvider();
     }
+    async getAppVariantIdHierarchy(id) {
+        const provider = await this.abapProvider.get(this.configuration);
+        const lrep = provider.getLayeredRepository();
+        const response = await lrep.get("/dta_folder/app_info", {
+            params: { id }
+        });
+        if (response.status === 200) {
+            return JSON.parse(response.data)?.appVariantIdHierarchy;
+        }
+        else if (this.configuration.appName) {
+            // Fallback to old API on old ABAP backend or CF for backward compatibility
+            const metadataResponse = await this.getMetadata(id);
+            return [{
+                    repoName: this.configuration.appName,
+                    appVariantId: id,
+                    cachebusterToken: metadataResponse.changedOn
+                }];
+        }
+        throw new Error(`App variant id hierarchy for app id '${id}' is not provided`);
+    }
     async getAnnotationMetadata(uri) {
         const provider = await this.abapProvider.get(this.configuration);
         const response = await provider.head(uri);
@@ -48,12 +68,11 @@ export default class AbapRepoManager {
             id
         };
     }
-    async downloadBaseAppFiles() {
-        const { destination, appName } = this.configuration;
-        const encodedAppName = encodeURIComponent(appName);
+    async fetch(repoName) {
+        const encodedRepoName = encodeURIComponent(repoName);
         const provider = await this.abapProvider.get(this.configuration);
         const ui5Repo = provider.getUi5AbapRepository();
-        const response = await ui5Repo.get(`/Repositories('${encodedAppName}')`, {
+        const response = await ui5Repo.get(`/Repositories('${encodedRepoName}')`, {
             params: {
                 DownloadFiles: "RUNTIME",
                 CodePage: "UTF8",
@@ -65,7 +84,7 @@ export default class AbapRepoManager {
             const buffer = Buffer.from(data.d.ZipArchive, "base64");
             return unzipZipEntries(buffer);
         }
-        throw new Error(`App '${appName}' from '${destination}' doesn't contain files`);
+        throw new Error(`App '${repoName}' doesn't contain files`);
     }
 }
 //# sourceMappingURL=abapRepoManager.js.map

package/dist/util/cfUtil.js

@@ -78,7 +78,7 @@ export default class CFUtil {
             return this.cfExecute(["create-service-key", serviceInstanceName, serviceKeyName]);
         }
         catch (error) {
-            throw new Error(`Couldn't create a service key for instance ${serviceInstanceName}: ${error.message}`);
+            throw new Error(`Couldn't create a service key for instance: ${serviceInstanceName}: ${error}`);
         }
     }
     static async getServiceInstance(params) {

package/dist/util/commonUtil.d.ts

@@ -3,11 +3,13 @@ import Language from "../model/language.js";
 export declare function dotToUnderscore(value: string): string;
 export declare function validateObject<T extends object>(options: T, properties: Array<keyof T>, message: string): void;
 export declare function escapeRegex(update: string): string;
-export declare function renameResources(files: Map<string, string>, search: string, replacement: string): Map<string, string>;
+export declare function renameResources(files: ReadonlyMap<string, string>, search: string[], replacement: string, ignoreInStrings?: string[]): Map<string, string>;
+export declare function rename(content: string, searchTerms: string[], replacement: string, ignoreInStrings?: string[]): string;
 export declare function insertInArray<T>(array: T[], index: number, insert: T): void;
 export declare function writeTempAnnotations({ writeTempFiles }: IConfiguration, name: string, language: Language, content: string): void;
-export declare function removePropertiesExtension(filePath: string): string;
+export declare function trimExtension(filePath: string): string;
 export declare function traverse(json: any, paths: string[], callback: (json: any, key: string | number, paths: string[]) => void): void;
 export declare function logBuilderVersion(): void;
 export declare function logBetaUsage(): void;
 export declare function getUniqueName(existingNames: string[], template: string): string;
+export declare function getI18nPropertyKeys(files: ReadonlyMap<string, string>): string[];

package/dist/util/commonUtil.js

@@ -17,38 +17,96 @@ export function validateObject(options, properties, message) {
 export function escapeRegex(update) {
     return update.replaceAll(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
 }
-export function renameResources(files, search, replacement) {
-    // The current regex works if the old Id is contained in the new Id, given
-    // that they do not have the same beginning.
-    // more complete alternative: /((?<!newIdStart)|(?!newIdEnd))oldId/g
-    let escapedSearch;
-    if (replacement.includes(search)) {
-        const [before] = replacement.split(search);
-        // Matches a position in the string that is not immediately preceded by
-        // the string "before". Since we won't replace anyway, we should also
-        // ignore one with the slashes.
-        const escapedBefore = escapeRegex(before).replaceAll("\\.", "[\\./]");
-        escapedSearch = `(?<!${escapedBefore})${escapeRegex(search)}`;
+export function renameResources(files, search, replacement, ignoreInStrings = []) {
+    return new Map([...files].map(([filepath, content]) => [filepath, rename(content, search, replacement, ignoreInStrings)]));
+}
+export function rename(content, searchTerms, replacement, ignoreInStrings = []) {
+    if (replacement.includes(".") && !searchTerms.some(searchTerm => searchTerm.includes("."))) {
+        throw new Error("Ambiguous reference and appVariantId: both should contains dots or both should not contain dots.");
     }
-    else {
-        escapedSearch = escapeRegex(search);
+    if (!content || !searchTerms || searchTerms.length === 0) {
+        return content;
     }
-    const dotToSlash = (update) => update.replaceAll(".", "\/");
-    const replaces = [
-        {
-            regexp: new RegExp(escapedSearch, "g"),
-            replacement
-        },
-        {
-            regexp: new RegExp(dotToSlash(escapedSearch), "g"),
-            replacement: dotToSlash(replacement)
+    const dotToSlash = (str) => str.replaceAll(".", "\/");
+    const replacementSlash = dotToSlash(replacement);
+    // We don't want to replace in adaptation project ids
+    ignoreInStrings.push(replacement);
+    ignoreInStrings.push(replacementSlash);
+    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,
+                searchTerm
+            });
+            indices.push({
+                i: content.indexOf(searchTermSlash, start),
+                replacement: replacementSlash,
+                searchTerm: searchTermSlash
+            });
         }
-    ];
-    files.forEach((content, filepath, map) => {
-        map.set(filepath, replaces.reduce((p, c) => p.replace(c.regexp, c.replacement), content));
-    });
-    return files;
+        const found = indices.filter(({ i }) => i > -1);
+        if (found.length === 0) {
+            return content;
+        }
+        const inBetween = (intervals, i) => {
+            for (const interval of intervals) {
+                for (const { start, end } of interval) {
+                    if (i >= start && i <= end) {
+                        return { start, end };
+                    }
+                }
+            }
+        };
+        const getNotEmptyArray = (a, b) => a.length > 0 ? a : b;
+        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));
+        const foundToReplace = getNotEmptyArray(found.filter(index => !index.inBetween), found);
+        const currentReplace = findCurrentReplace(foundToReplace);
+        if (currentReplace.inBetween) {
+            start = currentReplace.inBetween.end;
+        }
+        else {
+            content = content.substring(0, currentReplace.i)
+                + currentReplace.replacement
+                + content.substring(currentReplace.i + currentReplace.searchTerm.length);
+            start = currentReplace.i + currentReplace.replacement.length;
+        }
+    }
 }
+const 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;
+};
 export function insertInArray(array, index, insert) {
     array.splice(index, 0, insert);
 }
@@ -64,9 +122,8 @@ export function writeTempAnnotations({ writeTempFiles }, name, language, content
         fs.writeFileSync(path.join(TEMP_DIST_FOLDER, name + ".xml"), content);
     }
 }
-export function removePropertiesExtension(filePath) {
-    const lastIndexOf = filePath.lastIndexOf(".properties");
-    return filePath.substring(0, lastIndexOf);
+export function trimExtension(filePath) {
+    return filePath.replace(/\.[^/.]+$/, "");
 }
 export function traverse(json, paths, callback) {
     if (!json) {
@@ -101,8 +158,9 @@ export function logBuilderVersion() {
         const packageJson = fs.readFileSync(path.join(__dirname, "../../package.json"), { encoding: "utf-8" });
         const packageJsonVersion = JSON.parse(packageJson).version;
         log.info(`Running app-variant-bundler-build with version ${packageJsonVersion}`);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
     }
-    catch (_error) {
+    catch (e) {
         // do nothing
     }
 }
@@ -118,4 +176,19 @@ export function getUniqueName(existingNames, template) {
     } while (existingNames.includes(template + suffixString));
     return template + suffixString;
 }
+export function getI18nPropertyKeys(files) {
+    const keys = new Set();
+    files.forEach((content, filename) => {
+        if (filename.endsWith(".properties")) {
+            const lines = content.split("\n").filter(line => !line.startsWith("#"));
+            for (const line of lines) {
+                const [key] = line.split("=");
+                if (key) {
+                    keys.add(key);
+                }
+            }
+        }
+    });
+    return [...keys];
+}
 //# sourceMappingURL=commonUtil.js.map

package/dist/util/filesUtil.d.ts

@@ -0,0 +1,17 @@
+export default class FilesUtil {
+    static filter(files: ReadonlyMap<string, string>): ReadonlyMap<string, string>;
+    /**
+     * Renames files in the base application substituting original id with
+     * appVariant id. Renames all files except i18n properties files, when we
+     * rename property keys of nested application variants we got in the end
+     * multiple i18n properties with the same key, but different values. UI5
+     * takes the first one which is the oldest but we need the latest most
+     * recent updated one.
+     * @param files - The files of the base application.
+     * @param reference - The reference of the app variant (original/base app id).
+     * @param id - The id of the app variant.
+     * @returns A map of renamed files.
+     */
+    static rename(files: ReadonlyMap<string, string>, references: string[], adaptationProjectId: string): ReadonlyMap<string, string>;
+    private static ignore;
+}

package/dist/util/filesUtil.js

@@ -0,0 +1,49 @@
+import { rename, getI18nPropertyKeys } from "./commonUtil.js";
+import ManifestHandler from "./renamingHandlers/manifestHandler.js";
+export default class FilesUtil {
+    static filter(files) {
+        const result = new Map();
+        files.forEach((content, filename) => {
+            if (!this.ignore(filename)) {
+                result.set(filename, content);
+            }
+        });
+        return result;
+    }
+    /**
+     * Renames files in the base application substituting original id with
+     * appVariant id. Renames all files except i18n properties files, when we
+     * rename property keys of nested application variants we got in the end
+     * multiple i18n properties with the same key, but different values. UI5
+     * takes the first one which is the oldest but we need the latest most
+     * recent updated one.
+     * @param files - The files of the base application.
+     * @param reference - The reference of the app variant (original/base app id).
+     * @param id - The id of the app variant.
+     * @returns A map of renamed files.
+     */
+    static rename(files, references, adaptationProjectId) {
+        const handlers = [new ManifestHandler()];
+        const IGNORE_EXTENSIONS = [".properties"];
+        const ignoreInStrings = getI18nPropertyKeys(files);
+        const renamedFiles = new Map();
+        for (const handler of handlers) {
+            handler.before(files);
+        }
+        files.forEach((content, filename) => {
+            if (!IGNORE_EXTENSIONS.some(ext => filename.endsWith(ext))) {
+                content = rename(content, references, adaptationProjectId, ignoreInStrings);
+            }
+            renamedFiles.set(filename, content);
+        });
+        for (const handler of handlers) {
+            handler.after(renamedFiles);
+        }
+        return renamedFiles;
+    }
+    static ignore(filename) {
+        const IGNORE_FILES = ["manifest.appdescr_variant"];
+        return filename.startsWith("changes/manifest/") || IGNORE_FILES.includes(filename);
+    }
+}
+//# sourceMappingURL=filesUtil.js.map

package/dist/util/i18nMerger.d.ts

@@ -1,12 +1,19 @@
-import * as Resource from "@ui5/fs/Resource";
-import { IAppVariantInfo } from "../model/types.js";
-type Resource = typeof Resource;
-export default class I18NMerger {
-    static analyzeAppVariantManifestChanges(rootFolder: string, tranlsationRegexPattern: string, { changes }: IAppVariantInfo): {
-        mergePathsRegex: RegExp[];
-        copyPathsRegex: RegExp[];
+import AppVariant from "../appVariantManager.js";
+import { IChange } from "../model/types.js";
+export default class FileMerger {
+    static analyzeAppVariantManifestChanges(manifestChanges: ReadonlyArray<IChange>): {
+        mergePaths: RegExp[];
+        copyPaths: RegExp[];
     };
-    static mergeI18NFiles(baseAppResources: any[], appVariantResources: any[], projectNamespace: string, baseAppManifestI18NPath: string, appVariantInfo: IAppVariantInfo, taskUtil: any): Promise<(typeof Resource)[]>;
+    static merge(baseAppFiles: ReadonlyMap<string, string>, i18nPath: string, appVariant: AppVariant): Map<string, string>;
+    /**
+     * Filters out specific lines from the given string.
+     * Removes lines matching:
+     * - __ldi.translation.uuid\s*=\s*(.*)
+     * - ABAP_TRANSLATION
+     * - SAPUI5 TRANSLATION-KEY
+     */
+    private static filterTranslationMetaLines;
     /**
      *  Merge/Append base property file with property file from app variant
      * FIXME Currently merge could duplicate keys which causes undefined
@@ -16,16 +23,4 @@ export default class I18NMerger {
      * existing overwritten keys (as there should be none)
      */
     private static mergePropertiesFiles;
-    /**
-     * update the path of app variant property file so it will be copied into
-     <app_variant_id> folder
-     */
-    private static moveToAppVarSubfolder;
-    /**
-     * create new i18n file in case e.g. translation file does not exist in base
-     * app but in variant and copy of translation file is needed
-     */
-    private static createFile;
-    private static mergeFiles;
 }
-export {};

package/dist/util/i18nMerger.js

@@ -1,19 +1,18 @@
-import { dotToUnderscore, escapeRegex, removePropertiesExtension } from "./commonUtil.js";
-import ResourceUtil from "./resourceUtil.js";
+import { dotToUnderscore, escapeRegex, trimExtension } from "./commonUtil.js";
 import { posix as path } from "path";
-export default class I18NMerger {
-    static analyzeAppVariantManifestChanges(rootFolder, tranlsationRegexPattern, { changes }) {
+export default class FileMerger {
+    static analyzeAppVariantManifestChanges(manifestChanges) {
         // check which files need to be copied and which files need to be merged and copied
         // this is necessary because lrep does not support multiple enhanceWith with multiple locations
+        const TRANSLATION_REGEX_PATTERN = "((_[a-z]{2,3})?(_[a-zA-Z]{2,3}(_[a-zA-Z]{2,20})?)?)\.properties$";
         const mergePaths = new Set();
         const copyPaths = new Set();
-        changes.forEach((change) => {
+        manifestChanges.forEach((change) => {
             const i18nPathWithExtension = change.content?.bundleUrl || change.texts?.i18n;
             if (i18nPathWithExtension) {
                 // build regex to match specific + language related files
-                const i18nPath = removePropertiesExtension(i18nPathWithExtension);
-                const resourcePath = path.join(rootFolder, i18nPath);
-                const regex = new RegExp(escapeRegex(resourcePath) + tranlsationRegexPattern);
+                const i18nPath = trimExtension(i18nPathWithExtension);
+                const regex = new RegExp("^" + escapeRegex(i18nPath) + TRANSLATION_REGEX_PATTERN);
                 if (change.changeType.includes("addNewModelEnhanceWith")) {
                     copyPaths.add(regex);
                 }
@@ -22,36 +21,44 @@ export default class I18NMerger {
                 }
             }
         });
-        return { mergePathsRegex: [...mergePaths.values()], copyPathsRegex: [...copyPaths.values()] };
+        return { mergePaths: Array.from(mergePaths), copyPaths: Array.from(copyPaths) };
     }
-    static async mergeI18NFiles(baseAppResources, appVariantResources, projectNamespace, baseAppManifestI18NPath, appVariantInfo, taskUtil) {
-        const aggregatedResourceFilesMap = new Map(baseAppResources.map(baseAppResource => [baseAppResource.getPath(), baseAppResource]));
-        const i18nTargetFolder = dotToUnderscore(appVariantInfo.id);
-        const rootFolder = ResourceUtil.getRootFolder(projectNamespace);
-        const tranlsationRegexPattern = "((_[a-z]{2,3})?(_[a-zA-Z]{2,3}(_[a-zA-Z]{2,20})?)?)\.properties$";
-        const { copyPathsRegex: copyPathsValues, mergePathsRegex: mergePathsValues } = this.analyzeAppVariantManifestChanges(rootFolder, tranlsationRegexPattern, appVariantInfo);
-        for (const appVariantResource of appVariantResources) {
-            const appVariantResourcePath = appVariantResource.getPath();
-            if (appVariantResourcePath.endsWith(".properties")) {
+    static merge(baseAppFiles, i18nPath, appVariant) {
+        const i18nTargetFolder = dotToUnderscore(appVariant.id);
+        const { copyPaths, mergePaths } = this.analyzeAppVariantManifestChanges(appVariant.getProcessedManifestChanges());
+        const files = new Map(baseAppFiles);
+        for (const [filename, content] of Array.from(appVariant.files)) {
+            if (filename.endsWith(".properties")) {
                 // merge/copy logic
                 // check if file matches with regex in merge/copy
-                const mergePathMatch = mergePathsValues.map(path => appVariantResourcePath.match(path)).find(match => match);
-                const shouldMergeFile = !!mergePathMatch;
-                const shouldCopyFile = copyPathsValues.map(path => appVariantResourcePath.match(path)).find(match => match);
-                if (shouldMergeFile) {
-                    let baseAppI18NPath = `${rootFolder}/${baseAppManifestI18NPath}${mergePathMatch[1] || ""}.properties`;
-                    await this.mergePropertiesFiles(aggregatedResourceFilesMap, appVariantResource, baseAppI18NPath);
+                const mergePathMatch = mergePaths.map(path => filename.match(path)).find(match => match);
+                const copyPathMatch = copyPaths.map(path => filename.match(path)).find(match => match);
+                if (mergePathMatch) {
+                    this.mergePropertiesFiles(files, i18nPath, content, mergePathMatch[1]);
                 }
-                // Resource for to be copied file already exists so we only have to adjust path
-                // Otherwise we have to omit it. We always change the path to avoid omitting a base app file
-                this.moveToAppVarSubfolder(appVariantResource, rootFolder, i18nTargetFolder);
-                if (!shouldCopyFile) {
-                    taskUtil.setTag(appVariantResource, taskUtil.STANDARD_TAGS.OmitFromBuildResult, true);
+                if (copyPathMatch) {
+                    files.set(path.join(i18nTargetFolder, filename), content);
                 }
             }
-            aggregatedResourceFilesMap.set(appVariantResource.getPath(), appVariantResource);
+            else {
+                files.set(filename, content);
+            }
         }
-        return Array.from(aggregatedResourceFilesMap.values());
+        return files;
+    }
+    /**
+     * Filters out specific lines from the given string.
+     * Removes lines matching:
+     * - __ldi.translation.uuid\s*=\s*(.*)
+     * - ABAP_TRANSLATION
+     * - SAPUI5 TRANSLATION-KEY
+     */
+    static filterTranslationMetaLines(content) {
+        const lines = content.split('\n');
+        const filtered = lines.filter(line => !/^# __ldi\.translation\.uuid\s*=/.test(line) &&
+            !line.startsWith("# ABAP_TRANSLATION") &&
+            !line.startsWith("# SAPUI5 TRANSLATION-KEY"));
+        return filtered.join('\n');
     }
     /**
      *  Merge/Append base property file with property file from app variant
@@ -61,39 +68,14 @@ export default class I18NMerger {
      * app variant Id as prefix => If we filter on them we do not need to remove
      * existing overwritten keys (as there should be none)
      */
-    static async mergePropertiesFiles(aggregatedResourceFilesMap, variantResource, baseAppI18NPath) {
-        const baseAppI18NFile = aggregatedResourceFilesMap.get(baseAppI18NPath);
-        if (baseAppI18NFile) {
-            await this.mergeFiles(baseAppI18NFile, variantResource);
-        }
-        else {
-            // create the merge target file if it missing in base app. Maybe the language does not exist in the base app.
-            // Since the file might also be copied we do not just change the path of it but create another resource
-            await this.createFile(aggregatedResourceFilesMap, baseAppI18NPath, variantResource);
-        }
-    }
-    /**
-     * update the path of app variant property file so it will be copied into
-     <app_variant_id> folder
-     */
-    static moveToAppVarSubfolder(variantResource, rootFolder, i18nBundleName) {
-        const relativeFilePath = variantResource.getPath().substring(rootFolder.length);
-        const newResourcePath = path.join(rootFolder, i18nBundleName, relativeFilePath);
-        variantResource.setPath(newResourcePath);
-    }
-    /**
-     * create new i18n file in case e.g. translation file does not exist in base
-     * app but in variant and copy of translation file is needed
-     */
-    static async createFile(aggregatedResourceFilesMap, path, resource) {
-        const createdFile = await resource.clone();
-        createdFile.setPath(path);
-        aggregatedResourceFilesMap.set(path, createdFile);
-    }
-    static async mergeFiles(baseFile, variantFile) {
-        const variantFileContent = await variantFile.getString();
-        const mergedFileContent = await baseFile.getString();
-        baseFile.setString(`${mergedFileContent}\n\n#App variant specific text file\n\n${variantFileContent}`);
+    static mergePropertiesFiles(files, i18nPath, appVariantFileContent, language = "") {
+        const baseAppI18nPath = i18nPath + language + ".properties";
+        const baseAppFileContent = files.get(baseAppI18nPath);
+        const filteredBaseContent = baseAppFileContent ? this.filterTranslationMetaLines(baseAppFileContent) : "";
+        const content = filteredBaseContent
+            ? `${filteredBaseContent}\n\n#App variant specific text file\n\n${appVariantFileContent}`
+            : appVariantFileContent;
+        files.set(baseAppI18nPath, content);
     }
 }
 //# sourceMappingURL=i18nMerger.js.map

package/dist/util/renamingHandlers/manifestHandler.d.ts

@@ -0,0 +1,6 @@
+import { IRenamingHandler } from "./renamingHandler.js";
+export default class ManifestHandler implements IRenamingHandler {
+    private appVariantIdHierarchy;
+    before(files: ReadonlyMap<string, string>): void;
+    after(files: Map<string, string>): void;
+}