@ui5/task-adaptation 1.4.2 → 1.5.0

package/dist/util/cfUtil.js

@@ -1,4 +1,5 @@
-import { cfCreateService, cfGetInstanceCredentials, cfGetTarget } from "@sap/cf-tools/out/src/cf-local.js";
+import { cfCreateService, cfGetInstanceCredentials } from "@sap/cf-tools/out/src/cf-local.js";
+import { getSpaceGuidThrowIfUndefined } from "@sap/cf-tools/out/src/utils.js";
 import { Cli } from "@sap/cf-tools/out/src/cli.js";
 import { eFilters } from "@sap/cf-tools/out/src/types.js";
 import { getLogger } from "@ui5/logger";
@@ -34,16 +35,20 @@ export default class CFUtil {
     }
     static async createService(params) {
         log.verbose(`Creating a service instance with parameters: ${JSON.stringify(params)}`);
-        const resources = await this.requestCfApi(`/v3/service_plans?names=${params.planName}&space_guids=${params.spaceGuid}`);
-        const publicPlan = resources.find(resource => resource.visibility_type === "public");
-        if (!publicPlan) {
-            throw new Error(`Cannot find a public plan by name '${params.serviceName}' in space '${params.spaceGuid}'`);
+        const serviceOfferings = await this.requestCfApi(`/v3/service_offerings?names=${params.serviceName}`);
+        if (serviceOfferings.length === 0) {
+            throw new Error(`Cannot find a service offering by name '${params.serviceName}'`);
+        }
+        const plans = await this.requestCfApi(`/v3/service_plans?service_offering_guids=${serviceOfferings[0].guid}`);
+        const plan = plans.find(plan => plan.name === params.planName);
+        if (!plan) {
+            throw new Error(`Cannot find a plan by name '${params.planName}' for service '${params.serviceName}'`);
         }
         try {
-            await cfCreateService(publicPlan.guid, params.serviceName, params.parameters, params.tags);
+            await cfCreateService(plan.guid, params.serviceInstanceName, params.parameters, params.tags);
         }
         catch (error) {
-            throw new Error(`Cannot create a service instance '${params.serviceName}' in space '${params.spaceGuid}': ${error.message}`);
+            throw new Error(`Cannot create a service instance '${params.serviceInstanceName}' in space '${params.spaceGuid}': ${error.message}`);
         }
     }
     static async getOrCreateServiceKeys(serviceInstance) {
@@ -73,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}`);
+            throw new Error(`Couldn't create a service key for instance: ${serviceInstanceName}: ${error}`);
         }
     }
     static async getServiceInstance(params) {
@@ -92,9 +97,19 @@ export default class CFUtil {
             guid: service.guid
         }));
     }
+    static processErrors(json) {
+        if (json?.errors?.length > 0) {
+            const message = JSON.stringify(json.errors);
+            if (json?.errors?.some((e) => e.title === "CF-NotAuthenticated" || e.code === 10002)) {
+                throw new Error(`Authentication error. Use 'cf login' to authenticate in Cloud Foundry: ${message}`);
+            }
+            throw new Error(`Failed sending request to Cloud Foundry: ${message}`);
+        }
+    }
     static async requestCfApi(url) {
         const response = await this.cfExecute(["curl", url]);
         const json = this.parseJson(response);
+        this.processErrors(json);
         const resources = json?.resources;
         const totalPages = json?.pagination?.total_pages;
         if (totalPages > 1) {
@@ -105,7 +120,7 @@ export default class CFUtil {
                 return this.parseJson(response)?.resources || [];
             })).then(resources => [].concat(...resources)));
         }
