@ui5/task-adaptation 1.0.16 → 1.0.18

package/CHANGELOG.md

@@ -2,7 +2,13 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task-adaptation/compare/v1.0.16...HEAD).
+A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task-adaptation/compare/v1.0.18...HEAD).
+
+<a name="v1.0.18"></a>
+## [v1.0.18] - 2023-11-10
+
+<a name="v1.0.17"></a>
+## [v1.0.17] - 2023-08-16
 
 <a name="v1.0.16"></a>
 ## [v1.0.16] - 2023-08-15
@@ -46,6 +52,8 @@ A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task
 <a name="v1.0.0"></a>
 ## v1.0.0 - 2020-12-09
 
+[v1.0.18]: https://github.com/SAP/ui5-task-adaptation/compare/v1.0.17...v1.0.18
+[v1.0.17]: https://github.com/SAP/ui5-task-adaptation/compare/v1.0.16...v1.0.17
 [v1.0.16]: https://github.com/SAP/ui5-task-adaptation/compare/v1.0.11...v1.0.16
 [v1.0.11]: https://github.com/SAP/ui5-task-adaptation/compare/v1.0.10...v1.0.11
 [v1.0.10]: https://github.com/SAP/ui5-task-adaptation/compare/v1.0.9...v1.0.10

package/dist/annotationManager.d.ts

