@ui5/task-adaptation 1.3.1 → 1.3.3

package/dist/util/commonUtil.js

@@ -0,0 +1,118 @@
+import * as Log from "@ui5/logger";
+import * as fs from "fs";
+import { fileURLToPath } from "url";
+import { posix as path } from "path";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const log = Log.getLogger("rollup-plugin-ui5-resolve-task-adaptation");
+export function dotToUnderscore(value) {
+    return value.replace(/\./g, "_");
+}
+export function validateObject(options, properties, message) {
+    for (const property of properties) {
+        if (!options[property]) {
+            throw new Error(`'${String(property)}' ${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)}`;
+    }
+    else {
+        escapedSearch = escapeRegex(search);
+    }
+    const dotToSlash = (update) => update.replaceAll(".", "\/");
+    const replaces = [
+        {
+            regexp: new RegExp(escapedSearch, "g"),
+            replacement
+        },
+        {
+            regexp: new RegExp(dotToSlash(escapedSearch), "g"),
+            replacement: dotToSlash(replacement)
+        }
+    ];
+    files.forEach((content, filepath, map) => {
+        map.set(filepath, replaces.reduce((p, c) => p.replace(c.regexp, c.replacement), content));
+    });
+    return files;
+}
+export function insertInArray(array, index, insert) {
+    array.splice(index, 0, insert);
+}
+export function writeTempAnnotations({ writeTempFiles }, name, language, content) {
+    const TEMP_DIST_FOLDER = path.join(process.cwd(), "dist-debug", name);
+    if (writeTempFiles) {
+        if (!fs.existsSync(TEMP_DIST_FOLDER)) {
+            fs.mkdirSync(TEMP_DIST_FOLDER, { recursive: true });
+        }
+        if (language) {
+            name += "-" + language.i18n;
+        }
+        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 traverse(json, paths, callback) {
+    for (const key of Object.keys(json)) {
+        const internPaths = [...paths];
+        internPaths.push(key);
+        if (typeof json[key] === "object") {
+            if (Array.isArray(json[key])) {
+                const array = json[key];
+                for (let i = 0; i < array.length; i++) {
+                    if (typeof array[i] === "object") {
+                        traverse(array[i], internPaths, callback);
+                    }
+                    else {
+                        callback(array, i, internPaths);
+                    }
+                }
+            }
+            else {
+                traverse(json[key], internPaths, callback);
+            }
+        }
+        else {
+            callback(json, key, internPaths);
+        }
+    }
+}
+export function logBuilderVersion() {
+    try {
+        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}`);
+    }
+    catch (e) {
+        // do nothing
+    }
+}
+export function logBetaUsage() {
+    log.info("Beta features enabled");
+}
+export function getUniqueName(existingNames, template) {
+    let suffix = -1;
+    let suffixString;
+    do {
+        suffixString = suffix === -1 ? "" : suffix;
+        suffix++;
+    } while (existingNames.includes(template + suffixString));
+    return template + suffixString;
+}
+//# sourceMappingURL=commonUtil.js.map

package/dist/util/i18nMerger.d.ts

@@ -0,0 +1,32 @@
+/// <reference path="../../types/ui5.d.ts" />
+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[];
+    };
+    static mergeI18NFiles(baseAppResources: any[], appVariantResources: any[], projectNamespace: string, baseAppManifestI18NPath: string, appVariantInfo: IAppVariantInfo, taskUtil: any): Promise<(typeof Resource)[]>;
+    /**
+     *  Merge/Append base property file with property file from app variant
+     * FIXME Currently merge could duplicate keys which causes undefined
+     * behavior => Existing keys which are in merge content must be removed =>
+     * Actually only descriptor texts are relevant for merge which always have
+     * app variant Id as prefix => If we filter on them we do not need to remove
+     * 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

@@ -0,0 +1,99 @@
+import { dotToUnderscore, escapeRegex, removePropertiesExtension } from "./commonUtil.js";
+import ResourceUtil from "./resourceUtil.js";
+import { posix as path } from "path";
+export default class I18NMerger {
+    static analyzeAppVariantManifestChanges(rootFolder, tranlsationRegexPattern, { changes }) {
+        // 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 mergePaths = new Set();
+        const copyPaths = new Set();
+        changes.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);
+                if (change.changeType.includes("addNewModelEnhanceWith")) {
+                    copyPaths.add(regex);
+                }
+                else {
+                    mergePaths.add(regex);
+                }
+            }
+        });
+        return { mergePathsRegex: [...mergePaths.values()], copyPathsRegex: [...copyPaths.values()] };
+    }
+    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")) {
+                // 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);
+                }
+                // 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);
+                }
+            }
+            aggregatedResourceFilesMap.set(appVariantResource.getPath(), appVariantResource);
+        }
+        return Array.from(aggregatedResourceFilesMap.values());
+    }
+    /**
+     *  Merge/Append base property file with property file from app variant
+     * FIXME Currently merge could duplicate keys which causes undefined
+     * behavior => Existing keys which are in merge content must be removed =>
+     * Actually only descriptor texts are relevant for merge which always have
+     * 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}`);
+    }
+}
+//# sourceMappingURL=i18nMerger.js.map

package/dist/util/requestUtil.d.ts

@@ -0,0 +1,6 @@
+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>;
+    private static handleError;
+}

package/dist/util/requestUtil.js

@@ -0,0 +1,36 @@
+import axios from "axios";
+import ServerError from "../model/serverError.js";
+export default class RequestUtil {
+    static async head(url) {
+        return this.request(url, axios.head);
+    }
+    static async get(url, options) {
+        return this.request(url, axios.get, options);
+    }
+    static async request(url, method, options) {
+        try {
+            return await method(url, options);
+        }
+        catch (error) {
+            this.handleError(error, url);
+        }
+    }
+    static handleError(error, uri) {
+        if (error.response) {
+            // HTTP Status Code > 2xx
+            if (error.response.status >= 500) {
+                throw new ServerError(uri, error);
+            }
+            else {
+                throw new Error(`Unexpected response received from '${uri}': ${error.response.status} ${error.response.data ?? ""}`);
+            }
+        }
+        else if (error.request) {
+            throw new Error(`No response was received from '${uri}': ${error.code}`);
+        }
+        else {
+            throw new Error(`Error sending request to '${uri}': ${error.code}`);
+        }
+    }
+}
+//# sourceMappingURL=requestUtil.js.map

package/dist/util/resourceUtil.d.ts

@@ -0,0 +1,11 @@
+export default class ResourceUtil {
+    static getRootFolder(projectNamespace?: string): string;
+    static relativeToRoot(resourcePath: string, projectNamespace?: string): string;
+    static getResourcePath(projectNamespace?: string, ...paths: string[]): string;
+    static write(dir: string, files: Map<string, string>): Promise<void[]>;
+    static read(rootFolder: string, folder: string, files: Map<string, string>, exclude?: string[]): void;
+    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;
+}

package/dist/util/resourceUtil.js

@@ -0,0 +1,62 @@
+import * as fs from "fs";
+import * as resourceFactory from "@ui5/fs/resourceFactory";
+import { posix as path } from "path";
+const UTF8 = "utf8";
+export default class ResourceUtil {
+    static getRootFolder(projectNamespace) {
+        const newPath = ["/resources"];
+        if (projectNamespace) {
+            newPath.push(projectNamespace);
+        }
+        return path.join(...newPath);
+    }
+    static relativeToRoot(resourcePath, projectNamespace) {
+        const rootFolder = ResourceUtil.getRootFolder(projectNamespace);
+        return path.relative(rootFolder, resourcePath);
+    }
+    static getResourcePath(projectNamespace, ...paths) {
+        return path.join(this.getRootFolder(projectNamespace), ...paths);
+    }
+    static write(dir, files) {
+        const fsTarget = resourceFactory.createAdapter({
+            fsBasePath: dir,
+            virBasePath: "/"
+        });
+        const promises = [];
+        files.forEach((string, filename) => {
+            const resource = resourceFactory.createResource({ path: "/" + filename, string });
+            promises.push(fsTarget.write(resource));
+        });
+        return Promise.all(promises);
+    }
+    static read(rootFolder, folder, files, exclude = []) {
+        const entries = fs.readdirSync(folder);
+        for (let entry of entries) {
+            const entryPath = path.join(folder, entry);
+            const stats = fs.lstatSync(entryPath);
+            if (stats.isFile() && !exclude.some(filepath => entryPath.endsWith(filepath))) {
+                const normalized = entryPath.substring(rootFolder.length + 1);
+                files.set(normalized, fs.readFileSync(entryPath, { encoding: "utf-8" }));
+            }
+            else if (stats.isDirectory()) {
+                this.read(rootFolder, entryPath, files, exclude);
+            }
+        }
+    }
+    static getString(resource) {
+        return resource.getBuffer().then((buffer) => buffer.toString(UTF8));
+    }
+    static getJson(resource) {
+        return resource.getBuffer().then((buffer) => JSON.parse(buffer.toString(UTF8)));
+    }
+    static setString(resource, str) {
+        resource.setBuffer(Buffer.from(str, UTF8));
+    }
+    static createResource(filename, projectNamespace, content) {
+        return resourceFactory.createResource({
+            path: this.getResourcePath(projectNamespace, filename),
+            string: content
+        });
+    }
+}
+//# sourceMappingURL=resourceUtil.js.map

package/dist/util/urlUtil.d.ts

@@ -0,0 +1,4 @@
+export default class UrlUtil {
+    static join(relativeUrl: string, parentUrl: string): string;
+    static getResourcePath(url: string): string;
+}

package/dist/util/urlUtil.js

@@ -0,0 +1,18 @@
+import { URI } from "../../dist/bundle.js";
+export default class UrlUtil {
+    static join(relativeUrl, parentUrl) {
+        // Remove trailing slash, otherwise url join can be incorrect Remove
+        // trailing slash, otherwise url join can be incorrect Annotation URLs
+        // defined in manifest might end with .../$value/ or .../$value and both
+        // are accepted by Gateway and produce the same content with same
+        // relative URLs. The first case is actually incorrect and we have to
+        // sanitize the same way as UI5. We also trim urls domain/host, because
+        // we need to substitute it with destination to download later.
+        return new URI(relativeUrl).absoluteTo(parentUrl.replace(/\/$/, "")).toString();
+    }
+    static getResourcePath(url) {
+        // Trim urls domain/host.
+        return URI.parse(url).path;
+    }
+}
+//# sourceMappingURL=urlUtil.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,21 @@
+import * as convert from "xml-js";
+const XML_OPTIONS = { compact: true, spaces: 4 };
+export default 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;", "\"")
+        }));
+    }
+}
+//# sourceMappingURL=xmlUtil.js.map

