@ui5/task-adaptation 1.5.2 → 1.6.0

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"));
+}

package/scripts/publish.ts

@@ -0,0 +1,256 @@
+import { promises as fs } from "fs";
+import path from "path";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { Octokit } from "@octokit/rest";
+import { retry } from "@octokit/plugin-retry";
+
+const OctokitClass = Octokit.plugin(retry);
+
+
+/**
+ * Recursively get all file paths in the workspace root, excluding:
+ *   - test/lib/integration
+ *   - test/fixtures
+ *   - test/expected
+ *   - test/lib/index.perf.ts
+ * Returns relative paths from the root.
+ */
+async function getAllRootFilesExceptTestExclusions(root: string): Promise<string[]> {
+    const excludeDirs = [
+        "test/lib/integration",
+        "test/fixtures",
+        "test/expected",
+        ".git",
+        "coverage",
+        ".DS_Store",
+        "node_modules",
+        ".nyc_output",
+        "coverage",
+        "dist",
+        "dist-debug",
+        "dist.zip",
+        ".env",
+        "test/resources/metadata/download"
+    ];
+    const excludeFiles = [
+        "test/lib/index.perf.ts",
+        "scripts/test-integration-prep.sh",
+        "Jenkinsfile"
+    ];
+
+    async function walk(dir: string): Promise<string[]> {
+        const dirents = await fs.readdir(dir, { withFileTypes: true });
+        const files: string[] = [];
+        for (const dirent of dirents) {
+            const relPath = path.relative(root, path.join(dir, dirent.name));
+            if (excludeDirs.some(ex => relPath === ex || relPath.startsWith(ex + path.sep))) {
+                continue;
+            }
+            if (excludeFiles.includes(relPath)) {
+                continue;
+            }
+            if (dirent.isDirectory()) {
+                files.push(...await walk(path.join(dir, dirent.name)));
+            } else {
+                files.push(relPath);
+            }
+        }
+        return files;
+    }
+    return walk(root);
+}
+
+const FILES = await getAllRootFilesExceptTestExclusions(process.cwd());
+
+
+interface PublishArgs {
+    p?: string;
+    dryRun?: boolean;
+    tag?: string;
+    branch?: string;
+    [key: string]: unknown;
+}
+
+async function publish() {
+    const argv = yargs(hideBin(process.argv))
+        .option("p", {
+            type: "string",
+            description: "GitHub token (-p)",
+            alias: "p"
+        })
+        .option("dryRun", {
+            type: "boolean",
+            description: "Run without publishing",
+            default: false
+        })
+        .option("tag", {
+            type: "string",
+            description: "Publish with a specific tag"
+        })
+        .option("branch", {
+            type: "string",
+            description: "Branch to update (default: main)",
+            default: "main",
+            alias: "b"
+        })
+        .help()
+        .alias("h", "help")
+        .parseSync() as PublishArgs;
+
+    if (argv.dryRun) {
+        console.log("Dry run: no publishing will be performed.");
+        return;
+    }
+    const auth = argv.p;
+    if (auth) {
+        const octokit = new OctokitClass({ auth });
+        const ORGANIZATION = "SAP";
+        const REPO = "ui5-task-adaptation";
+        await uploadToRepo(octokit, ORGANIZATION, REPO, argv.branch);
+        if (argv.tag) {
+            console.log(`Published with tag: ${argv.tag}`);
+        }
+    } else {
+        console.log("Github token is not provided.");
+    }
+}
+
+
+async function getLatestVersion(): Promise<string> {
+    const pkg = await fs.readFile(path.join(process.cwd(), "package.json"), { encoding: "utf-8" });
+    const pkgJson = JSON.parse(pkg);
+    return pkgJson.version;
+}
+
+
+async function uploadToRepo(
+    octokit: InstanceType<typeof OctokitClass>,
+    org: string,
+    repo: string,
+    branch: string = "main"
+): Promise<void> {
+    const fileBlobs = await Promise.all(Object.values(FILES).map(file => toBlob(octokit, org, repo, path.join(process.cwd(), file))));
+    const currentCommit = await getCurrentCommit(octokit, org, repo, branch);
+    const newTree = await createNewTree(
+        octokit,
+        org,
+        repo,
+        fileBlobs,
+        FILES,
+        currentCommit.treeSha
+    );
+    const currentVersion = await getLatestVersion();
+    const commitMessage = `Release ${currentVersion}`;
+    const newCommit = await createNewCommit(
+        octokit,
+        org,
+        repo,
+        commitMessage,
+        newTree.sha,
+        currentCommit.commitSha
+    );
+    await setBranchToCommit(octokit, org, repo, branch, newCommit.sha);
+}
+
+
+async function getCurrentCommit(
+    octokit: InstanceType<typeof OctokitClass>,
+    org: string,
+    repo: string,
+    branch: string = "main"
+): Promise<{ commitSha: string; treeSha: string }> {
+    const { data: refData } = await octokit.git.getRef({
+        owner: org,
+        repo,
+        ref: `heads/${branch}`,
+    });
+    const commitSha = refData.object.sha
+    const { data: commitData } = await octokit.git.getCommit({
+        owner: org,
+        repo,
+        commit_sha: commitSha,
+    });
+    return {
+        commitSha,
+        treeSha: commitData.tree.sha,
+    }
+}
+
+
+async function toBlob(
+    octokit: InstanceType<typeof OctokitClass>,
+    org: string,
+    repo: string,
+    filePath: string
+): Promise<{ sha: string }> {
+    const content = await fs.readFile(filePath, { encoding: "utf8" });
+    const blobData = await octokit.git.createBlob({
+        owner: org,
+        repo,
+        content,
+        encoding: "utf-8",
+    })
+    return blobData.data;
+}
+
+
+async function createNewTree(
+    octokit: InstanceType<typeof OctokitClass>,
+    owner: string,
+    repo: string,
+    blobs: { sha: string }[],
+    paths: string[],
+    parentTreeSha: string
+): Promise<any> {
+    const tree = blobs.map(({ sha }, i) => ({
+        path: paths[i],
+        mode: "100644" as const,
+        type: "blob" as const,
+        sha,
+    }));
+    const { data } = await octokit.git.createTree({
+        owner,
+        repo,
+        tree,
+        base_tree: parentTreeSha,
+    })
+    return data;
+}
+
+
+async function createNewCommit(
+    octokit: InstanceType<typeof OctokitClass>,
+    org: string,
+    repo: string,
+    message: string,
+    currentTreeSha: string,
+    currentCommitSha: string
+): Promise<any> {
+    const commit = await octokit.git.createCommit({
+        owner: org,
+        repo,
+        message,
+        tree: currentTreeSha,
+        parents: [currentCommitSha],
+    });
+    return commit.data;
+};
+
+
+async function setBranchToCommit(
+    octokit: InstanceType<typeof OctokitClass>,
+    org: string,
+    repo: string,
+    branch: string = "main",
+    commitSha: string
+): Promise<any> {
+    return octokit.git.updateRef({
+        owner: org,
+        repo,
+        ref: `heads/${branch}`,
+        sha: commitSha,
+    });
+}
+
+publish();

package/scripts/test-integration-prep.sh

@@ -0,0 +1,4 @@
+for d in test/fixtures/*/ ; do
+    echo "$d"
+    npm --prefix $d i
+done