@ui5/task-adaptation 1.5.2 → 1.5.4

package/rollup/bundler.ts

@@ -0,0 +1,35 @@
+import * as rollup from "rollup";
+import * as builtins from "builtin-modules";
+import ui5 from "./ui5Resolve.js";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+
+
+export default abstract class Bundler {
+
+    static async run(resources: Map<string, any>, input: string, output: string, skipTransformation: string[] = []): Promise<void> {
+        if (!skipTransformation.includes(input)) {
+            skipTransformation.push(input);
+        }
+        const inputOptions = <rollup.RollupOptions>{
+            input,
+            plugins: [
+                ui5({
+                    resources,
+                    skipTransformation,
+                    output
+                }),
+                nodeResolve({
+                    preferBuiltins: true
+                })
+            ],
+            external: builtins
+        };
+        const bundle = await rollup.rollup(inputOptions);
+        const outputOptions = <rollup.RollupOptions>{
+            file: output,
+            format: "esm"
+        };
+        await bundle.write(outputOptions);
+        await bundle.close();
+    }
+}

package/rollup/overrides/sap/base/config.js

@@ -0,0 +1,59 @@
+/*!
+* ${copyright}
+*/
+sap.ui.define([
+], (
+) => {
+    "use strict";
+
+    /**
+     * The base Configuration.
+     *
+     * @author SAP SE
+     * @version ${version}
+     * @private
+     * @ui5-restricted sap.ui.core, sap.fl, sap.ui.intergration, sap.ui.export
+     * @alias module:sap/base/config
+     * @borrows module:sap/base/config/_Configuration.get as get
+     * @borrows module:sap/base/config/_Configuration.Type as Type
+     * @namespace
+     */
+
+    const _Configuration = { _: {} };
+
+    const internalConfig = new Map();
+
+    /**
+     * Returns a writable base configuration instance
+     * @returns {module:sap/base/config} The writable base configuration
+     * @private
+     * @ui5-restricted sap.ui.core, sap.fl
+     */
+    _Configuration.getWritableInstance = () => {
+        return {
+            get(obj) {
+                internalConfig.get(obj.name);
+            },
+            set(name, obj) {
+                internalConfig.set(name, obj);
+            }
+        }
+    };
+
+    /**
+     * Attaches the <code>fnFunction</code> event handler to the {@link #event:invalidated invalidated} event
+     *
+     * @param {function} fnFunction The function to be called when the event occurs
+     * @private
+     */
+    function attachInvalidated() {
+    }
+    _Configuration._.attachInvalidated = attachInvalidated;
+
+    const origInvalidate = _Configuration._.invalidate;
+    _Configuration._.invalidate = () => {
+        origInvalidate();
+    };
+
+    return _Configuration;
+});

package/rollup/overrides/sap/ui/fl/apply/_internal/flexObjects/AppDescriptorChange.js

@@ -0,0 +1,68 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2020 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+sap.ui.define([
+], function (
+) {
+    "use strict";
+
+    /**
+     * Flexibility change class. Stores change content and related information.
+     *
+     * @param {object} oFile - File content and admin data
+     *
+     * @class sap.ui.fl.Change
+     * @private
+     * @ui5-restricted
+     * @experimental Since 1.25.0
+     */
+    var AppDescriptorChange = function (content) {
+        this.content = content;
+    };
+
+    /**
+     * Returns the change type.
+     *
+     * @returns {String} Change type of the file, for example <code>LabelChange</code>
+     * @public
+     */
+    AppDescriptorChange.prototype.getChangeType = function () {
+        return this.content?.flexObjectMetadata?.changeType || this.content?.changeType;
+    };
+
+    /**
+     * Gets the layer type for the change.
+     * @returns {string} Layer of the change file
+     *
+     * @public
+     */
+    AppDescriptorChange.prototype.getLayer = function () {
+        return this.content.layer;
+    };
+
+    /**
+     * Returns the content section of the change.
+     * @returns {string} Content of the change file. The content structure can be any JSON.
+     *
+     * @public
+     */
+    AppDescriptorChange.prototype.getContent = function () {
+        return this.content.content;
+    };
+
+    /**
+     * Returns all texts.
+     *
+     * @returns {object} All texts
+     *
+     * @function
+     */
+    AppDescriptorChange.prototype.getTexts = function () {
+        return this.content.texts;
+    };
+
+    return AppDescriptorChange;
+}, true);

package/rollup/overrides/sap/ui/performance/Measurement.js

@@ -0,0 +1,4 @@
+export default class PerfMeasurement {
+	static average() {}
+	static end() {}
+}

package/rollup/project/package.json

@@ -0,0 +1,4 @@
+{
+    "name": "rollup",
+    "version": "1.0.0"
+}

package/rollup/project/ui5.yaml

@@ -0,0 +1,13 @@
+---
+specVersion: "2.2"
+type: application
+metadata:
+  name: rollup
+  allowSapInternal: true
+framework:
+  name: SAPUI5
+  version: 0.0.0
+  libraries:
+    - name: sap.ui.fl
+    - name: sap.suite.ui.generic.template
+    - name: sap.fe.core

