mlcl 1.0.0

package/build/commands/utilities/convertTypeScriptToJavaScript.js

@@ -0,0 +1,451 @@
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+import prettier from 'prettier';
+/**
+ * Returns the name of some node.
+ */
+const getName = (source, node) => {
+    const name = (node.name && node.name.escapedText)
+        || (node.parameters && source.substring(node.parameters.pos, node.parameters.end));
+    // Change type [key: string] to {...} so it will be parsed by JSDoc.
+    if (name === 'key: string') {
+        return '{...}';
+    }
+    return name;
+};
+/**
+ * Returns the name of some type.
+ */
+const getTypeName = (source, type) => {
+    let typeName = ``;
+    if (!type) {
+        return `any`;
+    }
+    if (type.typeName && type.typeName.escapedText) {
+        typeName = type.typeName.escapedText;
+        if (type.typeArguments && type.typeArguments.length) {
+            const args = type.typeArguments.map(subType => getTypeName(source, subType)).join(', ');
+            typeName = `${typeName}<${args}>`;
+        }
+    }
+    else if (ts.isFunctionTypeNode(type) || ts.isFunctionLike(type)) {
+        typeName = 'function';
+    }
+    else if (ts.isArrayTypeNode(type)) {
+        typeName = 'Array';
+    }
+    else if (type.types) {
+        typeName = type.types.map(subType => getTypeName(source, subType)).join(' | ');
+    }
+    else if (type.members && type.members.length) {
+        typeName = 'object';
+    }
+    else {
+        typeName = source.substring(type.pos, type.end).trim();
+    }
+    typeName = typeName.replace(/`/g, `'`);
+    typeName = typeName.replace(`['`, `#`).replace(`']`, ``);
+    typeName = typeName.replace(/keyof .+/g, `string`);
+    typeName = typeName.replace(/<.+>/gi, ``);
+    typeName = typeName.replace(/typeof /gi, ``);
+    return typeName;
+};
+/**
+ * Returns the JSDoc `@param` tag for some parameter.
+ */
+const getJSDocParamTag = (source, parameter) => {
+    let parameterName = getName(source, parameter);
+    const parameterComment = (parameter.jsDoc && parameter.jsDoc[0] && parameter.jsDoc[0].comment) || '';
+    if (parameter.questionToken) {
+        parameterName = ['[', parameterName, ']'].join('');
+    }
+    return `@param {${getTypeName(source, parameter.type)}} ${parameterName}${parameterComment ? ` ${parameterComment}` : ``}`;
+};
+/**
+ * Returns JSDoc `@property` tags for some type.
+ */
+const getJSDocPropertyTags = (source, type, tags = [], parentName = '') => {
+    // Type could be an array of types like: `{sth: 1} | string` so parse each type separately.
+    const typesToCheck = [type];
+    if (type.types && type.types.length) {
+        typesToCheck.push(...type.types);
+    }
+    typesToCheck.forEach(type => {
+        // Handling array defined like this: {element1: 'something'}[]
+        if (ts.isArrayTypeNode(type) && type.elementType) {
+            getJSDocPropertyTags(source, type.elementType, tags, parentName ? parentName + '[]' : '[]');
+        }
+        // Handling Array<{element1: 'somethin'}>
+        if (type.typeName && type.typeName.escapedText === 'Array') {
+            if (type.typeArguments && type.typeArguments.length) {
+                type.typeArguments.forEach(subType => {
+                    getJSDocPropertyTags(source, subType, tags, parentName ? parentName + '[]' : '');
+                });
+            }
+        }
+        // Handling {property1: "value"}
+        (type.members || []).filter(m => ts.isTypeElement(m)).forEach(member => {
+            let memberName = getName(source, member);
+            const memberComment = (member.jsDoc && member.jsDoc[0] && member.jsDoc[0].comment) || '';
+            const members = member.type.members || [];
+            const memberTypeName = members.length ? 'object' : getTypeName(source, member.type);
+            if (parentName) {
+                memberName = [parentName, memberName].join('.');
+            }
+            tags.push(`@property {${memberTypeName}} ${member.questionToken ? `[${memberName}]` : memberName}${memberComment ? ` ${memberComment}` : ``}`);
+            getJSDocPropertyTags(source, member.type, tags, memberName);
+        });
+    });
+    return tags;
+};
+/**
+ * Returns JSDoc comment lines and a method to append comment lines.
+ */
+const useCommentLines = (source, jsDocNode) => {
+    const commentLines = jsDocNode
+        ? source.substring(jsDocNode.pos, jsDocNode.end).split(/(\n|\r|\r\n)/).filter(line => line.trim().length > 0)
+        : [`/**`, ` */`];
+    let appendedAtLeastOnce = jsDocNode ? false : true;
+    const shouldUpdate = { current: false };
+    const appendComment = line => {
+        let args = [commentLines.length - 1, 0];
+        if (!appendedAtLeastOnce) {
+            appendedAtLeastOnce = true;
+            args = args.concat(` *`);
+        }
+        args = args.concat([].concat(line).map(line => ` * ${line}`));
+        // eslint-disable-next-line prefer-spread
+        commentLines.splice.apply(commentLines, args);
+        shouldUpdate.current = true;
+    };
+    return [commentLines, appendComment, shouldUpdate];
+};
+/**
+ * Updates JSDoc comments based on the type definitions.
+ */
+const updateJSDocComments = (source, filename, modulePath) => {
+    const sourceFile = ts.createSourceFile(filename, source, ts.ScriptTarget.Latest, true);
+    let updatedSource = source;
+    let tempConstantIndex = 1;
+    const isTest = modulePath.includes(`/__tests__/`) && !/\.(spec|test)\.tsx?$/.test(filename);
+    if (modulePath && !isTest) {
+        if (!updatedSource.includes(`* @module`)) {
+            updatedSource = `${updatedSource}\n\n/** @module ${modulePath} */`;
+        }
+    }
+    for (const _statement of sourceFile.statements) {
+        const statement = _statement; // TODO fix this
+        const name = getName(source, statement);
+        const [commentLines, appendComment, shouldUpdate] = useCommentLines(source, statement.jsDoc && statement.jsDoc[0]);
+        const appendMemberOf = () => {
+            if (modulePath && !isTest) {
+                appendComment([
+                    `@memberof module:${modulePath}`,
+                    ``
+                ]);
+            }
+        };
+        let addCommentAfter = false;
+        const declaration = statement.declarationList
+            && statement.declarationList.declarations
+            && statement.declarationList.declarations[0];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const initializer = declaration && declaration.initializer; // TODO
+        const functionParameters = initializer && initializer.parameters;
+        if (ts.isTypeAliasDeclaration(statement)) {
+            addCommentAfter = true;
+            if (ts.isFunctionTypeNode(statement.type)) {
+                appendMemberOf();
+                appendComment(`@typedef {function} ${name}`);
+                statement.type.parameters.forEach(parameter => {
+                    appendComment(getJSDocParamTag(source, parameter));
+                });
+            }
+            if (ts.isTypeLiteralNode(statement.type)) {
+                appendMemberOf();
+                appendComment(`@typedef {object} ${name}`);
+                getJSDocPropertyTags(source, statement.type).forEach(appendComment);
+            }
+            if (ts.isIntersectionTypeNode(statement.type)) {
+                appendMemberOf();
+                appendComment(`@typedef {object} ${name}`);
+                getJSDocPropertyTags(source, statement.type).forEach(appendComment);
+            }
+        }
+        else if (ts.isInterfaceDeclaration(statement)) {
+            addCommentAfter = true;
+            appendMemberOf();
+            appendComment(`@typedef ${name}`);
+            statement.members.forEach(member => {
+                const memberName = getName(source, member);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const memberType = member.type; // TODO
+                appendComment(`@property {${getTypeName(source, memberType)}} ${member.questionToken ? `[${memberName}]` : memberName}`);
+            });
+        }
+        else if (ts.isClassDeclaration(statement)) {
+            const className = getName(source, statement);
+            const memberComments = [];
+            statement.members.forEach(member => {
+                if (!ts.isPropertyDeclaration(member)) {
+                    return;
+                }
+                const modifiers = (member.modifiers || []).map(m => m.getText({ text: source }));
+                modifiers.forEach(m => {
+                    if (['private', 'public', 'protected'].includes(m)) {
+                        memberComments.push(`@${m}`);
+                    }
+                });
+                if (member.type) {
+                    memberComments.push(`@type {${getTypeName(source, member.type)}}`);
+                }
+                if (modifiers.find((m => m === 'static'))) {
+                    memberComments.push(`${className}.${getName(source, member)}`);
+                }
+                else {
+                    memberComments.push(`${className}.prototype.${getName(source, member)}`);
+                }
+                memberComments.forEach(appendComment);
+            });
+        }
+        else if (declaration && declaration.type) {
+            appendMemberOf();
+            appendComment(`@type {${getTypeName(source, declaration.type)}}`);
+        }
+        else if (functionParameters) {
+            appendMemberOf();
+            functionParameters.forEach(parameter => {
+                appendComment(getJSDocParamTag(source, parameter));
+            });
+        }
+        if (shouldUpdate.current) {
+            const newCommentBlock = commentLines.join(`\n`); // TODO .replace(/```ts/g, '```js')
+            const text = statement.getText().trim();
+            const fullText = statement.getFullText().trim();
+            if (filename.split(/\/|\\/).pop() === `types.ts` || !fullText || updatedSource.indexOf(fullText) < 0) {
+                updatedSource = `${updatedSource}\n\n${newCommentBlock}`;
+            }
+            else if (addCommentAfter) {
+                updatedSource = updatedSource.replace(statement.jsDoc ? fullText : text, `${text}\n\n${newCommentBlock}\nconst ___temp${tempConstantIndex++} = null`);
+            }
+            else {
+                updatedSource = updatedSource.replace(statement.jsDoc ? fullText : text, `${newCommentBlock}\n${text}`);
+            }
+        }
+    }
+    return updatedSource;
+};
+/**
+ * Recursively walks through the directories and converts all .ts and .tsx files
+ * to .js and .jsx files with JSDoc type annotations based on the type definitions.
+ *
+ * All other files are copied as is.
+ */
+const transpileRecursively = (tsPath, jsPath, modulePath = '') => {
+    const files = fs.readdirSync(tsPath);
+    for (const file of files) {
+        const tsFile = path.join(tsPath, file);
+        const jsFile = path.join(jsPath, file.replace(/\.ts$/, '.js').replace(/\.tsx$/, '.jsx'));
+        const stats = fs.statSync(tsFile);
+        if (stats.isDirectory()) {
+            transpileRecursively(tsFile, jsFile, modulePath ? `${modulePath}/${file}` : file);
+            continue;
+        }
+        else if (!/\.tsx?$/.test(file)) {
+            // Ensure the directory exists.
+            if (!fs.existsSync(jsPath)) {
+                fs.mkdirSync(jsPath, { recursive: true });
+            }
+            fs.copyFileSync(tsFile, jsFile);
+            continue;
+        }
+        else if (/\.d\.ts$/.test(file)) {
+            continue;
+        }
+        let source = fs.readFileSync(tsFile, 'utf8');
+        if (source.includes(`/** @ts-only */`)) {
+            // Skip copying of files with this flag.
+            continue;
+        }
+        // Remove lines (usually type imports) containing the `// @ts-only` comment.
+        source = source.replace(/^(.*)\/\/ @ts-only(.*)(\r|\n|\r\n)/gm, ``);
+        // Preserve double dollar signs. No idea why these are being reduced to a single one.
+        source = source.replace(/\$\$\{/g, '__DOLLAR_SIGN__${');
+        // Ensure every module is covered.
+        source = source + `\n\n\nconst ___temp = null`;
+        // Add the necessary JSDoc comments based on the type definitions.
+        source = updateJSDocComments(source, tsFile, modulePath ? `${modulePath}/${file.replace(/\.tsx?$/, ``)}` : file.replace(/\.tsx?$/, ``));
+        // Preserve line spacing.
+        source = source.replace(/(\n\n|\r\r|\r\n\r\n)/g, '\n/* __NEWLINE__ */');
+        // Get transpiled ESM code.
+        source = ts.transpileModule(source, {
+            compilerOptions: {
+                target: ts.ScriptTarget.ESNext,
+                module: ts.ModuleKind.ESNext,
+                moduleResolution: ts.ModuleResolutionKind.NodeJs,
+                esModuleInterop: true,
+                strict: false,
+                jsx: /\.tsx$/.test(file) ? ts.JsxEmit.Preserve : ts.JsxEmit.None,
+                newLine: ts.NewLineKind.LineFeed,
+                removeComments: false,
+                pretty: true
+            }
+        }).outputText;
+        // Restore line spacing.
+        source = source.replace(/\/\* __NEWLINE__ \*\//g, '\n');
+        // Remove the temporary constants.
+        source = source.replace(/const ___temp(|[0-9]+) = null/g, '');
+        // Remove @typescript-eslint lines.
+        source = source.replace(/(\s|)(\/\/|\/\*) eslint-disable(|-next-line) @typescript-eslint\/.*?(\n|\r|\r\n)/gi, `\n`);
+        try {
+            // Make the code pretty again.
+            source = prettier.format(source, {
+                filepath: jsFile,
+                printWidth: 120,
+                semi: false,
+                singleQuote: true,
+                quoteProps: 'consistent',
+                jsxSingleQuote: true,
+                trailingComma: 'none'
+            });
+        }
+        catch (error) {
+            console.error(error);
+            console.log(tsFile);
+            console.log(source);
+        }
+        // Restore double dollar signs.
+        source = source.replace(/__DOLLAR_SIGN__/g, '$');
+        if (source.trim().length && source.trim() !== `export {}`) {
+            // Ensure the directory exists.
+            if (!fs.existsSync(jsPath)) {
+                fs.mkdirSync(jsPath, { recursive: true });
+            }
+            // Write the JavaScript file.
+            fs.writeFileSync(jsFile, source);
+        }
+    }
+};
+/**
+ * A very quick and dirty hacked together script to convert a TypeScript codebase to JavaScript one.
+ */
+export const convertTypeScriptToJavaScript = async (cwd = `.`) => {
+    const tsPath = path.join(cwd, `src-ts`);
+    const jsPath = path.join(cwd, `src`);
+    try {
+        // Transpile all TypeScript to JavaScript.
+        fs.renameSync(jsPath, tsPath);
+        fs.mkdirSync(jsPath);
+        transpileRecursively(tsPath, jsPath);
+        fs.rmSync(tsPath, { recursive: true, force: true });
+    }
+    catch (error) {
+    }
+    try {
+        // Remove TypeScript dependencies and replace `.ts` with `.js` in `package.json`.
+        const packageJsonPath = path.join(cwd, `package.json`);
+        const packageJson = JSON.parse(await fs.promises.readFile(packageJsonPath, `utf8`));
+        delete packageJson.devDependencies[`ts-node`];
+        delete packageJson.devDependencies[`typescript`];
+        delete packageJson.devDependencies[`@babel/preset-typescript`];
+        for (const moduleName in packageJson.devDependencies) {
+            if (/^@(types\/|typescript(\/|-))/.test(moduleName)) {
+                delete packageJson.devDependencies[moduleName];
+            }
+        }
+        for (const scriptName in packageJson.scripts) {
+            const script = packageJson.scripts[scriptName];
+            if (script.includes(` --loader=ts-node/esm`)) {
+                packageJson.scripts[scriptName] = script
+                    .replace(/ --loader=ts-node\/esm/g, ``)
+                    .replace(/\.tsx\b/g, `.jsx`)
+                    .replace(/\.ts\b/g, `.js`);
+            }
+        }
+        if (packageJson.scripts.build === `tsc`) {
+            delete packageJson.scripts.build;
+        }
+        if (packageJson.scripts.start) {
+            packageJson.scripts.start = packageJson.scripts.start.replace(`node build/`, `node src/`);
+        }
+        await fs.promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+    catch (error) {
+    }
+    try {
+        // Remove `tsconfig.json`.
+        await fs.promises.rm(path.join(cwd, `tsconfig.json`));
+    }
+    catch (error) {
+    }
+    try {
+        // Update `.eslintrc.json`.
+        const eslintConfigPath = path.join(cwd, `.eslintrc.json`);
+        const eslintConfig = JSON.parse(await fs.promises.readFile(eslintConfigPath, `utf8`));
+        if (eslintConfig.plugins) {
+            eslintConfig.plugins = eslintConfig.plugins.filter(plugin => plugin !== `@typescript-eslint`);
+        }
+        delete eslintConfig.parser;
+        if (eslintConfig.extends) {
+            eslintConfig.extends = eslintConfig.extends.filter(extend => extend !== `plugin:@typescript-eslint/recommended`);
+        }
+        if (eslintConfig.rules) {
+            for (const key in eslintConfig.rules) {
+                if (/^@typescript-/.test(key)) {
+                    delete eslintConfig.rules[key];
+                }
+            }
+        }
+        await fs.promises.writeFile(eslintConfigPath, JSON.stringify(eslintConfig, null, 2));
+    }
+    catch (error) {
+    }
+    try {
+        // Update `jest.config.json` if it exists.
+        const jestConfigPath = path.join(cwd, `jest.config.json`);
+        await fs.promises.access(jestConfigPath, fs.constants.R_OK | fs.constants.R_OK);
+        await fs.promises.writeFile(jestConfigPath, JSON.stringify({
+            "roots": [
+                "<rootDir>/src/"
+            ],
+            "setupFiles": [
+                "<rootDir>/src/environment.js"
+            ],
+            "moduleNameMapper": {
+                "^(\\.{1,2}/.*)\\.jsx?$": "$1"
+            }
+        }, null, 2));
+    }
+    catch (error) {
+    }
+    try {
+        // Update `babel.config.json` if it exists.
+        const babelConfigPath = path.join(cwd, `babel.config.json`);
+        const babelConfig = JSON.parse(await fs.promises.readFile(babelConfigPath, `utf8`));
+        babelConfig.presets = babelConfig.presets.filter(preset => preset !== `@babel/preset-typescript`);
+        await fs.promises.writeFile(babelConfigPath, JSON.stringify(babelConfig, null, 2));
+    }
+    catch (error) {
+    }
+    try {
+        // Replace all TypeScript info with JavaScript.
+        const readmePath = path.join(cwd, `README.md`);
+        let README = await fs.promises.readFile(readmePath, `utf8`);
+        README = README
+            .replace(`\r\n- [\`ts-node\`](https://www.npmjs.com/package/ts-node) - Allows us to run TypeScript (.ts) files as easily as JavaScript (.js) files.\r\n`, ``)
+            .replace(`Uses the [TypeScript](typescriptlang.org) compiler to compile the \`*.ts\` files within the \`src\` directory into \`*.js\` files within the \`build\` directory. You probably don't need to use this unless you're explicitly running the production build locally, as [\`ts-node\`](https://www.npmjs.com/package/ts-node) handles everything for you in development.`, ``)
+            .replace(`### \`npm run build\`\r\n\r\n\r\n\r\n\r\n`, ``)
+            .replace(`### \`yarn run build\`\r\n\r\n\r\n\r\n\r\n`, ``)
+            .replace(`\r\n- \`@types/*\` - Type definitions for popular libraries. See [DefinitelyTyped](https://github.com/DefinitelyTyped/DefinitelyTyped) for more information.\r\n`, ``)
+            .replace(`\r\n- \`@typescript-eslint/*\` - Enables linting of our TypeScript codebase.\r\n`, ``)
+            .replace(`\r\n- [\`typescript\`](https://www.npmjs.com/package/typescript) - Necessary for TypeScript support.\r\n`, ``)
+            .replace(/www\.typescriptlang\.org/g, `developer.mozilla.org/en-US/docs/Web/JavaScript`)
+            .replace(/JavaScript and TypeScript/g, `JavaScript`)
+            .replace(/TypeScript/g, `JavaScript`)
+            .replace(/\.ts\b/g, `.js`);
+        await fs.promises.writeFile(readmePath, README);
+    }
+    catch (error) {
+    }
+};

package/build/commands/utilities/enableMergeDrivers.js

@@ -0,0 +1,50 @@
+import fs from 'fs';
+import path from 'path';
+import { logger } from '../../logger.js';
+/**
+ * A bit of a hack to make it easier to merge many different commits across various branches.
+ *
+ * Creates or updates the .gitattributes file to use custom merge strategies for every file.
+ *
+ * Uses a custom JSON merge driver for `.json` files, and diff3 + union for all others.
+ */
+export const enableMergeDrivers = (repoPath = ``) => {
+    const gitConfigPath = repoPath ? path.join(repoPath, `.git`, `config`) : path.join(`.git`, `config`);
+    const gitConfigExisted = fs.existsSync(gitConfigPath);
+    const originalGitConfig = (gitConfigExisted && fs.readFileSync(gitConfigPath, `utf8`)) || ``;
+    const gitAttributesPath = repoPath ? path.join(repoPath, `.gitattributes`) : path.join(`.gitattributes`);
+    const gitAttributesExisted = fs.existsSync(gitAttributesPath);
+    const originalGitAttributes = (gitAttributesExisted && fs.readFileSync(gitAttributesPath, `utf8`)) || ``;
+    logger.info(`Enabling custom merge drivers...`);
+    fs.appendFileSync(gitConfigPath, [
+        ``,
+        `[merge "json"]`,
+        `	name = custom merge driver for json files`,
+        `	driver = npx mlcl x-merge-json %O %A %B`,
+        `[merge "diff3-union"]`,
+        `	name = custom merge driver for all other files`,
+        `	driver = git merge-file --diff3 --union %A %O %B`,
+        ``,
+    ].join(`\n`));
+    fs.appendFileSync(gitAttributesPath, [
+        ``,
+        `* merge=diff3-union`,
+        `*.json merge=json`,
+        ``,
+    ].join(`\n`));
+    return () => {
+        logger.info(`Removing custom merge drivers...`);
+        if (gitConfigExisted) {
+            fs.writeFileSync(gitConfigPath, originalGitConfig);
+        }
+        else {
+            fs.unlinkSync(gitConfigPath);
+        }
+        if (gitAttributesExisted) {
+            fs.writeFileSync(gitAttributesPath, originalGitAttributes);
+        }
+        else {
+            fs.unlinkSync(gitAttributesPath);
+        }
+    };
+};

package/build/commands/utilities/getCurrentBranch.js

@@ -0,0 +1,11 @@
+import { asyncExec } from './asyncExec.js';
+/**
+ * Returns the name of the current branch.
+ */
+export const getCurrentBranch = async (repoPath = ``) => {
+    const { stdout, stderr } = await asyncExec(`git${repoPath ? ` -C "${repoPath}"` : ``} branch --show-current`);
+    if (stderr) {
+        throw new Error(stderr);
+    }
+    return stdout.replace(/^\* /, ``).trim();
+};

package/build/commands/utilities/getCurrentBranchSync.js

@@ -0,0 +1,7 @@
+import { execSync } from 'child_process';
+/**
+ * Returns the name of the current branch.
+ */
+export const getCurrentBranchSync = () => {
+    return execSync(`git branch --show-current`, { encoding: `utf8` }).replace(/^\* /, ``).trim();
+};

package/build/commands/utilities/getRepoRootPath.js

@@ -0,0 +1,7 @@
+import { execSync } from 'child_process';
+/**
+ * Returns the root path of the current git repository.
+ */
+export const getRepoRootPath = () => {
+    return execSync(`git rev-parse --show-toplevel`, { encoding: `utf8` }).trim();
+};

package/build/commands/utilities/getRepoRootPathSync.js

@@ -0,0 +1,13 @@
+import { spawnSync } from 'child_process';
+/**
+ * Returns the root path of the current git repository.
+ */
+export const getRepoRootPathSync = () => {
+    try {
+        const spawn = spawnSync('git', ['rev-parse', '--show-toplevel']);
+        return spawn.stdout.toString().trim() || `.`;
+    }
+    catch (error) {
+        return `.`;
+    }
+};

package/build/commands/utilities/index.js

@@ -0,0 +1,16 @@
+/**
+ * Utilities for common commands.
+ *
+ * @module
+ */
+export * from './asyncExec.js';
+export * from './branchExists.js';
+export * from './checkoutSelectionBranch.js';
+export * from './cherryPick.js';
+export * from './cloneRepo.js';
+export * from './convertNpmToYarn.js';
+export * from './convertTypeDocToJSDoc.js';
+export * from './convertTypeScriptToJavaScript.js';
+export * from './enableMergeDrivers.js';
+export * from './getCurrentBranch.js';
+export * from './getRepoRootPathSync.js';

package/build/commands/utilities/npm-to-yarn.js

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import glob from 'glob';
+// Delete package-lock.json.
+if (fs.existsSync(`package-lock.json`)) {
+    fs.unlinkSync(`package-lock.json`);
+}
+// Add Yarn to prerequisites in README.
+let README = fs.readFileSync(`README.md`, `utf8`);
+if (!README.includes(`[Yarn](https://yarnpkg.com/getting-started/install)`)) {
+    README = README.replace(`- [Node.js](https://nodejs.org/) (version 16.10 or greater)`, `- [Node.js](https://nodejs.org/) (version 16.10 or greater)
+
+- [Yarn](https://yarnpkg.com/getting-started/install)
+
+  - The recommended way to install Yarn is by enabling [Corepack](https://github.com/nodejs/corepack), which is included by default with the latest Node.js version, but it is opt-in. To enable Corepack, run \`corepack enable\` in your console, which may require elevated permissions (if on Windows, run command prompt as administrator). `);
+    fs.writeFileSync(`README.md`, README);
+}
+glob(`{*.md,**!(node_modules)/*.md,src/**/*.{js,jsx,ts,tsx}}`, async (error, files) => {
+    const replace = file => {
+        const npmContents = fs.readFileSync(file, `utf8`);
+        const yarnContents = npmContents
+            .replace(/npm run/g, `yarn run`)
+            .replace(/npm start/g, `yarn start`)
+            .replace(/npm install/g, `yarn install`)
+            .replace(/npm version/g, `yarn version`)
+            .replace(/npm test/g, `yarn test`)
+            .replace(/npx cap/g, `yarn run cap`);
+        if (npmContents !== yarnContents) {
+            fs.writeFileSync(file, yarnContents);
+        }
+    };
+    replace(`package.json`);
+    if (fs.existsSync(`electron/package.json`)) {
+        replace(`electron/package.json`);
+    }
+    for (const file of files) {
+        replace(file);
+    }
+    // yarn install
+    // git add yarn.lock
+    // git add electron/yarn.lock
+});