@ui5/task-adaptation 1.0.15 → 1.0.16

package/dist/util/cfUtil.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const CFLocal = require("@sap/cf-tools/out/src/cf-local");
 const CFToolsCli = require("@sap/cf-tools/out/src/cli");
@@ -22,58 +13,51 @@ class CFUtil {
      * @return {Promise<IServiceKeys>} promise with service keys
      * @memberof CFUtil
      */
-    static getServiceInstanceKeys(getServiceInstanceParams, createServiceInstanceParams) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            let serviceInstances = yield this.getServiceInstance(getServiceInstanceParams);
-            if (!((serviceInstances === null || serviceInstances === void 0 ? void 0 : serviceInstances.length) > 0) && createServiceInstanceParams) {
-                yield this.createService(createServiceInstanceParams);
-                serviceInstances = yield this.getServiceInstance(getServiceInstanceParams);
-            }
-            if (!((serviceInstances === null || serviceInstances === void 0 ? void 0 : serviceInstances.length) > 0)) {
-                throw new Error(`Cannot find '${(_a = getServiceInstanceParams.names) === null || _a === void 0 ? void 0 : _a.join(", ")}' service in current space: ${(_b = getServiceInstanceParams.spaceGuids) === null || _b === void 0 ? void 0 : _b.join(", ")}`);
-            }
-            // we can use any instance in the list to connect to HTML5 Repo
-            log.verbose(`Use '${serviceInstances[0].name}' HTML5 Repo Runtime service instance`);
-            const serviceKeys = yield this.getOrCreateServiceKeys(serviceInstances[0]);
-            if (!((serviceKeys === null || serviceKeys === void 0 ? void 0 : serviceKeys.length) > 0)) {
-                throw new Error(`Cannot get service keys for '${(_c = getServiceInstanceParams.names) === null || _c === void 0 ? void 0 : _c.join(", ")}' service in current space: ${(_d = getServiceInstanceParams.spaceGuids) === null || _d === void 0 ? void 0 : _d.join(", ")}`);
-            }
-            return {
-                credentials: serviceKeys[0].credentials,
-                serviceInstance: serviceInstances[0]
-            };
-        });
+    static async getServiceInstanceKeys(getServiceInstanceParams, createServiceInstanceParams) {
+        let serviceInstances = await this.getServiceInstance(getServiceInstanceParams);
+        if (!(serviceInstances?.length > 0) && createServiceInstanceParams) {
+            await this.createService(createServiceInstanceParams);
+            serviceInstances = await this.getServiceInstance(getServiceInstanceParams);
+        }
+        if (!(serviceInstances?.length > 0)) {
+            throw new Error(`Cannot find '${getServiceInstanceParams.names?.join(", ")}' service in current space: ${getServiceInstanceParams.spaceGuids?.join(", ")}`);
+        }
+        // we can use any instance in the list to connect to HTML5 Repo
+        log.verbose(`Use '${serviceInstances[0].name}' HTML5 Repo Runtime service instance`);
+        const serviceKeys = await this.getOrCreateServiceKeys(serviceInstances[0]);
+        if (!(serviceKeys?.length > 0)) {
+            throw new Error(`Cannot get service keys for '${getServiceInstanceParams.names?.join(", ")}' service in current space: ${getServiceInstanceParams.spaceGuids?.join(", ")}`);
+        }
+        return {
+            credentials: serviceKeys[0].credentials,
+            serviceInstance: serviceInstances[0]
+        };
     }
-    static createService(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            log.verbose(`Creating a service instance with parameters: ${JSON.stringify(params)}`);
-            const resources = yield 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}'`);
-            }
-            try {
-                yield CFLocal.cfCreateService(publicPlan.guid, params.serviceName, params.parameters, params.tags);
-            }
-            catch (error) {
-                throw new Error(`Cannot create a service instance '${params.serviceName}' in space '${params.spaceGuid}': ${error.message}`);
-            }
-        });
+    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}'`);
+        }
+        try {
+            await CFLocal.cfCreateService(publicPlan.guid, params.serviceName, params.parameters, params.tags);
+        }
+        catch (error) {
+            throw new Error(`Cannot create a service instance '${params.serviceName}' in space '${params.spaceGuid}': ${error.message}`);
+        }
     }