-        return resources;
+        return resources ?? [];
     }
     static getOAuthToken() {
         return this.cfExecute(["oauth-token"]);
@@ -152,20 +167,9 @@ export default class CFUtil {
      * @memberof CFUtil
      */
     static async getSpaceGuid(spaceGuid) {
-        if (spaceGuid == null) {
-            const spaceName = (await cfGetTarget())?.space;
-            if (spaceName) {
-                const resources = await this.requestCfApi(`/v3/spaces?names=${spaceName}`);
-                for (const resource of resources) {
-                    spaceGuid = resource.guid;
-                    break;
-                }
-            }
-        }
-        if (spaceGuid == null) {
-            throw new Error("Please login to Cloud Foundry with 'cf login' and try again");
-        }
-        return spaceGuid;
+        return spaceGuid ?? getSpaceGuidThrowIfUndefined().catch((e) => {
+            throw new Error("Please specify space and org guids in ui5.yaml or login to Cloud Foundry with 'cf login' and try again: " + e.message);
+        });
     }
 }
 //# sourceMappingURL=cfUtil.js.map

package/dist/util/commonUtil.d.ts

@@ -1,13 +1,15 @@
 import { IConfiguration } from "../model/types.js";
 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 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,6 +158,7 @@ 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 (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;
+}

package/dist/util/renamingHandlers/manifestHandler.js

@@ -0,0 +1,20 @@
+export default class ManifestHandler {
+    appVariantIdHierarchy = [];
+    before(files) {
+        const manifest = files.get("manifest.json");
+        if (manifest) {
+            const manifestJson = JSON.parse(manifest);
+            this.appVariantIdHierarchy = manifestJson["sap.ui5"].appVariantIdHierarchy;
+        }
+    }
+    after(files) {
+        const manifest = files.get("manifest.json");
+        if (manifest) {
+            const manifestJson = JSON.parse(manifest);
+            manifestJson["sap.ui5"].appVariantIdHierarchy = this.appVariantIdHierarchy;
+            files.set("manifest.json", JSON.stringify(manifestJson));
+        }
+    }
+    ;
+}
+//# sourceMappingURL=manifestHandler.js.map

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

@@ -0,0 +1,4 @@
+export interface IRenamingHandler {
+    before(files: ReadonlyMap<string, string>): void;
+    after(files: Map<string, string>): void;
+}

package/dist/util/renamingHandlers/renamingHandler.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=renamingHandler.js.map

package/dist/util/requestUtil.d.ts

@@ -1,6 +1,7 @@
+import { AxiosRequestConfig } from "axios";
 export default class RequestUtil {
     static head(url: string): Promise<any>;
     static get(url: string, options?: any): Promise<any>;
-    static request(url: string, method: Function, options?: any): Promise<any>;
+    static request(url: string, method: (url: string, config?: AxiosRequestConfig) => any, options?: any): Promise<any>;
     private static handleError;
 }

package/dist/util/resourceUtil.d.ts

@@ -3,9 +3,11 @@ export default class ResourceUtil {
     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 read(rootFolder: string, folder: string, files: Map<string, string>, exclude?: string[]): void;
+    private static _read;
+    static read(folder: string): Map<string, string>;
     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 toFileMap(resources: ReadonlyArray<Resource>, projectNamespace: string): Promise<Map<string, string>>;
 }

package/dist/util/resourceUtil.js

@@ -29,7 +29,7 @@ export default class ResourceUtil {
         });
         return Promise.all(promises);
     }
-    static read(rootFolder, folder, files, exclude = []) {
+    static _read(rootFolder, folder, files, exclude = []) {
         const entries = fs.readdirSync(folder);
         for (let entry of entries) {
             const entryPath = path.join(folder, entry);
@@ -39,10 +39,15 @@ export default class ResourceUtil {
                 files.set(normalized, fs.readFileSync(entryPath, { encoding: "utf-8" }));
             }
             else if (stats.isDirectory()) {
-                this.read(rootFolder, entryPath, files, exclude);
+                this._read(rootFolder, entryPath, files, exclude);
             }
         }
     }
+    static read(folder) {
+        const files = new Map();
+        this._read(folder, folder, files);
+        return files;
+    }
     static getString(resource) {
         return resource.getBuffer().then((buffer) => buffer.toString(UTF8));
     }
@@ -58,5 +63,13 @@ export default class ResourceUtil {
             string: content
         });
     }
+    static async toFileMap(resources, projectNamespace) {
+        const files = new Map();
+        const rootFolderLength = ResourceUtil.getRootFolder(projectNamespace).length;
+        for (const resource of resources) {
+            files.set(resource.getPath().substring(rootFolderLength + 1), await ResourceUtil.getString(resource));
+        }
+        return files;
+    }
 }
 //# sourceMappingURL=resourceUtil.js.map