package/dist/util/zipUtil.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function unzipZipEntries(zip: Buffer): Promise<Map<string, string>>;

package/dist/util/zipUtil.js

@@ -0,0 +1,16 @@
+import AdmZip from "adm-zip";
+export async function unzipZipEntries(zip) {
+    let admZip;
+    try {
+        admZip = new AdmZip(zip);
+        const entries = admZip.getEntries();
+        return mapEntries(entries);
+    }
+    catch (error) {
+        throw new Error("Failed to parse zip content from HTML5 Repository: " + error.message);
+    }
+}
+function mapEntries(entries) {
+    return new Map(entries.filter(entry => !entry.isDirectory).map(entry => [entry.entryName, entry.getData().toString("utf8")]));
+}
+//# sourceMappingURL=zipUtil.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ui5/task-adaptation",
-    "version": "1.3.1",
+    "version": "1.3.3",
     "description": "Custom task for ui5-builder which allows building UI5 Flexibility Adaptation Projects for SAP BTP, Cloud Foundry environment",
     "main": "index.js",
     "scripts": {
@@ -9,7 +9,7 @@
         "dev": "UI5_LOG_LVL=error mocha --no-timeouts --no-warnings --import=tsx --loader=esmock 'test/**/*.spec.ts'",
         "perf": "UI5_LOG_LVL=error mocha --no-timeouts --no-warnings --import=tsx --loader=esmock 'test/**/*.perf.ts'",
         "coverage": "npx c8 npm run dev",
-        "preversion": "",
+        "preversion": "npm test",
         "version": "git-chglog --next-tag v$npm_package_version -o CHANGELOG.md && git add CHANGELOG.md",
         "prepublishOnly": "git push --follow-tags",
         "release-note": "git-chglog -c .chglog/release-config.yml v$npm_package_version",
@@ -33,6 +33,10 @@
     "author": "SAP SE",
     "license": "Apache-2.0",
     "dependencies": {
+        "@sap-ux/axios-extension": "^1.13.1",
+        "@sap-ux/btp-utils": "^0.14.4",
+        "@sap-ux/store": "^0.6.0",
+        "@sap-ux/system-access": "^0.4.2",
         "@sap/cf-tools": "^3.2.0",
         "@ui5/fs": "^3.0.5",
         "@ui5/logger": "^3.0.0",
@@ -104,7 +108,8 @@
             "scripts/git/octokitUtil.ts",
             "*/**/*.d.ts",
             "src/annotations/comparator/diffCase.ts",
-            "src/annotations/transformers/transformer.ts"
+            "src/annotations/transformers/transformer.ts",
+            "src/model/configuration.ts"
         ],
         "check-coverage": true,
         "statements": 85,