-    static getOrCreateServiceKeys(serviceInstance) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const credentials = yield this.getServiceKeys(serviceInstance.guid);
-            if (credentials.length === 0) {
-                const serviceKeyName = serviceInstance.name + "_key";
-                log.info(`Creating service key '${serviceKeyName}' for service instance '${serviceInstance.name}'`);
-                yield this.createServiceKey(serviceInstance.name, serviceKeyName);
-            }
-            else {
-                return credentials;
-            }
-            return this.getServiceKeys(serviceInstance.guid);
-        });
+    static async getOrCreateServiceKeys(serviceInstance) {
+        const credentials = await this.getServiceKeys(serviceInstance.guid);
+        if (credentials.length === 0) {
+            const serviceKeyName = serviceInstance.name + "_key";
+            log.info(`Creating service key '${serviceKeyName}' for service instance '${serviceInstance.name}'`);
+            await this.createServiceKey(serviceInstance.name, serviceKeyName);
+        }
+        else {
+            return credentials;
+        }
+        return this.getServiceKeys(serviceInstance.guid);
     }
     static getServiceKeys(serviceInstanceGuid) {
         return CFLocal.cfGetInstanceCredentials({
@@ -85,78 +69,68 @@ class CFUtil {
             throw Error("Failed to get service credentials: " + error.message);
         });
     }
-    static createServiceKey(serviceInstanceName, serviceKeyName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return this.cfExecute(["create-service-key", serviceInstanceName, serviceKeyName]);
-            }
-            catch (error) {
-                throw new Error(`Couldn't create a service key for instance: ${serviceInstanceName}`);
-            }
-        });
+    static async createServiceKey(serviceInstanceName, serviceKeyName) {
+        try {
+            return this.cfExecute(["create-service-key", serviceInstanceName, serviceKeyName]);
+        }
+        catch (error) {
+            throw new Error(`Couldn't create a service key for instance: ${serviceInstanceName}`);
+        }
     }
-    static getServiceInstance(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const PARAM_MAP = {
-                spaceGuids: "space_guids",
-                planNames: "service_plan_names",
-                names: "names"
-            };
-            const parameters = Object.entries(params)
-                .filter(([_, value]) => (value === null || value === void 0 ? void 0 : value.length) && (value === null || value === void 0 ? void 0 : value.length) > 0)
-                .map(([key, value]) => `${PARAM_MAP[key]}=${value === null || value === void 0 ? void 0 : value.join(",")}`);
-            const uri = `/v3/service_instances` + (parameters.length > 0 ? `?${parameters.join("&")}` : "");
-            const resources = yield this.requestCfApi(uri);
-            return resources.map((service) => ({
-                name: service.name,
-                guid: service.guid
-            }));
-        });
+    static async getServiceInstance(params) {
+        const PARAM_MAP = {
+            spaceGuids: "space_guids",
+            planNames: "service_plan_names",
+            names: "names"
+        };
+        const parameters = Object.entries(params)
+            .filter(([_, value]) => value?.length && value?.length > 0)
+            .map(([key, value]) => `${PARAM_MAP[key]}=${value?.join(",")}`);
+        const uri = `/v3/service_instances` + (parameters.length > 0 ? `?${parameters.join("&")}` : "");
+        const resources = await this.requestCfApi(uri);
+        return resources.map((service) => ({
+            name: service.name,
+            guid: service.guid
+        }));
     }
-    static requestCfApi(url) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.cfExecute(["curl", url]);
-            const json = this.parseJson(response);
-            const resources = json === null || json === void 0 ? void 0 : json.resources;
-            const totalPages = (_a = json === null || json === void 0 ? void 0 : json.pagination) === null || _a === void 0 ? void 0 : _a.total_pages;
-            if (totalPages > 1) {
-                const pages = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);
-                return resources.concat(yield Promise.all(pages.map((page) => __awaiter(this, void 0, void 0, function* () {
-                    var _b;
-                    const uri = `${url}${url.includes("?") ? "&" : "?"}page=${page}`;
-                    const response = yield this.cfExecute(["curl", uri]);
-                    return ((_b = this.parseJson(response)) === null || _b === void 0 ? void 0 : _b.resources) || [];
-                }))).then(resources => [].concat(...resources)));
-            }
-            return resources;
-        });
+    static async requestCfApi(url) {
+        const response = await this.cfExecute(["curl", url]);
+        const json = this.parseJson(response);
+        const resources = json?.resources;
+        const totalPages = json?.pagination?.total_pages;
+        if (totalPages > 1) {
+            const pages = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);
+            return resources.concat(await Promise.all(pages.map(async (page) => {
+                const uri = `${url}${url.includes("?") ? "&" : "?"}page=${page}`;
+                const response = await this.cfExecute(["curl", uri]);
+                return this.parseJson(response)?.resources || [];
+            })).then(resources => [].concat(...resources)));
+        }
+        return resources;
     }
     static getOAuthToken() {
         return this.cfExecute(["oauth-token"]);
     }