package/rollup/project/webapp/manifest.json

@@ -0,0 +1,5 @@
+{
+    "sap.app": {
+        "id": "rollup"
+    }
+}

package/rollup/rollup.ts

@@ -0,0 +1,133 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as semver from "semver";
+import * as yaml from "js-yaml";
+import Bundler from "./bundler.js";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import * as resourceFactory from "@ui5/fs/resourceFactory";
+import { graphFromPackageDependencies } from "@ui5/project/graph";
+import { getLogger } from "@ui5/logger";
+
+const log = getLogger("rollup-plugin-ui5-resolve-task-adaptation");
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const projectPaths = [
+    path.resolve(__dirname, "project")
+];
+const LATEST_VERSION_PLACEHOLDER = "0.0.0";
+
+export default class Builder {
+
+    static async getProjectInfo(projectPaths: string[]) {
+        for (const cwd of projectPaths) {
+            try {
+                const options = <any>{
+                    cwd
+                };
+                const version = this.validateProjectSettings(cwd);
+                if (version === LATEST_VERSION_PLACEHOLDER) {
+                    options.versionOverride = "latest";
+                }
+                return await graphFromPackageDependencies(options);
+            } catch (error: any) {
+                log.info(`${error.message}`);
+            }
+        }
+    }
+
+    static validateProjectSettings(projectPath: string): string {
+        const FRAMEWORK_TYPES = ["OpenUI5", "SAPUI5"];
+        const content = fs.readFileSync(path.join(projectPath, "ui5.yaml"), { encoding: "utf-8" });
+        const yamlJson = <any>yaml.load(content);
+        const framework = yamlJson["framework"];
+        if (!FRAMEWORK_TYPES.includes(framework.name)) {
+            throw new Error(`UI5 framework name is incorrect, possible values: ${FRAMEWORK_TYPES.join(" or ")}`);
+        }
+        if (!semver.valid(framework.version)) {
+            throw new Error(`UI5 framework version should correspond semantic version standard, e.g: 1.85.2`);
+        }
+        return framework.version;
+    }
+
+    static getBundledUI5Version(destination: string) {
+        const bundleFilePath = path.join(process.cwd(), destination);
+        if (fs.existsSync(bundleFilePath)) {
+            const bundle = fs.readFileSync(bundleFilePath, { encoding: "utf-8" });
+            const version = bundle.substring(2, bundle.indexOf("\n"));
+            return semver.coerce(version);
+        }
+    }
+
+    static async getResources(namespaces: Map<string, string[]>, projectGraph: any): Promise<Map<string, any>> {
+        const fsBasePaths = new Set<string>();
+        const adapters = new Map<string, any>();
+        for (const project of [...projectGraph.getProjects("rollup")]) {
+            const fsBasePath = project.getSourcePath();
+            if (!fsBasePaths.has(fsBasePath)) {
+                adapters.set(project.getNamespace(), resourceFactory.createReader({
+                    fsBasePath,
+                    virBasePath: "/resources/"
+                }));
+                fsBasePaths.add(fsBasePath);
+            }
+        }
+
+        const resources = new Map<string, any>();
+        for (const [namespace, adapter] of adapters.entries()) {
+            const patterns = namespaces.get(namespace);
+            if (patterns) {
+                for (const pattern of patterns) {
+                    const result = await adapter.byGlob(pattern) as any[];
+                    result.forEach(resource => resources.set(resource.getPath(), resource));
+                }
+            }
+        }
+
+        return resources;
+    }
+
+    static copyTypeDefinition() {
+        fs.copyFileSync(path.join(__dirname, "bundle.d.ts"), path.join(process.cwd(), "dist", "bundle.d.ts"))
+    }
+
+    static async run(): Promise<void> {
+        const project = await this.getProjectInfo(projectPaths);
+        if (!project) {
+            throw new Error("ui5.yaml is not found or incorrect");
+        }
+        const namespaces = new Map([
+            ["sap/fe/core", [
+                "/resources/sap/fe/core/**"
+            ]],
+            ["sap/ui/fl", [
+                "/resources/sap/ui/fl/**"
+            ]],
+            ["sap/ui/core", [
+                "/resources/ui5loader-autoconfig.js",
+                "/resources/sap/base/**",
+                "/resources/sap/ui/{base,thirdparty,model,util}/**"
+            ]],
+            ["sap/suite/ui/generic/template", [
+                "/resources/sap/suite/ui/generic/template/**"
+            ]]
+        ]);
+        const resources = await this.getResources(namespaces, project);
+        await Bundler.run(
+            resources,
+            "bundleDefinition.js",
+            "./dist/bundle.js",
+            [
+                "sap/ui/performance/Measurement"
+            ]
+        );
+        this.copyTypeDefinition();
+    }
+}
+
+if (process.argv.length === 2) {
+    const start = Date.now();
+    await Builder.run();
+    log.info(`Bundled in ${Date.now() - start} ms`);
+}