@@ -10,12 +10,8 @@ export default class AnnotationManager {
     constructor(configuration: IConfiguration, abapRepoManager: AbapRepoManager);
     ANNOTATIONS_FOLDER: string;
     process(renamedBaseAppManifest: any, languages: string[]): Promise<Map<string, string>>;
-    private createI18nFiles;
     private normalizeAppVariantId;
     private createAnnotationFile;
-    private getNormalisedLanguage;
-    private getAdaptedAnnotation;
-    private getUniqueKeyForPath;
     private downloadAnnotations;
     private updateManifest;
     private updateManifestDataSources;
@@ -23,10 +19,4 @@ export default class AnnotationManager {
     private enhanceManifestModel;
     private downloadAnnotation;
     private getODataAnnotations;
-    static traverseJson(obj: any, path: string): {
-        subject: any;
-        property: string;
-    };
-    private getDiffJsonPaths;
-    private traverseDiff;
 }

package/dist/annotationManager.js

@@ -1,17 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const convert = require("xml-js");
-const path = require("path");
 const annotationsCacheManager_1 = require("./cache/annotationsCacheManager");
 const baseAppManager_1 = require("./baseAppManager");
-const json_diff_1 = require("json-diff");
-const util_1 = require("util");
-const { ResourceBundle } = require("../dist/bundle-resourceBundle");
+const i18nManager_1 = require("./i18nManager");
+const xmlUtil_1 = require("./util/xmlUtil");
+const path_1 = require("path");
 const I18N_DEFAULT_PATH = "i18n/annotations";
 const I18N_DEFAULT_MODEL_NAME = "@i18n";
 const SAPUI5 = "sap.ui5";
 const SAPAPP = "sap.app";
-const XML_OPTIONS = { compact: true, spaces: 4 };
 const log = require("@ui5/logger").getLogger("@ui5/task-adaptation::AnnotationManager");
 class AnnotationManager {
     constructor(configuration, abapRepoManager) {
@@ -27,13 +24,12 @@ class AnnotationManager {
         const oDataAnnotations = this.getODataAnnotations(renamedBaseAppManifest);
         const promises = this.downloadAnnotations(oDataAnnotations, languages);
         const modelName = I18N_DEFAULT_MODEL_NAME; //`i18n_a9n_${normalisedId}`;
-        const i18nPathName = path.join(I18N_DEFAULT_PATH, normalisedId);
-        const keys = new Array();
-        const propertiesPerLanguage = new Map();
+        const i18nPathName = path_1.posix.join(I18N_DEFAULT_PATH, normalisedId);
         const annotationFiles = new Map();
         const metaInfo = new Array();
+        const i18nManager = new i18nManager_1.default(modelName, id, languages);
         for (const { promisesPerLanguage, annotationName } of promises) {
-            const annotationXml = await this.createAnnotationFile(promisesPerLanguage, keys, modelName, propertiesPerLanguage, id);
+            const annotationXml = await this.createAnnotationFile(promisesPerLanguage, i18nManager);
             const annotationFileName = `annotations/annotation_${annotationName}.xml`;
             annotationFiles.set(annotationFileName, annotationXml);
             metaInfo.push({ annotationFileName, annotationName });
@@ -41,82 +37,20 @@ class AnnotationManager {
         if (metaInfo.length > 0) {
             this.updateManifest(renamedBaseAppManifest, metaInfo, modelName, i18nPathName);
         }
-        const i18nFiles = this.createI18nFiles(propertiesPerLanguage, i18nPathName);
+        const i18nFiles = i18nManager.createFiles(i18nPathName);
         return new Map([...annotationFiles, ...i18nFiles]);
     }
-    createI18nFiles(propertiesPerLanguage, i18nPathName) {
-        const files = new Map();
-        propertiesPerLanguage.forEach((i18nLines, language) => {
-            i18nLines.sort();
-            let filename = "i18n";
-            const normalisedLanguage = this.getNormalisedLanguage(language);
-            if (normalisedLanguage) {
-                filename += "_" + normalisedLanguage;
-            }
-            const filepath = path.join(i18nPathName, filename + ".properties");
-            files.set(filepath, i18nLines.join("\n"));
-        });
-        return files;
-    }
     normalizeAppVariantId(id, replaceWith = "") {
         return id.replace(/[.\W]+/gi, replaceWith);
     }
-    async createAnnotationFile(promisesPerLanguage, keys, modelName, propertiesPerLanguage, appVariantId) {
+    async createAnnotationFile(promisesPerLanguage, i18nManager) {
         const annotationJsons = new Map();
         for (const promise of promisesPerLanguage) {
             const { language, xml } = await promise;
-            annotationJsons.set(language, JSON.parse(convert.xml2json(xml, XML_OPTIONS)));
-        }
-        const paths = this.getDiffJsonPaths([...annotationJsons.values()]);
-        const { annotationJson, languageI18nContentMap } = this.getAdaptedAnnotation(paths, keys, annotationJsons, modelName, appVariantId);
-        languageI18nContentMap.forEach((i18nLines, language) => {
-            const properties = propertiesPerLanguage.get(language);
-            if (properties) {
-                properties.push(...i18nLines);
-            }
-            else {
-                propertiesPerLanguage.set(language, i18nLines);
-            }
-        });
-        return convert.json2xml(annotationJson, XML_OPTIONS);
-    }
-    getNormalisedLanguage(language) {
-        const normalisedLanguages = ResourceBundle._getFallbackLocales(language);
-        if (normalisedLanguages?.length > 0 && normalisedLanguages[0] != null && normalisedLanguages[0].length > 0) {
-            return normalisedLanguages[0].toLowerCase();
+            annotationJsons.set(language, xmlUtil_1.default.xmlToJson(xml));
         }
-    }
-    getAdaptedAnnotation(paths, keys, annotationJsons, modelName, appVariantId) {
-        const pathKeyMap = new Map();
-        const languageI18nContentMap = new Map();
-        for (const [language, json] of [...annotationJsons]) {
-            const lines = [];
-            for (const path of paths) {
-                const { subject, property } = AnnotationManager.traverseJson(json, path);
-                const value = subject[property];
-                const key = appVariantId + "_" + this.getUniqueKeyForPath(pathKeyMap, path, keys, value);
-                lines.push(key + "=" + value);
-                subject[property] = `{${modelName}>${key}}`;
-            }
-            if (lines.length > 0) {
-                languageI18nContentMap.set(language, lines);
-            }
-        }
-        return { annotationJson: [...annotationJsons][0][1], languageI18nContentMap };
-    }
-    getUniqueKeyForPath(pathKeyMap, path, keys, value) {
-        if (pathKeyMap.has(path)) {
-            return pathKeyMap.get(path);
-        }
-        const propertyName = value.replace(/\W/gi, "_").toUpperCase();
-        let suffix = "";
-        while (keys.includes(propertyName + suffix)) {
-            suffix = suffix === "" ? "0" : (parseInt(suffix) + 1).toString();
-        }
-        const key = propertyName + suffix;
-        pathKeyMap.set(path, key);
-        keys.push(key);
-        return key;
+        const annotationJson = i18nManager.populateTranslations(annotationJsons);
+        return xmlUtil_1.default.jsonToXml(annotationJson.json);
     }
     downloadAnnotations(annotations, languages) {
         return [...annotations].map(([name, { uri }]) => ({
@@ -181,7 +115,13 @@ class AnnotationManager {
         const cacheManager = new annotationsCacheManager_1.default(this.configuration, cacheFilename);
         log.verbose(`Getting annotation '${name}' ${language} by '${annotationUri}'`);
         try {
-            const files = await cacheManager.getFiles(() => this.abapRepoManager.getAnnotationMetadata(annotationUri), () => this.abapRepoManager.downloadAnnotationFile(annotationUri));
+            let files;
+            if (this.configuration.enableAnnotationCache) {
+                files = await cacheManager.getFiles(() => this.abapRepoManager.getAnnotationMetadata(annotationUri), () => this.abapRepoManager.downloadAnnotationFile(annotationUri));
+            }
+            else {
+                files = await this.abapRepoManager.downloadAnnotationFile(annotationUri);
+            }
             if (!files || files.size === 0) {
                 throw new Error(`No files were fetched for '${name}' by '${annotationUri}'`);
             }
@@ -204,73 +144,6 @@ class AnnotationManager {
         }
         return oDataAnnotations;
     }
-    static traverseJson(obj, path) {
-        const checkArrayIndex = (part) => {
-            if (Array.isArray(subject)) {
-                const item = parseInt(part);
-                if (isNaN(item)) {
-                    throw new Error(`Array index '${part}' is not a number in path '${path}' for ${json}`);
-                }
-            }
-        };
-        const json = util_1.inspect(obj, true, 100, false);
-        const pathParts = path.split("/");
-        if (path.endsWith("/")) {
-            pathParts.pop();
-        }
-        let property = pathParts.pop();
-        let subject = obj;
-        for (const part of pathParts) {
-            let item = part;
-            checkArrayIndex(part);
-            subject = subject[item];
-            if (subject == null) {
-                throw new Error(`Property '${item}' is undefined in path '${path}' for ${json}`);
-            }
-        }
-        checkArrayIndex(property);
-        if (subject[property] == null) {
-            throw new Error(`Target property '${property}' is undefined in path '${path}' for ${json}`);
-        }
-        return { subject, property };
-    }
-    getDiffJsonPaths(jsons) {
-        const paths = new Set();
-        if (jsons.length > 1) {
-            for (let j = 1; j < jsons.length; j++) {
-                const diffResult = json_diff_1.diff(jsons[0], jsons[j], { full: false, sort: false });
-                // if diffResult is undefined -> jsons are the same
-                if (diffResult) {
-                    for (const path of this.traverseDiff(diffResult)) {
-                        paths.add(path);
-                    }
-                }
-            }
-        }
-        return [...paths];
-    }
-    traverseDiff(obj, path = "") {
-        const branches = [];
-        if (Array.isArray(obj)) {
-            for (let i = 0; i < obj.length; i++) {
-                const item = obj[i];
-                if (item[0] == "~") {
-                    branches.push(...this.traverseDiff(item[1], path + `${i}/`));
-                }
-            }
-        }
-        else {
-            for (const key of Object.keys(obj)) {
-                if (key == "__old" || key == "__new") {
-                    branches.push(path);
-                }
-                else {
-                    branches.push(...this.traverseDiff(obj[key], path + `${key}/`));
-                }
-            }
-        }
-        return branches;
-    }
 }
 exports.default = AnnotationManager;
 //# sourceMappingURL=annotationManager.js.map

package/dist/appVariantManager.d.ts

@@ -2,6 +2,7 @@ import { IAppVariantInfo } from "./model/types";
 export default class AppVariantManager {
     static process(appVariantResources: any[], projectNamespace: string, taskUtil: any): Promise<IAppVariantInfo>;
     static getAppVariantResources(workspace: any): Promise<any[]>;
+    static renameChanges(appVariantResources: any[], projectNamespace: string, appVariantInfo: IAppVariantInfo): Promise<void>;
     static getAppVariantInfo(appVariantResources: any[]): Promise<IAppVariantInfo>;
     static writeI18nToModule(resource: any, projectNamespace: string, i18nBundleName: string): void;
     private static omitFiles;

package/dist/appVariantManager.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const resourceUtil_1 = require("./util/resourceUtil");
 const commonUtil_1 = require("./util/commonUtil");
+const resourceUtil_1 = require("./util/resourceUtil");
+const path_1 = require("path");
 const log = require("@ui5/logger").getLogger("@ui5/task-adaptation::AppVariantManager");
 const OMIT_FILES = ["manifest.appdescr_variant"];
 const OMIT_FOLDERS = [];
@@ -11,42 +11,71 @@ const MANIFEST_APP_VARIANT = "manifest.appdescr_variant";
 class AppVariantManager {
     static async process(appVariantResources, projectNamespace, taskUtil) {
         const appVariantInfo = await this.getAppVariantInfo(appVariantResources);
-        const i18nBundleName = commonUtil_1.replaceDots(appVariantInfo.id);
+        const i18nBundleName = (0, commonUtil_1.replaceDots)(appVariantInfo.id);
         for (const resource of appVariantResources) {
             this.writeI18nToModule(resource, projectNamespace, i18nBundleName);
             this.omitFiles(resource, taskUtil);
         }
         this.adjustAddNewModelEnhanceWith(appVariantInfo?.manifest?.content ?? [], i18nBundleName);
+        await this.renameChanges(appVariantResources, projectNamespace, appVariantInfo);
         return appVariantInfo;
     }
     static getAppVariantResources(workspace) {
         return workspace.byGlob(`/**/*.{${EXTENSIONS}}`);
     }
+    static async renameChanges(appVariantResources, projectNamespace, appVariantInfo) {
+        const changesFolder = resourceUtil_1.default.getResourcePath(projectNamespace, "changes");
+        const changes = new Map();
+        const resourcesByPath = new Map();
+        for (const resource of appVariantResources) {
+            const resourcePath = resource.getPath();
+            const basename = path_1.posix.dirname(resourcePath);
+            if (changesFolder === basename) {
+                changes.set(resourcePath, await resourceUtil_1.default.getString(resource));
+                resourcesByPath.set(resourcePath, resource);
+            }
+        }
+        const renamedChanges = (0, commonUtil_1.renameResources)(changes, appVariantInfo.reference, appVariantInfo.id);
+        renamedChanges.forEach((renamedContent, resourcePath) => {
+            const resource = resourcesByPath.get(resourcePath);
+            resourceUtil_1.default.setString(resource, renamedContent);
+        });
+    }
     static async getAppVariantInfo(appVariantResources) {
+        const changesManifestFolder = path_1.posix.join("changes", "manifest");
+        let manifest;
+        const manifestChanges = [];
         for (const resource of appVariantResources) {
-            const basename = path.basename(resource.getPath());
+            const resourcePath = resource.getPath();
+            const dirname = path_1.posix.dirname(resource.getPath());
+            const basename = path_1.posix.basename(resourcePath);
             if (basename === MANIFEST_APP_VARIANT) {
-                const manifest = await resource.getBuffer().then((buffer) => buffer.toString("utf8")).then(JSON.parse);
-                const { id, reference } = manifest;
-                return { id, reference, manifest };
+                manifest = await resourceUtil_1.default.getString(resource).then(JSON.parse);
+            }
+            else if (dirname.endsWith(changesManifestFolder)) {
+                const str = await resourceUtil_1.default.getString(resource);
+                manifestChanges.push(JSON.parse(str));
             }
         }
-        throw new Error("Application variant should contain manifest.appdescr_variant");
+        if (manifest) {
+            return {
+                id: manifest.id,
+                reference: manifest.reference,
+                manifest,
+                manifestChanges
+            };
+        }
+        throw new Error("Adaptation project should contain manifest.appdescr_variant");
     }
     static writeI18nToModule(resource, projectNamespace, i18nBundleName) {
-        if (path.extname(resource.getPath()) === ".properties") {
+        if (path_1.posix.extname(resource.getPath()) === ".properties") {
             let rootFolder = resourceUtil_1.default.getRootFolder(projectNamespace);
-            if (resource.getPath().startsWith(rootFolder)) {
-                resource.setPath(path.join(rootFolder, i18nBundleName, resource.getPath().substring(rootFolder.length)));
-            }
-            else {
-                resource.setPath(path.join("/", i18nBundleName, resource.getPath()));
-            }
+            resource.setPath(path_1.posix.join(rootFolder, i18nBundleName, resource.getPath().substring(rootFolder.length)));
         }
     }
     static omitFiles(resource, taskUtil) {
-        const dirname = path.dirname(resource.getPath());
-        const filename = path.basename(resource.getPath());
+        const dirname = path_1.posix.dirname(resource.getPath());
+        const filename = path_1.posix.basename(resource.getPath());
         if (OMIT_FILES.includes(filename) ||
             OMIT_FOLDERS.some(folder => dirname.endsWith(folder))) {
             taskUtil.setTag(resource, taskUtil.STANDARD_TAGS.OmitFromBuildResult, true);

package/dist/baseAppManager.d.ts

@@ -1,16 +1,20 @@
-import { IAppVariantInfo, IAppVariantManifest, IProjectOptions } from "./model/types";
+import { IAppVariantInfo, IProjectOptions } from "./model/types";
 import IProcessor from "./processors/processor";
+export interface IBaseAppResources {
+    resources: any[];
+    manifestInfo: IManifestInfo;
+}
+export interface IManifestInfo {
+    id: string;
+    version: string;
+}
 export default class BaseAppManager {
-    static process(baseAppFiles: Map<string, string>, appVariantInfo: IAppVariantInfo, options: IProjectOptions, processor: IProcessor): Promise<any[]>;
+    static process(baseAppFiles: Map<string, string>, appVariantInfo: IAppVariantInfo, options: IProjectOptions, processor: IProcessor): Promise<IBaseAppResources>;
     private static updateAdaptationProperties;
-    static getManifestInfo(manifest: any): {
-        id: string;
-        version: string;
-    };
-    static renameBaseApp(baseAppFiles: Map<string, string>, search: string, replacement: string): Map<string, string>;
+    static getManifestInfo(manifest: any): IManifestInfo;
     private static getBaseAppManifest;
     private static fillAppVariantIdHierarchy;
     static validateProperty(value: string, property: string): void;
-    static applyDescriptorChanges(baseAppManifest: any, appVariantManifest: IAppVariantManifest, i18nBundleName: string): Promise<void>;
+    static applyDescriptorChanges(baseAppManifest: any, appVariantInfo: IAppVariantInfo, i18nBundleName: string): Promise<void>;
     static writeToWorkspace(baseAppFiles: Map<string, string>, projectNamespace: string): any[];
 }

package/dist/baseAppManager.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
+const commonUtil_1 = require("./util/commonUtil");
 const buildStrategy_1 = require("./buildStrategy");
 const resourceUtil_1 = require("./util/resourceUtil");
-const commonUtil_1 = require("./util/commonUtil");
+const path_1 = require("path");
 const { RegistrationBuild, ApplyUtil, Applier, Change } = require("../dist/bundle");
 const resourceFactory = require("@ui5/fs/lib/resourceFactory");
 const log = require("@ui5/logger").getLogger("@ui5/task-adaptation::BaseAppManager");
@@ -11,15 +11,18 @@ class BaseAppManager {
     static async process(baseAppFiles, appVariantInfo, options, processor) {
         const baseAppManifest = this.getBaseAppManifest(baseAppFiles);
         const { id, version } = this.getManifestInfo(baseAppManifest.content);
-        const renamedBaseAppFiles = this.renameBaseApp(baseAppFiles, appVariantInfo.reference, appVariantInfo.id);
+        const renamedBaseAppFiles = (0, commonUtil_1.renameResources)(baseAppFiles, appVariantInfo.reference, appVariantInfo.id);
         const { filepath, content } = this.getBaseAppManifest(renamedBaseAppFiles);
         await processor.updateLandscapeSpecificContent(content, renamedBaseAppFiles);
         this.fillAppVariantIdHierarchy(processor, id, version, content);
         this.updateAdaptationProperties(content);
-        const i18nBundleName = commonUtil_1.replaceDots(appVariantInfo.id);
-        await this.applyDescriptorChanges(content, appVariantInfo.manifest, i18nBundleName);
+        const i18nBundleName = (0, commonUtil_1.replaceDots)(appVariantInfo.id);
+        await this.applyDescriptorChanges(content, appVariantInfo, i18nBundleName);
         renamedBaseAppFiles.set(filepath, JSON.stringify(content));
-        return this.writeToWorkspace(renamedBaseAppFiles, options.projectNamespace);
+        return {
+            resources: this.writeToWorkspace(renamedBaseAppFiles, options.projectNamespace),
+            manifestInfo: this.getManifestInfo(content)
+        };
     }
     static updateAdaptationProperties(content) {
         if (content["sap.fiori"]?.cloudDevAdaptationStatus) {
@@ -35,26 +38,6 @@ class BaseAppManager {
         const version = manifest["sap.app"]?.applicationVersion?.version;
         return { id, version };
     }
-    static renameBaseApp(baseAppFiles, search, replacement) {
-        log.verbose("Renaming base app resources to appVariant id");
-        const dotToSlash = (update) => update.split(".").join("\/");
-        const dotsEscape = (update) => update.split(".").join("\\.");
-        const replaces = [
-            {
-                regexp: new RegExp(dotsEscape(search), "g"),
-                replacement
-            },
-            {
-                regexp: new RegExp(dotToSlash(search), "g"),
-                replacement: dotToSlash(replacement)
-            }
-        ];
-        const renamed = new Map();
-        baseAppFiles.forEach((content, filepath) => {
-            renamed.set(filepath, replaces.reduce((p, c) => p.replace(c.regexp, c.replacement), content));
-        });
-        return renamed;
-    }
     static getBaseAppManifest(baseAppFiles) {
         let filepath = [...baseAppFiles.keys()].find(filepath => filepath.endsWith("manifest.json"));
         if (filepath) {
@@ -83,14 +66,19 @@ class BaseAppManager {
             throw new Error(`Original application manifest should have ${property}`);
         }
     }
-    static async applyDescriptorChanges(baseAppManifest, appVariantManifest, i18nBundleName) {
+    static async applyDescriptorChanges(baseAppManifest, appVariantInfo, i18nBundleName) {
         log.verbose("Applying appVariant changes");
         const strategy = new buildStrategy_1.default(RegistrationBuild, ApplyUtil, i18nBundleName);
-        if (appVariantManifest.layer) {
-            appVariantManifest.content?.forEach(item => item.layer = appVariantManifest.layer);
+        const { manifest } = appVariantInfo;
+        const allChanges = [
+            ...manifest.content,
+            ...appVariantInfo.manifestChanges
+        ];
+        if (manifest.layer) {
+            allChanges.forEach(item => item.layer = manifest.layer);
         }
-        const changesContent = appVariantManifest.content?.map((change) => new Change(change));
-        if (changesContent) {
+        const changesContent = allChanges.map(change => new Change(change));
+        if (changesContent.length > 0) {
             await Applier.applyChanges(baseAppManifest, changesContent, strategy);
         }
     }
@@ -116,6 +104,6 @@ class BaseAppManager {
 exports.default = BaseAppManager;
 const getPath = (filename, projectNamespace) => {
     const rootFolder = resourceUtil_1.default.getRootFolder(projectNamespace);
-    return path.resolve(path.join(rootFolder, filename));
+    return path_1.posix.join(rootFolder, filename);
 };
 //# sourceMappingURL=baseAppManager.js.map

package/dist/bundle.js

@@ -6,28 +6,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var path = require('path');
 
-function _interopNamespace(e) {
-	if (e && e.__esModule) return e;
-	var n = Object.create(null);
-	if (e) {
-		Object.keys(e).forEach(function (k) {
-			if (k !== 'default') {
-				var d = Object.getOwnPropertyDescriptor(e, k);
-				Object.defineProperty(n, k, d.get ? d : {
-					enumerable: true,
-					get: function () {
-						return e[k];
-					}
-				});
-			}
-		});
-	}
-	n['default'] = e;
-	return Object.freeze(n);
-}
-
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-
 var fnIsEmptyObject = function isEmptyObject(obj) {
   for (var sName in obj) {
     return false;
@@ -85,7 +63,7 @@ class URI {
     }
 
     normalize() {
-        this.value = path__namespace.normalize(this.value);
+        this.value = path.posix.normalize(this.value).replace(/\\/g, "/");
         return this;
     }
 

package/dist/cache/cacheManager.js

@@ -27,6 +27,7 @@ class CacheManager {
         }
     }
     isMetadataSame(tempMetadata, metadata) {
+        // TODO: Implement correct metadata comparision.
         return tempMetadata && metadata && tempMetadata.changedOn === metadata.changedOn;
     }
     readTempMetadata() {

package/dist/i18nManager.d.ts

@@ -0,0 +1,43 @@
+import { IDiffProperty, IJsonContent } from "./util/jsonDiffUtil";
+export declare class PropertyValue {
+    value: string;
+    isReference: boolean;
+    qualifier: string;
+    language: string;
+    private static OLD;
+    private static NEW;
+    private constructor();
+    get isOld(): boolean;
+    set(diff: any, references: Map<string, string>): void;
+    static oldFrom(language: string, value?: string): PropertyValue;
+    static newFrom(language: string, value?: string): PropertyValue;
+}
+export declare class I18nFileContent {
+    private properties;
+    constructor(languages: string[]);
+    add(prop: PropertyValue, key: string): void;
+    private initKeyValuesForOtherLanguages;
+    hasTranslations(): boolean;
+    private getOrCreateLanguageContent;
+    createFiles(i18nPathName: string): Map<string, string>;
+}
+export default class I18nManager {
+    private modelName;
+    private appVariantId;
+    private references;
+    private existingKeys;
+    private i18nFileContent;
+    constructor(modelName: string, appVariantId: string, languages: string[]);
+    processDiff(properties: Set<IDiffProperty>, previousLanguage: string, currentLanguage: string): void;
+    createFiles(i18nPathName: string): Map<string, string>;
+    populateTranslations(annotationJsons: Map<string, any>): IJsonContent;
+    populate(annotationJsons: [string, any][], defaultAnnotation: IJsonContent): {
+        language: string;
+        json: any;
+    };
+    static extractDefaultLanguageAnnotation(annotationJsons: Map<string, any>): IJsonContent;
+    private replaceWithModelReference;
+    private createReference;
+    getUniqueKeyForValue(value: string): string;
+    private initPropertyValues;
+}

package/dist/i18nManager.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nFileContent = exports.PropertyValue = void 0;
+const jsonDiffUtil_1 = require("./util/jsonDiffUtil");
+const annotationDiffStructureError_1 = require("./model/annotationDiffStructureError");
+const path_1 = require("path");
+// To generate keys, english language is more common, so compare all other
+// languages with it
+const DEFAULT_LANGUAGES = ["", "EN", "EN_US", "EN_GB"];
+class PropertyValue {
+    constructor(qualifier, language, value) {
+        this.isReference = false;
+        this.qualifier = qualifier;
+        this.language = language;
+        this.value = value;
+    }
+    get isOld() {
+        return this.qualifier === PropertyValue.OLD;
+    }
+    set(diff, references) {
+        this.value = diff[this.qualifier];
+        this.isReference = references.has(diff[this.qualifier]);
+    }
+    static oldFrom(language, value = "") {
+        return new PropertyValue(PropertyValue.OLD, language, value);
+    }
+    static newFrom(language, value = "") {
+        return new PropertyValue(PropertyValue.NEW, language, value);
+    }
+}
+exports.PropertyValue = PropertyValue;
+PropertyValue.OLD = "__old";
+PropertyValue.NEW = "__new";
+class I18nFileContent {
+    constructor(languages) {
+        this.properties = new Map();
+        languages.forEach(language => this.properties.set(language, new Map()));
+    }
+    add(prop, key) {
+        this.getOrCreateLanguageContent(prop.language).set(key, prop.value);
+        this.initKeyValuesForOtherLanguages(prop, key);
+    }
+    initKeyValuesForOtherLanguages(prop, key) {
+        // "", EN, EN_US, DE, FR
+        // If we already compared 2 languages and saved translations, we assume
+        // that we have generated all property keys, but suddenly 3d language or
+        // further contain translation which was not present in previous
+        // languages we need to update all other languages then. These values
+        // will be overwritten later by actual values of the language:
+        // this.getOrCreateLanguageContent(prop.language).set(key, prop.value);
+        if (prop.isOld) {
+            this.properties.forEach((keyValue, language) => {
+                if (language !== prop.language && !keyValue.has(key)) {
+                    keyValue.set(key, prop.value);
+                }
+            });
+        }
+    }
+    hasTranslations() {
+        // this.properties.size can be 0 or 2+, it can't be 1
+        return [...this.properties.values()].some(keyValue => keyValue.size > 0);
+    }
+    getOrCreateLanguageContent(language) {
+        if (!this.properties.has(language)) {
+            this.properties.set(language, new Map());
+        }
+        return this.properties.get(language);
+    }
+    createFiles(i18nPathName) {
+        const files = new Map();
+        if (this.hasTranslations()) {
+            this.properties.forEach((i18nLines, language) => {
+                let filename = "i18n";
+                if (language) {
+                    filename += "_" + language.toLowerCase();
+                }
+                const filepath = (0, path_1.join)(i18nPathName, filename + ".properties");
+                files.set(filepath, [...i18nLines].map(([key, value]) => `${key}=${value}`).join("\n"));
+            });
+        }
+        return files;
+    }
+}
+exports.I18nFileContent = I18nFileContent;
+class I18nManager {
+    constructor(modelName, appVariantId, languages) {
+        this.references = new Map();
+        this.existingKeys = new Set();
+        this.modelName = modelName;
+        this.appVariantId = appVariantId;
+        this.i18nFileContent = new I18nFileContent(languages);
+    }
+    processDiff(properties, previousLanguage, currentLanguage) {
+        // json-diff uses __old and __new value as diff,
+        // so we assign it with languages which were in comparison
+        const propertyValues = [
+            PropertyValue.oldFrom(previousLanguage),
+            PropertyValue.newFrom(currentLanguage)
+        ];
+        for (const property of properties) {
+            this.replaceWithModelReference(property, propertyValues);
+        }
+    }
+    createFiles(i18nPathName) {
+        return this.i18nFileContent.createFiles(i18nPathName);
+    }
+    populateTranslations(annotationJsons) {
+        /* We compare annotations. Diff gives us:
+        {
+            "string": {
+                "__old": "A"
+                "__new": "B"
+            }
+        }
+        we generate key and extract to properties file. Now it looks so:
+        {
+            "string": "{@i18n>id_KEY}"
+        }
+        and we compare this with next language and diff gives us:
+        {
+            "string": {
+                "__old": "{@i18n>id_KEY}"
+                "__new": "C"
+            }
+        }
+        we use already generate key id_KEY and extract translation value to
+        properties file again. And then compare with the next language and so on
+        and so on */
+        let defaultAnnotation = I18nManager.extractDefaultLanguageAnnotation(annotationJsons);
+        if (annotationJsons.size > 0 && defaultAnnotation) {
+            defaultAnnotation = this.populate([...annotationJsons], defaultAnnotation);
+        }
+        return defaultAnnotation;
+    }
+    populate(annotationJsons, defaultAnnotation) {
+        return annotationJsons
+            .map(([language, json]) => ({ language, json }))
+            .reduce((p, c) => {
+            try {
+                const pDiff = jsonDiffUtil_1.default.diff(p.json, c.json);
+                this.processDiff(pDiff.properties, p.language, c.language);
+                return { json: pDiff.json, language: p.language };
+            }
+            catch (error) {
+                if (error instanceof annotationDiffStructureError_1.default) {
+                    throw new Error(`The structure of the oData annotation xml of language '${p.language}' is different from xml of language '${c.language}' near element: ${error.message}`);
+                }
+                throw error;
+            }
+        }, defaultAnnotation);
+    }
+    static extractDefaultLanguageAnnotation(annotationJsons) {
+        let json = null;
+        for (const language of DEFAULT_LANGUAGES) {
+            json = annotationJsons.get(language);
+            if (json != null) {
+                annotationJsons.delete(language);
+                return { json, language };
+            }
+        }
+        const language = [...annotationJsons.keys()][0];
+        json = annotationJsons.get(language);
+        annotationJsons.delete(language);
+        return { json, language };
+    }
+    replaceWithModelReference({ object, property }, propertyValues) {
+        const diff = object[property];
+        this.initPropertyValues(diff, propertyValues);
+        // If there are already generated key, like on step 3. above comment, we
+        // take it (from __old), so we don't need to generate new
+        const propReference = propertyValues.find(prop => prop.isReference);
+        let reference = propReference?.value ?? this.createReference(diff.__old);
+        object[property] = reference;
+        // Other values, which are not references, are extracted to .properties
+        const key = this.references.get(reference);
+        if (key) {
+            propertyValues.filter(prop => !prop.isReference).forEach(prop => this.i18nFileContent.add(prop, key));
+        }
+    }
+    createReference(value) {
+        const key = this.appVariantId + "_" + this.getUniqueKeyForValue(value);
+        const reference = `{${this.modelName}>${key}}`;
+        this.references.set(reference, key);
+        return reference;
+    }
+    getUniqueKeyForValue(value) {
+        const propertyName = value.replace(/\W/gi, "_").toUpperCase();
+        let suffix = -1;
+        let suffixString;
+        do {
+            suffixString = suffix === -1 ? "" : suffix;
+            suffix++;
+        } while (this.existingKeys.has(propertyName + suffixString));
+        const key = propertyName + suffixString;
+        this.existingKeys.add(key);
+        return key;
+    }
+    initPropertyValues(diff, propertyValues) {
+        propertyValues.forEach(prop => prop.set(diff, this.references));
+    }
+}
+exports.default = I18nManager;
+//# sourceMappingURL=i18nManager.js.map

package/dist/index.js

@@ -10,12 +10,12 @@ const processor_1 = require("./processors/processor");
 module.exports = ({ workspace, options, taskUtil }) => {
     dotenv.config();
     async function process(workspace, taskUtil) {
-        const processor = processor_1.determineProcessor(options.configuration);
+        const processor = (0, processor_1.determineProcessor)(options.configuration);
         const appVariantResources = await appVariantManager_1.default.getAppVariantResources(workspace);
         const appVariantInfo = await appVariantManager_1.default.process(appVariantResources, options.projectNamespace, taskUtil);
         const baseAppFiles = await processor.getBaseAppFiles(appVariantInfo.reference);
-        const baseAppResources = await baseAppManager_1.default.process(baseAppFiles, appVariantInfo, options, processor);
-        await Promise.all(appVariantResources.concat(baseAppResources).map(resource => workspace.write(resource)));
+        const { resources } = await baseAppManager_1.default.process(baseAppFiles, appVariantInfo, options, processor);
+        await Promise.all(appVariantResources.concat(resources).map(resource => workspace.write(resource)));
     }
     return process(workspace, taskUtil);
 };

package/dist/model/annotationDiffStructureError.d.ts

@@ -0,0 +1,3 @@
+export default class AnnotationDiffStructureError extends Error {
+    constructor(json: any);
+}

package/dist/model/annotationDiffStructureError.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AnnotationDiffStructureError extends Error {
+    constructor(json) {
+        super(JSON.stringify(json));
+    }
+}
+exports.default = AnnotationDiffStructureError;
+//# sourceMappingURL=annotationDiffStructureError.js.map

package/dist/model/types.d.ts

@@ -10,6 +10,7 @@ export interface IConfiguration {
     credentials?: IAuth;
     type?: "cf" | "abap";
     languages?: string[];
+    enableAnnotationCache?: boolean;
 }
 export interface IProjectOptions {
     configuration: IConfiguration;
@@ -58,6 +59,7 @@ export interface IAppVariantInfo {
     id: string;
     reference: string;
     manifest: IAppVariantManifest;
+    manifestChanges: Array<IChange>;
 }
 export interface IAppVariantManifest {
     id: string;
@@ -94,6 +96,6 @@ export interface IMetadata {
     changedOn: string;
     id?: string;
 }
-export declare type KeyedMap<T, K extends keyof T, V> = {
+export type KeyedMap<T, K extends keyof T, V> = {
     [k in K]: V;
 };

package/dist/processors/abapProcessor.js

@@ -12,7 +12,7 @@ class AbapProcessor {
         return this.cacheManager.getFiles(() => this.abapRepoManager.getMetadata(baseAppId), () => this.abapRepoManager.downloadBaseAppFiles());
     }
     validateConfiguration() {
-        commonUtil_1.validateObject(this.configuration, ["destination", "appName"], "should be specified in ui5.yaml configuration");
+        (0, commonUtil_1.validateObject)(this.configuration, ["destination", "appName"], "should be specified in ui5.yaml configuration");
     }
     async updateLandscapeSpecificContent(renamedBaseAppManifest, baseAppFiles) {
         const { languages } = this.configuration;

package/dist/processors/cfProcessor.js

@@ -11,7 +11,7 @@ class CFProcessor {
         return this.cacheManager.getFiles(() => html5RepoManager_1.default.getMetadata(this.configuration), () => html5RepoManager_1.default.getBaseAppFiles(this.configuration));
     }
     validateConfiguration() {
-        commonUtil_1.validateObject(this.configuration, ["appHostId", "appName", "appVersion"], "should be specified in ui5.yaml configuration");
+        (0, commonUtil_1.validateObject)(this.configuration, ["appHostId", "appName", "appVersion"], "should be specified in ui5.yaml configuration");
     }
     async updateLandscapeSpecificContent(renamedBaseAppManifest) {
         this.updateCloudPlatform(renamedBaseAppManifest);

package/dist/repositories/abapRepoManager.js

@@ -50,7 +50,7 @@ class AbapRepoManager {
         const data = await requestUtil_1.default.get(uri, REQUEST_OPTIONS_XML, auth);
         if (data?.d?.ZipArchive.length > 0) {
             const buffer = Buffer.from(data.d.ZipArchive, "base64");
-            return zipUtil_1.unzipZipEntries(buffer);
+            return (0, zipUtil_1.unzipZipEntries)(buffer);
         }
         throw new Error(`App '${appName}' from destination '${destination}' doesn't contain files`);
     }

package/dist/repositories/html5RepoManager.js

@@ -69,7 +69,7 @@ class HTML5RepoManager {
         const { appHostId, appName, appVersion } = options;
         const uri = `${html5RepoBaseUri}/applications/content/${appName}-${appVersion}/`;
         const zip = await this.download(token, appHostId, uri);
-        return zipUtil_1.unzipZipEntries(zip);
+        return (0, zipUtil_1.unzipZipEntries)(zip);
     }
     static async download(token, appHostId, uri) {
         if (!token) {

package/dist/util/commonUtil.d.ts

@@ -1,2 +1,3 @@
 export declare function replaceDots(value: string): string;
 export declare function validateObject<T extends Object>(options: T, properties: Array<keyof T>, message: string): void;
+export declare function renameResources(files: Map<string, string>, search: string, replacement: string): Map<string, string>;

package/dist/util/commonUtil.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateObject = exports.replaceDots = void 0;
+exports.renameResources = exports.validateObject = exports.replaceDots = void 0;
 function replaceDots(value) {
     return value.replace(/\./g, "_");
 }
@@ -13,4 +13,36 @@ function validateObject(options, properties, message) {
     }
 }
 exports.validateObject = validateObject;
+function renameResources(files, search, replacement) {
+    const escapeRegexSpecialChars = (update) => update.replaceAll(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+    // 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
+    if (replacement.includes(search)) {
+        const [before, _] = replacement.split(search);
+        // Matches a position in the string that is not immediately preceded by
+        // the string "before".
+        search = `(?<!${escapeRegexSpecialChars(before)})${escapeRegexSpecialChars(search)}`;
+    }
+    else {
+        search = escapeRegexSpecialChars(search);
+    }
+    const dotToSlash = (update) => update.replaceAll(".", "\/");
+    const replaces = [
+        {
+            regexp: new RegExp(search, "g"),
+            replacement
+        },
+        {
+            regexp: new RegExp(dotToSlash(search), "g"),
+            replacement: dotToSlash(replacement)
+        }
+    ];
+    const renamed = new Map();
+    files.forEach((content, filepath) => {
+        renamed.set(filepath, replaces.reduce((p, c) => p.replace(c.regexp, c.replacement), content));
+    });
+    return renamed;
+}
+exports.renameResources = renameResources;
 //# sourceMappingURL=commonUtil.js.map

package/dist/util/jsonDiffUtil.d.ts

@@ -0,0 +1,17 @@
+export interface IJsonContent {
+    language: string;
+    json: any;
+}
+export interface IDiffProperty {
+    object: any;
+    property: string;
+}
+export interface IDiffJson {
+    json: any;
+    properties: Set<IDiffProperty>;
+}
+export default class JsonDiffUtil {
+    static diff(jsonA: any, jsonB: any): IDiffJson;
+    private static findDiffsAndRestoreStructure;
+    private static traverseDiffRecursive;
+}

package/dist/util/jsonDiffUtil.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsonDiff = require("json-diff");
+const annotationDiffStructureError_1 = require("../model/annotationDiffStructureError");
+class JsonDiffUtil {
+    static diff(jsonA, jsonB) {
+        const json = jsonDiff.diff(jsonA, jsonB, { full: true, sort: false });
+        const properties = this.findDiffsAndRestoreStructure(json);
+        return {
+            json,
+            properties
+        };
+    }
+    static findDiffsAndRestoreStructure(object) {
+        const properties = new Set();
+        this.traverseDiffRecursive(properties, { object }, "object");
+        return properties;
+    }
+    static traverseDiffRecursive(properties, object, property) {
+        const current = object[property];
+        if (typeof current !== "object") {
+            return;
+        }
+        if (Array.isArray(current)) {
+            for (let i = 0; i < current.length; i++) {
+                const item = current[i];
+                if (["~", " ", "-", "+"].some(sign => item[0] === sign)) {
+                    current[i] = item[1];
+                    // This is a sign from json-diff plugin, that the property contains differences.
+                    // We will remove these signs, to restore the original structure
+                    if (item[0] === "~") {
+                        this.traverseDiffRecursive(properties, item, 1);
+                    }
+                    else if (item[0] === "+" || item[0] === "-") {
+                        throw new annotationDiffStructureError_1.default(item[1]);
+                    }
+                }
+            }
+        }
+        else {
+            for (const key of Object.keys(current)) {
+                if (key == "__old" || key == "__new") {
+                    properties.add({ object, property });
+                    break;
+                }
+                else {
+                    this.traverseDiffRecursive(properties, current, key);
+                }
+            }
+        }
+    }
+}
+exports.default = JsonDiffUtil;
+//# sourceMappingURL=jsonDiffUtil.js.map

package/dist/util/resourceUtil.d.ts

@@ -1,5 +1,8 @@
 export default class ResourceUtil {
     static getRootFolder(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;
+    static getString(resource: any): Promise<string>;
+    static setString(resource: any, str: string): void;
 }

package/dist/util/resourceUtil.js

@@ -1,15 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = require("fs");
-const path = require("path");
+const path_1 = require("path");
 const resourceFactory = require("@ui5/fs/lib/resourceFactory");
+const UTF8 = "utf8";
 class ResourceUtil {
     static getRootFolder(projectNamespace) {
         const newPath = ["/resources"];
         if (projectNamespace) {
             newPath.push(projectNamespace);
         }
-        return path.join(...newPath);
+        return path_1.posix.join(...newPath);
+    }
+    static getResourcePath(projectNamespace, ...paths) {
+        return path_1.posix.join(this.getRootFolder(projectNamespace), ...paths);
     }
     static write(dir, files) {
         const fsTarget = resourceFactory.createAdapter({
@@ -26,7 +30,7 @@ class ResourceUtil {
     static read(rootFolder, folder, files, exclude = []) {
         const entries = fs.readdirSync(folder);
         for (let entry of entries) {
-            const entryPath = path.join(folder, entry);
+            const entryPath = path_1.posix.join(folder, entry);
             const stats = fs.lstatSync(entryPath);
             if (stats.isFile() && !exclude.some(filepath => entryPath.endsWith(filepath))) {
                 const normalized = entryPath.substring(rootFolder.length);
@@ -37,6 +41,12 @@ class ResourceUtil {
             }
         }
     }
+    static getString(resource) {
+        return resource.getBuffer().then((buffer) => buffer.toString(UTF8));
+    }
+    static setString(resource, str) {
+        resource.setBuffer(Buffer.from(str, UTF8));
+    }
 }
 exports.default = ResourceUtil;
 //# sourceMappingURL=resourceUtil.js.map

package/dist/util/xmlUtil.d.ts

@@ -0,0 +1,4 @@
+export default class XmlUtil {
+    static jsonToXml(json: any): string;
+    static xmlToJson(xml: string): any;
+}

package/dist/util/xmlUtil.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const convert = require("xml-js");
+const XML_OPTIONS = { compact: true, spaces: 4 };
+class XmlUtil {
+    static jsonToXml(json) {
+        return convert.json2xml(json, {
+            ...XML_OPTIONS, attributeValueFn: (val) => val
+                .replaceAll(""", "\"")
+                .replaceAll("&", "&")
+                .replaceAll("<", "&lt;")
+                .replaceAll("\"", "&quot;")
+                .replaceAll("'", "&apos;")
+        });
+    }
+    static xmlToJson(xml) {
+        return JSON.parse(convert.xml2json(xml, {
+            ...XML_OPTIONS, attributeValueFn: (val) => val
+                .replaceAll("&quot;", "\"")
+        }));
+    }
+}
+exports.default = XmlUtil;
+//# sourceMappingURL=xmlUtil.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ui5/task-adaptation",
-    "version": "1.0.16",
+    "version": "1.0.18",
     "description": "Custom task for ui5-builder which allows building UI5 Flexibility Adaptation Projects for SAP BTP, Cloud Foundry environment",
     "main": "index.js",
     "scripts": {
@@ -13,7 +13,7 @@
         "version": "git-chglog --next-tag v$npm_package_version -o CHANGELOG.md && git add CHANGELOG.md",
         "postversion": "git push --follow-tags",
         "release-note": "git-chglog -c .chglog/release-config.yml v$npm_package_version",
-        "rollup": "ts-node scripts/rollup.ts",
+        "rollup": "npx ts-node scripts/rollup.ts",
         "build": "npm run rollup && tsc -p ./"
     },
     "repository": {
@@ -62,14 +62,14 @@
         "@types/mocha": "^9.1.0",
         "@types/rimraf": "^3.0.2",
         "@types/semver": "^7.3.8",
-        "@types/sinon": "^10.0.2",
+        "@types/sinon": "^10.0.16",
         "chai": "^4.3.4",
         "chai-as-promised": "^7.1.1",
         "chalk": "^4.1.2",
         "mocha": "^9.2.0",
         "mock-require": "^3.0.3",
         "nyc": "^15.1.0",
-        "sinon": "^11.1.2",
+        "sinon": "^15.2.0",
         "source-map-support": "^0.5.19",
         "ts-node": "^10.4.0",
         "typescript": "^4.3.5"

package/scripts/bundler.ts

@@ -1,5 +1,5 @@
 import * as fs from "fs";
-import * as path from "path";
+import { posix as path } from "path";
 import * as semver from "semver";
 import * as rollup from "rollup";
 import * as builtins from "builtin-modules";

package/scripts/rollup/overrides/sap/ui/thirdparty/URI.js

@@ -1,4 +1,4 @@
-import * as path from "path";
+import { posix as path } from "path";
 
 export default class URI {
     constructor(value) {
@@ -6,7 +6,7 @@ export default class URI {
     }
 
     normalize() {
-        this.value = path.normalize(this.value);
+        this.value = path.normalize(this.value).replace(/\\/g, "/");
         return this;
     }