deploy: current vibn theia state

Made-with: Cursor

dev-packages/private-ext-scripts/bin/theia-ts-clean.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+// *****************************************************************************
+// Copyright (C) 2021 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+// @ts-check
+
+const _glob = require('glob');
+const debug = require('debug')('ts-clean');
+const fs = require('fs');
+const parcelWatcher = require('@parcel/watcher');
+const path = require('path');
+const util = require('util');
+const yargs = require('yargs');
+
+const glob = util.promisify(_glob);
+
+tsClean().catch(error => {
+    console.error(error);
+    process.exit(1);
+});
+
+async function tsClean() {
+    yargs
+        .command(
+            '$0 [globs..]',
+            'cleanup TypeScript output',
+            cmd => cmd
+                .option('verbose', {
+                    description: 'print what\'s going on',
+                    boolean: true,
+                    default: false,
+                })
+                .option('dry', {
+                    description: 'only display the files that would be deleted',
+                    boolean: true,
+                    default: false,
+                })
+                .option('watch', {
+                    description: 'run the cleanup in watch mode',
+                    alias: 'w',
+                    boolean: true,
+                    default: false,
+                })
+                .positional('globs', {
+                    array: true,
+                    default: [process.cwd()]
+                }),
+            async ({ dry, globs, verbose, watch }) => {
+                if (dry || verbose) {
+                    debug.enabled = true;
+                }
+                await Promise.all(globs.map(async pattern => {
+                    if (typeof pattern !== 'string') {
+                        return;
+                    }
+                    const roots = await glob(pattern, {
+                        absolute: true,
+                    });
+                    await Promise.all(roots.map(async root => {
+                        const stat = await fs.promises.stat(root);
+                        if (!stat.isDirectory()) {
+                            debug(`"${root}" is not a directory, skipping...`);
+                            return;
+                        }
+                        const tsconfigPath = path.resolve(root, 'tsconfig.json');
+                        if (!await exists(tsconfigPath)) {
+                            debug(`"${root}" is not a TypeScript package, skipping...`);
+                            return;
+                        }
+                        const {
+                            compilerOptions: {
+                                outDir = undefined,
+                                rootDir = undefined,
+                            } = {},
+                        } = await fs.promises.readFile(tsconfigPath, 'utf8').then(JSON.parse);
+                        if (typeof outDir !== 'string' || typeof rootDir !== 'string') {
+                            debug(`"${tsconfigPath}" doesn't look like a compilation configuration, skipping...`);
+                            return;
+                        }
+                        const src = path.resolve(root, rootDir);
+                        const dst = path.resolve(root, outDir);
+                        await watch
+                            ? tsCleanWatch(src, dst, dry)
+                            : tsCleanRun(src, dst, dry);
+                    }));
+                }));
+            }
+        )
+        .fail((msg, err, cli) => {
+            process.exitCode = 1;
+            if (err) {
+                // One of the handlers threw an error:
+                console.error(err);
+            } else {
+                // Yargs detected a problem with commands and/or arguments while parsing:
+                cli.showHelp();
+                console.error(msg);
+            }
+        })
+        .parse();
+}
+
+/**
+ * @param {string} src
+ * @param {string} dst
+ * @param {boolean} dry
+ */
+async function tsCleanWatch(src, dst, dry) {
+    await tsCleanRun(src, dst, dry);
+    await parcelWatcher.subscribe(src, async (_err, events) => {
+        for (const event of events) {
+            let absolute;
+            if (event.type === 'delete') {
+                absolute = event.path;
+            } else {
+                continue;
+            }
+            console.log('Source removed:', absolute);
+            const relative = path.relative(src, absolute);
+            // Absolute path of the expected generated files, without the original ts(x) extension.
+            const base = path.resolve(dst, relative).replace(/\.(tsx?)$/i, '');
+            await Promise.all(generatedFilesFromBase(base).map(async file => {
+                debug('delete', file);
+                if (!dry && await exists(file)) {
+                    await fs.promises.unlink(file).catch(debug);
+                }
+            }));
+        }
+    });
+}
+
+/**
+ * @param {string} src
+ * @param {string} dst
+ * @param {boolean} dry
+ */
+async function tsCleanRun(src, dst, dry) {
+    /**
+     * Generated files relative to `dst`.
+     */
+    const files = await glob('**/*.{d.ts,d.ts.map,js,js.map}', {
+        absolute: false,
+        cwd: dst,
+    });
+    /**
+     * Key is the path without extension (base) relative to `dst`.
+     * Value is the list of found generated files (absolute path).
+     * @type {Map<string, string[]>}
+     */
+    const bases = new Map();
+    for (const file of files) {
+        const parse = path.parse(file);
+        const base = path.join(parse.dir, removeExtension(parse.base));
+        let generated = bases.get(base);
+        if (!generated) {
+            bases.set(base, generated = []);
+        }
+        generated.push(path.resolve(dst, file));
+    }
+    await Promise.all(Array.from(bases.entries(), async ([base, generated]) => {
+        if (await exists(src, `${base}.ts`) || await exists(src, `${base}.tsx`)) {
+            return;
+        }
+        console.log('Missing source:', path.resolve(src, `${base}.ts(x)`));
+        await Promise.all(generated.map(async file => {
+            debug('delete', file);
+            if (!dry) {
+                await fs.promises.unlink(file).catch(debug);
+            }
+        }));
+    }));
+}
+
+/**
+ * @param {string[]} parts
+ */
+function generatedFilesFromBase(...parts) {
+    const base = path.resolve(...parts);
+    return [
+        `${base}.d.ts`,
+        `${base}.d.ts.map`,
+        `${base}.js`,
+        `${base}.js.map`,
+    ];
+}
+
+/**
+ * Removes the extension of files ending with:
+ * .d.ts, .d.ts.map, .js, .js.map, .ts, .tsx
+ * @param {string} base
+ */
+function removeExtension(base) {
+    return base.replace(/\.(d\.ts(\.map)?|js(\.map)?|tsx?)$/i, '');
+}
+
+/**
+ * @param {string[]} parts
+ */
+async function exists(...parts) {
+    return fs.promises.access(path.resolve(...parts), fs.constants.F_OK)
+        .then(ok => true, error => false);
+}