package/rollup/ui5Resolve.ts

@@ -0,0 +1,145 @@
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+
+//@ts-ignore
+import convertAMDtoES6 from "@buxlabs/amd-to-es6";
+import convertAMDtoESM from "./amdToEsm.js";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getLogger } from "@ui5/logger";
+
+const log = getLogger("rollup-plugin-ui5-resolve-task-adaptation");
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+
+interface TransformCase {
+    accept(code: string, id: string): string;
+}
+
+class UriTransformCase implements TransformCase {
+    accept(code: string, id: string) {
+        if (id !== "sap/ui/thirdparty/URI") {
+            return code;
+        }
+        const header = code.substring(0, code.indexOf("(function"));
+        const neededCode = code.substring(code.indexOf("root) {") + 8, code.lastIndexOf("}));"))
+            .replace(/root/g, "window");
+        return header + "define('sap/ui/thirdparty/URI', [], function () {" + neededCode + "});";
+    }
+}
+
+
+export default function (options: any) {
+
+    const skipTransformation = (id: string) => !options.skipTransformation?.includes(id);
+
+    return {
+
+        name: "ui5-resolve",
+
+        /*
+         * Right before writing result to dist
+         */
+        renderChunk: (code: string) => {
+            return `var window = {};\n${code}`;
+        },
+
+
+        resolveId: (source: string, importer: string) => {
+            log.verbose(`resolveId: ${source} from ${importer}`);
+            if (importer && source.startsWith(".")) {
+                source = path.posix.join(path.dirname(importer), source);
+            }
+            log.verbose(" --> resolve to: " + source);
+            return source;
+        },
+
+
+        load: async (id: string) => {
+            log.verbose(`load: ${id}`);
+
+            const localFile = path.join(__dirname, id);
+            if (fs.existsSync(localFile)) {
+                log.info(`Bundle definition "${id}"`);
+                return fs.readFileSync(localFile, {
+                    encoding: "utf8"
+                });
+            }
+
+            const localOverride = path.resolve(__dirname, "overrides", id + ".js");
+            if (fs.existsSync(localOverride)) {
+                log.info(`Override with "${id}"`);
+                return fs.readFileSync(localOverride, { encoding: "utf8" });
+            }
+            const filepath = `/resources/${id}.js`;
+            if (options.resources.has(filepath)) {
+                return await options.resources.get(filepath).getString();
+            }
+        },
+
+
+        transform: (code: string, id: string): string | undefined => {
+            const skipped = !skipTransformation(id);
+            log.verbose(`transform: ${id} ${skipped ? "skipped" : ""}`);
+            if (skipped) {
+                return;
+            }
+
+            code = replaceRequireAsync(code);
+            code = transform(code, id);
+
+            code = code
+                .replace(/sap\.ui\.define/g, "define")
+                .replace(/\, \/\* bExport\= \*\/ true\)/g, ")")
+                .replace(/},.*(true|false)\);$/g, "});")
+                .replace(/},.*(true|false)\);(\n\/\/# sourceMappingURL=)*/g, "});\n//# sourceMappingURL=");
+            try {
+                return convertAMDtoES6(code);
+            } catch (_: any) {
+                return convertAMDtoESM(code);
+            }
+        }
+
+    };
+};
+
+
+function transform(code: string, id: string) {
+    const transformers = [
+        new UriTransformCase()
+    ];
+    for (const transformer of transformers) {
+        code = transformer.accept(code, id);
+    }
+    return code;
+}
+
+
+function replaceRequireAsync(code: string) {
+    const requireAsyncPattern = /requireAsync((.bind\(this, ")|(\("))+(?<url>[\/\w]*)"\)/mg;
+    let match, defineUrls = new Array<string>(), defineVars = new Array<string>(), matches = new Map();
+    // eslint-disable-next-line no-cond-assign
+    while (match = requireAsyncPattern.exec(code)) {
+        if (match.groups?.url) {
+            const varaibleName = match.groups.url.split("/").pop() + crypto.randomBytes(16).toString("hex");
+            defineUrls.push(`"${match.groups.url}"`);
+            defineVars.push(varaibleName);
+            const value = match[0].includes("requireAsync.bind")
+                ? `() => Promise.resolve(${varaibleName})`
+                : varaibleName;
+            matches.set(match[0], value);
+        }
+    }
+    if (defineUrls.length > 0 && defineVars.length > 0) {
+        matches.forEach((value, key) => code = code.replace(key, value));
+        code = replaceRequireAsyncWith(code, `"sap/ui/fl/requireAsync"`, defineUrls);
+        code = replaceRequireAsyncWith(code, "requireAsync", defineVars);
+    }
+    return code;
+}
+
+
+function replaceRequireAsyncWith(code: string, requireAsyncSearchKeyword: string, inserts: string[]) {
+    return code.replace(requireAsyncSearchKeyword, inserts.join(",\n\t"));
+}