-    static cfExecute(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const MAX_ATTEMPTS = 3;
-            const errors = new Set();
-            for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
-                try {
-                    const response = yield CFToolsCli.Cli.execute(params, { env: { "CF_COLOR": "false" } });
-                    if (response.exitCode === 0) {
-                        const errorValues = [...errors.values()];
-                        if ((errorValues === null || errorValues === void 0 ? void 0 : errorValues.length) > 0) {
-                            log.verbose(this.errorsToString(errorValues));
-                        }
-                        return response.stdout;
+    static async cfExecute(params) {
+        const MAX_ATTEMPTS = 3;
+        const errors = new Set();
+        for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+            try {
+                const response = await CFToolsCli.Cli.execute(params, { env: { "CF_COLOR": "false" } });
+                if (response.exitCode === 0) {
+                    const errorValues = [...errors.values()];
+                    if (errorValues?.length > 0) {
+                        log.verbose(this.errorsToString(errorValues));
                     }
-                    errors.add(response.error || response.stderr);
-                }
-                catch (error) {
-                    errors.add(error.message);
+                    return response.stdout;
                 }
+                errors.add(response.error || response.stderr);
             }
-            throw new Error(`Failed to send request with parameters '${JSON.stringify(params)}': ${this.errorsToString([...errors.values()])}`);
-        });
+            catch (error) {
+                errors.add(error.message);
+            }
+        }
+        throw new Error(`Failed to send request with parameters '${JSON.stringify(params)}': ${this.errorsToString([...errors.values()])}`);
     }
     static errorsToString(errors) {
         return errors.length > 1
@@ -178,24 +152,21 @@ class CFUtil {
      * @return {Promise<string>} promise with space guid
      * @memberof CFUtil
      */
-    static getSpaceGuid(spaceGuid) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (spaceGuid == null) {
-                const spaceName = (_a = (yield CFLocal.cfGetTarget())) === null || _a === void 0 ? void 0 : _a.space;
-                if (spaceName) {
-                    const resources = yield this.requestCfApi(`/v3/spaces?names=${spaceName}`);
-                    for (const resource of resources) {
-                        spaceGuid = resource.guid;
-                        break;
-                    }
+    static async getSpaceGuid(spaceGuid) {
+        if (spaceGuid == null) {
+            const spaceName = (await CFLocal.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;
-        });
+        }
+        if (spaceGuid == null) {
+            throw new Error("Please login to Cloud Foundry with 'cf login' and try again");
+        }
+        return spaceGuid;
     }
 }
 exports.default = CFUtil;

package/dist/util/commonUtil.js

@@ -8,7 +8,7 @@ exports.replaceDots = replaceDots;
 function validateObject(options, properties, message) {
     for (const property of properties) {
         if (!options[property]) {
-            throw new Error(`'${property}' ${message}`);
+            throw new Error(`'${String(property)}' ${message}`);
         }
     }
 }

package/dist/util/requestUtil.d.ts

@@ -1,5 +1,8 @@
-/// <reference types="node" />
+import { IAuth } from "../model/types";
 export default class RequestUtil {
-    static get(uri: string, options: any): Promise<any>;
-    static download(token: string, appHostId: string, uri: string): Promise<Buffer>;
+    static head(url: string, auth?: IAuth): Promise<any>;
+    static get(url: string, options?: any, auth?: IAuth): Promise<any>;
+    static request(url: string, method: Function, auth?: IAuth, options?: any): Promise<any>;
+    private static handleError;
+    static retryWithAuth<T>(requestWithoutAuth: Function, requestWithAuth: Function): Promise<T>;
 }

package/dist/util/requestUtil.js

@@ -1,33 +1,52 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const axios_1 = require("axios");
+const noAuthorizationProvidedError_1 = require("../model/noAuthorizationProvidedError");
 class RequestUtil {
-    static get(uri, options) {
-        return axios_1.default.get(uri, options).then(response => response.data);
+    static async head(url, auth) {
+        return this.request(url, axios_1.default.head, auth);
     }
-    static download(token, appHostId, uri) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!token) {
-                throw new Error("HTML5 token is undefined");
+    static async get(url, options, auth) {
+        return this.request(url, axios_1.default.get, auth, options);
+    }
+    static async request(url, method, auth, options) {
+        try {
+            return await method(url, { auth, ...options })
+                .then((response) => response.data);
+        }
+        catch (error) {
+            this.handleError(error, url);
+        }
+    }
+    static handleError(error, uri) {
+        if (error.response) {
+            // HTTP Status Code > 2xx
+            if (error.response.status === 401) {
+                throw new noAuthorizationProvidedError_1.default(uri);
+            }
+            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}`);
+        }
+    }
+    static async retryWithAuth(requestWithoutAuth, requestWithAuth) {
+        try {
+            return await requestWithoutAuth();
+        }
+        catch (error) {
+            if (error instanceof noAuthorizationProvidedError_1.default) {
+                return await requestWithAuth();
+            }
+            else {
+                throw error;
             }
-            return axios_1.default.get(uri, {
-                responseType: "arraybuffer",
-                headers: {
-                    "Content-Type": "application/json",
-                    "Authorization": "Bearer " + token,
-                    "x-app-host-id": appHostId
-                }
-            }).then(response => response.data);
-        });
+        }
     }
 }
 exports.default = RequestUtil;

package/dist/util/resourceUtil.d.ts

@@ -1,13 +1,5 @@
-import { IConfiguration } from "../model/types";
 export default class ResourceUtil {
-    static METADATA_FILENAME: string;
-    static readTempMetadata(configuration: IConfiguration): any;
     static getRootFolder(projectNamespace?: string): string;
-    static writeTemp(configuration: IConfiguration, files: Map<string, string>): Promise<void[]>;
-    static readTemp(configuration: IConfiguration): Promise<Map<string, string>>;
-    private static getBaseAppTempFolder;
-    private static getTempId;
-    static deleteTemp(configuration: IConfiguration): void;
-    private static normalizeId;
-    static fetchFiles(rootFolder: string, folder: string, baseAppFiles: Map<string, string>): void;
+    static write(dir: string, files: Map<string, string>): Promise<void[]>;
+    static read(rootFolder: string, folder: string, files: Map<string, string>, exclude?: string[]): void;
 }

package/dist/util/resourceUtil.js

@@ -1,27 +1,9 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = require("fs");
 const path = require("path");
-const rimraf = require("rimraf");
-const tempFolder = require('temp-dir');
 const resourceFactory = require("@ui5/fs/lib/resourceFactory");
 class ResourceUtil {
-    static readTempMetadata(configuration) {
-        const baseAppTempFolder = this.getBaseAppTempFolder(configuration);
-        const metadataPath = path.resolve(baseAppTempFolder, this.METADATA_FILENAME);
-        if (fs.existsSync(metadataPath)) {
-            return JSON.parse(fs.readFileSync(metadataPath, { encoding: "utf-8" }));
-        }
-    }
     static getRootFolder(projectNamespace) {
         const newPath = ["/resources"];
         if (projectNamespace) {
@@ -29,11 +11,9 @@ class ResourceUtil {
         }
         return path.join(...newPath);
     }
-    static writeTemp(configuration, files) {
-        const distTempFolder = this.getBaseAppTempFolder(configuration);
-        rimraf.sync(distTempFolder);
+    static write(dir, files) {
         const fsTarget = resourceFactory.createAdapter({
-            fsBasePath: distTempFolder,
+            fsBasePath: dir,
             virBasePath: "/"
         });
         const promises = [];
@@ -43,43 +23,20 @@ class ResourceUtil {
         });
         return Promise.all(promises);
     }
-    static readTemp(configuration) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const baseAppTempFolder = this.getBaseAppTempFolder(configuration);
-            const baseAppFiles = new Map();
-            if (fs.existsSync(baseAppTempFolder)) {
-                this.fetchFiles(baseAppTempFolder, baseAppTempFolder, baseAppFiles);
-            }
-            return baseAppFiles;
-        });
-    }
-    static getBaseAppTempFolder(configuration) {
-        return path.join(tempFolder, this.getTempId(configuration));
-    }
-    static getTempId({ appHostId, appName, appVersion }) {
-        return this.normalizeId(`ui5-task-adaptation-${appHostId}-${appName}-${appVersion}`);
-    }
-    static deleteTemp(configuration) {
-        rimraf.sync(this.getBaseAppTempFolder(configuration));
-    }
-    static normalizeId(id) {
-        return id.replace(/\/\\/g, "_");
-    }
-    static fetchFiles(rootFolder, folder, baseAppFiles) {
+    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() && !entryPath.endsWith(this.METADATA_FILENAME)) {
+            if (stats.isFile() && !exclude.some(filepath => entryPath.endsWith(filepath))) {
                 const normalized = entryPath.substring(rootFolder.length);
-                baseAppFiles.set(normalized, fs.readFileSync(entryPath, { encoding: "utf-8" }));
+                files.set(normalized, fs.readFileSync(entryPath, { encoding: "utf-8" }));
             }
             else if (stats.isDirectory()) {
-                this.fetchFiles(rootFolder, entryPath, baseAppFiles);
+                this.read(rootFolder, entryPath, files, exclude);
             }
         }
     }
 }
 exports.default = ResourceUtil;
-ResourceUtil.METADATA_FILENAME = "html5metadata.json";
 //# sourceMappingURL=resourceUtil.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,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unzipZipEntries = void 0;
+const AdmZip = require("adm-zip");
+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);
+    }
+}
+exports.unzipZipEntries = unzipZipEntries;
+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.0.15",
+    "version": "1.0.16",
     "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 ./dist/bundle.js",
+        "rollup": "ts-node scripts/rollup.ts",
         "build": "npm run rollup && tsc -p ./"
     },
     "repository": {
@@ -42,11 +42,14 @@
         "amdextract": "^3.0.0",
         "axios": "^0.25.0",
         "builtin-modules": "^3.2.0",
+        "dotenv": "^16.0.3",
         "js-yaml": "^4.1.0",
+        "json-diff": "^1.0.6",
         "rimraf": "^3.0.2",
         "rollup": "^2.56.3",
         "semver": "^7.3.5",
-        "temp-dir": "^2.0.0"
+        "temp-dir": "^2.0.0",
+        "xml-js": "^1.6.11"
     },
     "devDependencies": {
         "@istanbuljs/nyc-config-typescript": "^1.0.1",
@@ -54,6 +57,8 @@
         "@types/chai": "^4.2.21",
         "@types/chai-as-promised": "^7.1.4",
         "@types/js-yaml": "^4.0.3",
+        "@types/json-diff": "^0.9.1",
+        "@types/lodash": "^4.14.196",
         "@types/mocha": "^9.1.0",
         "@types/rimraf": "^3.0.2",
         "@types/semver": "^7.3.8",

package/scripts/bundler.ts

@@ -0,0 +1,75 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as semver from "semver";
+import * as rollup from "rollup";
+import * as builtins from "builtin-modules";
+import ui5 from "./rollup/ui5Resolve";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+
+const log = require("@ui5/logger").getLogger("rollup-plugin-ui5-resolve-task-adaptation");
+
+export default abstract class Bundler {
+
+    static async run(project: any, input: string, output: string, namespace: string,
+        assets: string[], skipTransformation?: string[]): Promise<void> {
+        if (skipTransformation == null) {
+            skipTransformation = [];
+        }
+        if (skipTransformation.includes(input) === false) {
+            skipTransformation.push(input);
+        }
+        const bundledUI5Version = this.getBundledUI5Version(output);
+        const ui5version = this.getVersion(project, namespace);
+        if (bundledUI5Version == null || ui5version && semver.neq(bundledUI5Version, ui5version)) {
+            if (ui5version) {
+                log.info(`Using UI5 version ${ui5version.toString()} to bundle`);
+            }
+            await this.bundle(project, input, output, assets, skipTransformation, ui5version);
+        } else {
+            log.info(`UI5 version ${bundledUI5Version!.toString()} is already bundled`);
+        }
+    }
+
+    private static async bundle(project: any, input: string, output: string,
+        assets: string[], skipTransformation: string[], ui5version: string): Promise<void> {
+        const inputOptions = <rollup.RollupOptions>{
+            input,
+            plugins: [
+                ui5({
+                    assets,
+                    skipTransformation,
+                    output,
+                    project,
+                    ui5version
+                }),
+                nodeResolve({
+                    preferBuiltins: true
+                })
+            ],
+            external: builtins
+        };
+        const bundle = await rollup.rollup(inputOptions);
+
+        const outputOptions = <rollup.RollupOptions>{
+            file: output,
+            format: "commonjs"
+        };
+        await bundle.write(outputOptions);
+        await bundle.close();
+    }
+
+    private static getBundledUI5Version(output: string) {
+        const bundleFilePath = path.join(process.cwd(), output);
+        if (fs.existsSync(bundleFilePath)) {
+            const bundle = fs.readFileSync(bundleFilePath, { encoding: "utf-8" });
+            const version = bundle.substring(2, bundle.indexOf("\n"));
+            return semver.coerce(version);
+        }
+    }
+
+    private static getVersion(project: any, namespace: string): string {
+        const isModule = (dependency: any) => dependency.id.endsWith(namespace);
+        const sapUiFlDependency = project.dependencies.find(isModule);
+        return sapUiFlDependency && sapUiFlDependency.version;
+    }
+}