@flarum/cli 2.0.0-beta.8 → 3.0.0

package/lib/steps/upgrade/twopointoh/backend/phpunit.d.ts

@@ -0,0 +1,8 @@
+import { BaseUpgradeStep, GitCommit, Replacement } from '../base';
+export default class PhpUnit extends BaseUpgradeStep {
+    type: string;
+    replacements(file: string): Replacement[];
+    targets(): string[];
+    gitCommit(): GitCommit;
+    pauseMessage(): string;
+}

package/lib/steps/upgrade/twopointoh/backend/phpunit.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base_1 = require("../base");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+class PhpUnit extends base_1.BaseUpgradeStep {
+    constructor() {
+        super(...arguments);
+        this.type = 'PHPUnit 9 to 11 changes';
+    }
+    replacements(file) {
+        if (!file.endsWith('.php'))
+            return [];
+        return [
+            (_file, code) => ({
+                updated: this.php.run('upgrade.2-0.phpunit', { file, code }).code,
+            }),
+            (file, code) => {
+                if (!file.endsWith('.xml'))
+                    return null;
+                return {
+                    updated: code.replace('xsi:noNamespaceSchemaLocation="([^"]+)"', 'xsi:noNamespaceSchemaLocation="../vendor/phpunit/phpunit/phpunit.xsd"'),
+                };
+            },
+        ];
+    }
+    targets() {
+        return ['tests/**/*'];
+    }
+    gitCommit() {
+        return {
+            message: 'chore(2.0): Backend tests + PHPUnit 9 to 11 changes',
+            description: 'Flarum 2.0 uses PHPUnit 11 and encourages use of model factories for easier cross-database testing.',
+        };
+    }
+    pauseMessage() {
+        const links = [
+            'https://github.com/sebastianbergmann/phpunit/blob/9.6/DEPRECATIONS.md',
+            'https://github.com/sebastianbergmann/phpunit/blob/10.5/DEPRECATIONS.md',
+            'https://github.com/sebastianbergmann/phpunit/blob/11.3.0/DEPRECATIONS.md',
+        ];
+        const dbLink = 'http://localhost:3000/extend/testing#model-factories';
+        return `Flarum 2.0 uses PHPUnit 11. The tool has applied the most significant changes, but you might still run into other deprecations.
+                     Please refer to the following links for more information:
+                     ${links.map((link) => chalk_1.default.underline(link)).join('\n                     ')}
+
+                     Additionally, Flarum 2.0 encourages the use of model factories when preparing data for tests, this simplifies cross-database testing
+                     as PgSQL and SQLite are more strict about constraints.
+                     ${chalk_1.default.underline(dbLink)}`;
+    }
+}
+exports.default = PhpUnit;

package/lib/steps/upgrade/twopointoh/backend/search.d.ts

@@ -0,0 +1,28 @@
+import { AdvancedContent, BaseUpgradeStep, GitCommit, Replacement } from '../base';
+type Gambit = {
+    name: string;
+    pattern: string;
+    filterKey?: string;
+    filterFile: string;
+};
+export default class Search extends BaseUpgradeStep {
+    type: string;
+    beforeHook: boolean;
+    generatedFrontendStuff: boolean;
+    protected gambits: Gambit[];
+    protected data: {
+        collectedData: any;
+        replacements: {
+            from: string;
+            to: string;
+        }[];
+        filterClasses: string[];
+    };
+    protected searchers: Record<string, string>;
+    before(file: string, code: string, _advanced: AdvancedContent): void;
+    replacements(_file: string): Replacement[];
+    targets(): string[];
+    gitCommit(): GitCommit;
+    pauseMessage(): string;
+}
+export {};

package/lib/steps/upgrade/twopointoh/backend/search.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base_1 = require("../base");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const step_manager_1 = require("boilersmith/step-manager");
+const gen_ext_scaffolder_1 = require("../../../gen-ext-scaffolder");
+const gambit_1 = require("../../../stubs/frontend/gambit");
+const search_gambit_1 = require("../../../js/search-gambit");
+const base_2 = require("../../../locale/base");
+const model_name_1 = require("../../../../utils/model-name");
+class Search extends base_1.BaseUpgradeStep {
+    constructor() {
+        super(...arguments);
+        this.type = 'Search & Filter API changes';
+        this.beforeHook = true;
+        this.generatedFrontendStuff = false;
+        this.gambits = [];
+        this.data = {
+            collectedData: {},
+            replacements: [],
+            filterClasses: [],
+        };
+        this.searchers = {};
+    }
+    before(file, code, _advanced) {
+        var _a;
+        if (code.includes(' extends AbstractSearcher')) {
+            const className = file.split('/').pop().replace('.php', '');
+            const namespace = (_a = code.match(/namespace ([^;]+);/)) === null || _a === void 0 ? void 0 : _a[1];
+            this.searchers[className] = `${namespace}\\${className}`;
+        }
+    }
+    replacements(_file) {
+        return [
+            (file, code) => {
+                var _a, _b, _c;
+                if (code.includes(' extends AbstractRegexGambit') || /implements ([\dA-z]+,\s*)*GambitInterface/.test(code)) {
+                    const isOnlyGambit = !code.includes('FilterInterface');
+                    const oldName = file.split('/').pop().replace('.php', '');
+                    const name = oldName.replace('FilterGambit', 'Gambit').replace('GambitFilter', 'Gambit').replace('Filter', 'Gambit');
+                    const filterName = name.replace('Gambit', 'Filter');
+                    const pattern = (_a = code.match(/ function getGambitPattern\(\)(?:: string)?\s*{\s*return '(.*)';\s*}/)) === null || _a === void 0 ? void 0 : _a[1];
+                    const filterKey = isOnlyGambit
+                        ? (pattern || '').replace('is:', '').split(':')[0]
+                        : (_b = code.match(/function getFilterKey\(\)(?:: string)?\s*{\s*return '(.*)';\s*}/)) === null || _b === void 0 ? void 0 : _b[1];
+                    if (pattern || /^\s+public function apply\(SearchState \$.+$/m.test(code)) {
+                        const newPath = file
+                            .replace(/FilterGambit/g, 'Filter')
+                            .replace(/GambitFilter/g, 'Filter')
+                            .replace(/Gambit/g, 'Filter');
+                        if (pattern)
+                            this.gambits.push({ name, pattern, filterKey, filterFile: newPath });
+                        // old fully qualified class name to new fully qualified class name
+                        const namespace = (_c = code.match(/namespace ([^;]+);/)) === null || _c === void 0 ? void 0 : _c[1];
+                        this.data.replacements.push({ from: `${namespace}\\${oldName}`, to: `${namespace}\\${filterName}` });
+                        this.data.filterClasses.push(file, newPath);
+                        return {
+                            newPath,
+                            updated: code
+                                .replace(oldName, filterName)
+                                .replace(' extends AbstractRegexGambit', '')
+                                .replace('use Flarum\\Search\\AbstractRegexGambit;\n', '')
+                                .replace('use Flarum\\Search\\GambitInterface;\n', '')
+                                .replace(/implements ([\dA-z]+,\s*)*GambitInterface(,\s*)?/, 'implements $1')
+                                .replace(/\s*\w+ function getGambitPattern\(\)(?:: string)?\s*{\s*return '.*';\s*}/, '')
+                                .replace(/(\s*protected function )conditions(\([^)]*\)\s*{.*?[^ ] {4}})/s, isOnlyGambit ? '$1filter$2' : '')
+                                .replace(/\s*public function apply\(([^)]*)\)\s*{.*?[^ ] {4}}/s, '')
+                                .replace(/namespace (.*)Gambit([^;]+);/, `namespace $1Filter$2;`)
+                                .replace(/namespace (.*)Gambit([^;]*);/, `namespace $1Filter$2;`),
+                        };
+                    }
+                }
+                return null;
+            },
+            async (file, code) => {
+                const data = this.data;
+                data.gambits = this.gambits;
+                const output = this.php.run('upgrade.2-0.search', { file, code, data });
+                if (output.searchers) {
+                    this.data.collectedData.searchers = Object.assign(Object.assign({}, this.data.collectedData.searchers), output.searchers);
+                }
+                if (output.repositories) {
+                    this.data.collectedData.repositories = Object.assign(Object.assign({}, this.data.collectedData.repositories), output.repositories);
+                }
+                if (output.extendData) {
+                    this.data.collectedData.extendData = Object.assign(Object.assign({}, this.data.collectedData.extendData), output.extendData);
+                }
+                return {
+                    updated: output.code,
+                };
+            },
+            (file, code) => {
+                if (!code.includes(' extends AbstractFilterer') || !code.includes('use Flarum\\Filter\\AbstractFilterer')) {
+                    return null;
+                }
+                const className = file.split('/').pop().replace('.php', '');
+                const wouldbeSearcher = className === null || className === void 0 ? void 0 : className.replace('Filterer', 'Searcher');
+                if (this.searchers[wouldbeSearcher]) {
+                    // there is already an equivalent searcher
+                    return {
+                        delete: true,
+                        updated: null,
+                    };
+                }
+                return {
+                    newPath: file.replace(className, wouldbeSearcher),
+                    updated: code
+                        .replace('Flarum\\Filter\\AbstractFilterer', 'Flarum\\Search\\Database\\AbstractSearcher')
+                        .replace('AbstractFilterer', 'AbstractSearcher')
+                        .replace(className, wouldbeSearcher),
+                };
+            },
+            async (_file) => {
+                var _a;
+                if (this.gambits.length > 0 && Object.keys(((_a = this.data.collectedData.extendData) === null || _a === void 0 ? void 0 : _a.searchers) || {}).length > 0) {
+                    const result = await this.command.runSteps(new step_manager_1.StepManager().silentGroup((steps) => {
+                        this.gambits.forEach((gambit, index) => {
+                            let gambitKey = gambit.pattern.replace('is:', '');
+                            if (gambitKey.includes(':')) {
+                                gambitKey = gambitKey.split(':')[0];
+                            }
+                            const relatedSearcher = Object.keys(this.data.collectedData.extendData.searchers).find((searcher) => {
+                                const filters = this.data.collectedData.extendData.searchers[searcher].filters || [];
+                                return filters.some((filter) => {
+                                    return gambit.filterFile.includes(filter.class.name.replaceAll('\\', '/'));
+                                });
+                            });
+                            let type = 'discussions';
+                            if (relatedSearcher) {
+                                type = (0, model_name_1.pluralKebabCaseModel)(relatedSearcher.split('\\').pop().replace('Searcher', ''));
+                            }
+                            steps
+                                .namedStep(`gambit-${index}`, new gambit_1.GenerateGambitStub(this.command.STUB_PATH, (0, gen_ext_scaffolder_1.genExtScaffolder)()), {}, [], {
+                                frontend: 'common',
+                                className: gambit.name,
+                                type: gambit.pattern.includes('is:') ? 'boolean' : 'key-value',
+                                filterKey: gambit.filterKey,
+                            })
+                                .step(new search_gambit_1.GenerateSearchGambitExtender(), {}, [
+                                {
+                                    sourceStep: `gambit-${index}`,
+                                    exposedName: 'classNamespace',
+                                    consumedName: 'className',
+                                },
+                            ], {
+                                frontend: 'common',
+                                modelType: type,
+                            })
+                                .step(new base_2.LocaleStep((0, gen_ext_scaffolder_1.genExtScaffolder)()), {}, [], {
+                                key: `lib.gambits.${gambit.filterKey}.key`,
+                                value: gambitKey,
+                            });
+                            delete this.gambits[index];
+                        });
+                    }));
+                    if (!result.succeeded) {
+                        this.command.error(result.error);
+                    }
+                    this.generatedFrontendStuff = true;
+                }
+                return null;
+            },
+            (_file, code) => {
+                if (!code.includes('$criteria->query') && !code.includes('SearchCriteria $criteria')) {
+                    return null;
+                }
+                return {
+                    updated: code.replace('$criteria->query', '$criteria->filters'),
+                };
+            },
+        ];
+    }
+    targets() {
+        return ['src/**/*', 'extend.php'];
+    }
+    gitCommit() {
+        return {
+            message: 'chore(2.0): Search & Filter API changes',
+            description: 'Flarum 2.0 introduces a search driver implementation and moves gambits to the frontend.',
+        };
+    }
+    pauseMessage() {
+        const link = 'https://docs.flarum.org/2.x/extend/update-2_0#searchfilter-system';
+        const readMore = chalk_1.default.dim(`Read more: ${link}`);
+        const exampleBeforeLink = 'https://github.com/flarum/framework/blob/1.x/extensions/tags';
+        const exampleAfterLink = 'https://github.com/flarum/framework/blob/2.x/extensions/tags';
+        const exampleReadMore = chalk_1.default.dim(`We recommend looking at a comparison between the bundled extensions (like tags) from 1.x to 2.x to have a better understanding of the changes:`);
+        return `Flarum 2.0 introduces a new search driver implementation. It also merges Filterers and Searchers into a single API.
+                     Gambits are now handled on the frontend side where they are converted to filters.
+                     The tool has attempted to automatically update your codebase, please review the changes then proceed with the upgrade.
+
+                     ${readMore}
+
+                     ${exampleReadMore}
+                     ${exampleBeforeLink}
+                     ${exampleAfterLink}`;
+    }
+}
+exports.default = Search;

package/lib/steps/upgrade/twopointoh/base.d.ts

@@ -0,0 +1,58 @@
+import * as t from '@babel/types';
+import { Store } from 'mem-fs';
+import { IO } from 'boilersmith/io';
+import { Paths } from 'boilersmith/paths';
+import { Step } from 'boilersmith/step-manager';
+import { FlarumProviders } from '../../../providers';
+import { ModuleImport } from '../../../utils/ast';
+import { Editor } from 'mem-fs-editor';
+import BaseCommand from '../../../base-command';
+import { PhpProvider } from '../../../providers/php-provider';
+export type ReplacementResult = {
+    imports?: ImportChange[];
+    newPath?: string | null;
+    newFiles?: {
+        path: string;
+        code: string;
+    }[];
+    delete?: boolean;
+    updated: string | AdvancedContent;
+};
+export type Replacement = (file: string, code: string, advanced: AdvancedContent) => null | ReplacementResult | Promise<null | ReplacementResult>;
+export type AdvancedContent = t.File | Record<string, any> | null;
+export type ImportChange = {
+    replacesPath?: string | null;
+    import: ModuleImport;
+};
+export type GitCommit = {
+    message: string;
+    description: string;
+};
+export declare abstract class BaseUpgradeStep implements Step<FlarumProviders> {
+    abstract type: string;
+    composable: boolean;
+    exposes: string[];
+    getExposed(_paths: Paths, _paramProvider: IO): Record<string, unknown>;
+    protected params: Record<string, unknown>;
+    protected command: BaseCommand;
+    protected php: null | PhpProvider;
+    protected step: number;
+    protected totalSteps: number;
+    protected forceStep: boolean;
+    protected root: string;
+    constructor(command: BaseCommand, root: string, step: number, totalSteps: number, forceStep: boolean);
+    protected beforeHook: boolean;
+    before(_file: string, _code: string, _advanced: AdvancedContent): void;
+    abstract targets(): string[];
+    abstract replacements(file: string, code: string): Replacement[];
+    abstract gitCommit(): GitCommit;
+    abstract pauseMessage(): string;
+    protected fsEditor: null | Editor;
+    run(fs: Store, paths: Paths, io: IO, providers: FlarumProviders): Promise<Store>;
+    applyReplacements(file: string, code: string, advanced: AdvancedContent): Promise<ReplacementResult>;
+    ensureImport(file: string, advanced: AdvancedContent, imp: ImportChange): void;
+    advancedContent(file: string, code: string): AdvancedContent;
+    updateCode(file: string, code: string, updated: string | AdvancedContent): Promise<string>;
+    protected pauseAndConfirm(message: string, io: IO): Promise<void>;
+    protected alreadyCommited(path: string, message: string): Promise<boolean>;
+}

package/lib/steps/upgrade/twopointoh/base.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseUpgradeStep = void 0;
+const tslib_1 = require("tslib");
+const t = tslib_1.__importStar(require("@babel/types"));
+const pick_deep_1 = tslib_1.__importDefault(require("pick-deep"));
+const ast_1 = require("../../../utils/ast");
+const mem_fs_editor_1 = require("mem-fs-editor");
+const create_1 = require("../../monorepo/create");
+const globby_1 = tslib_1.__importDefault(require("globby"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const string_1 = tslib_1.__importDefault(require("string"));
+const simple_git_1 = tslib_1.__importDefault(require("simple-git"));
+const types_1 = require("@babel/types");
+class BaseUpgradeStep {
+    getExposed(_paths, _paramProvider) {
+        return (0, pick_deep_1.default)(this.params, this.exposes);
+    }
+    constructor(command, root, step, totalSteps, forceStep) {
+        this.composable = true;
+        this.exposes = [];
+        this.php = null;
+        this.step = 0;
+        this.totalSteps = 0;
+        this.forceStep = false;
+        this.beforeHook = false;
+        this.fsEditor = null;
+        this.command = command;
+        this.step = step;
+        this.totalSteps = totalSteps;
+        this.forceStep = forceStep;
+        this.root = root;
+    }
+    before(_file, _code, _advanced) {
+        // ...
+    }
+    async run(fs, paths, io, providers) {
+        var _a, _b, _c, _d, _e;
+        if (this.root !== paths.cwd()) {
+            process.chdir(this.root);
+        }
+        const fsEditor = (0, mem_fs_editor_1.create)(fs);
+        this.fsEditor = fsEditor;
+        this.php = providers.php;
+        // Stop if there are uncommited changes
+        const status = await (0, simple_git_1.default)((_a = paths.requestedDir()) !== null && _a !== void 0 ? _a : paths.cwd()).status();
+        if (status === null || status === void 0 ? void 0 : status.files.length) {
+            this.command.error('You have uncommitted changes in your repository. Please commit or stash them before continuing.', {
+                code: 'FL_ERR',
+            });
+        }
+        const stepMarker = chalk_1.default.bgRed.bold('  STEP ' + this.step + '/' + this.totalSteps + '   ');
+        this.command.log(stepMarker + ' ' + chalk_1.default.bold(this.type));
+        this.command.log('');
+        // Skip if this was already done (check by commits).
+        if (!this.forceStep && (await this.alreadyCommited((_b = paths.requestedDir()) !== null && _b !== void 0 ? _b : paths.cwd(), this.gitCommit().message))) {
+            this.command.log('     => ' + chalk_1.default.bgGreen.bold('    SKIP    '));
+            this.command.log('');
+            return fs;
+        }
+        // Show loading indicator
+        let dots = 1;
+        let nl = false;
+        const progress = () => {
+            if (!nl) {
+                this.command.log('');
+                nl = true;
+            }
+            const filledDots = '.'.repeat(dots) + ' '.repeat(3 - dots);
+            this.command.log('\u001B[A     => ' + chalk_1.default.bold('  WORKING' + filledDots));
+            dots = (dots + 1) % 4;
+        };
+        const targets = this.targets();
+        for (const target of targets) {
+            progress();
+            // target can have a wildcard
+            const files = target.includes('*')
+                ? // eslint-disable-next-line no-await-in-loop
+                    await (0, globby_1.default)(paths.package(target))
+                : [paths.package(target)];
+            if (this.beforeHook) {
+                for (const file of files) {
+                    if (!fsEditor.exists(file)) {
+                        continue;
+                    }
+                    const code = fsEditor.read(file);
+                    const advanced = this.advancedContent(file, code);
+                    this.before(file, code, advanced);
+                    progress();
+                }
+            }
+            const newFiles = [];
+            const deletedFiles = [];
+            const applyOn = async (files) => {
+                for (const file of files) {
+                    if (deletedFiles.includes(file) || !fsEditor.exists(file)) {
+                        continue;
+                    }
+                    const code = fsEditor.read(file);
+                    const advanced = this.advancedContent(file, code);
+                    const relativeTarget = (0, string_1.default)(file.replace(paths.package(), '')).stripLeft('/').stripLeft('\\').toString();
+                    // eslint-disable-next-line no-await-in-loop
+                    const result = await this.applyReplacements(relativeTarget, code, advanced);
+                    if (result.newPath && result.newPath !== file) {
+                        fsEditor.move(file, result.newPath);
+                        newFiles.push(result.newPath);
+                    }
+                    if (result.newFiles) {
+                        result.newFiles.forEach((newFile) => {
+                            fsEditor.write(newFile.path, newFile.code);
+                            newFiles.push(newFile.path);
+                        });
+                    }
+                    if (result.delete) {
+                        fsEditor.delete(file);
+                        deletedFiles.push(file);
+                    }
+                    else {
+                        const newCode = result.updated;
+                        fsEditor.write(result.newPath, newCode);
+                    }
+                }
+                progress();
+                await new Promise((resolve, _reject) => {
+                    fsEditor.commit((err) => {
+                        if (err) {
+                            throw new Error(err);
+                        }
+                        resolve(true);
+                    });
+                });
+            };
+            // eslint-disable-next-line no-await-in-loop
+            await applyOn(files);
+            // if (newFiles.length > 0) {
+            //   // eslint-disable-next-line no-await-in-loop
+            //   await applyOn(newFiles);
+            // }
+        }
+        const changesMade = await (0, simple_git_1.default)((_c = paths.requestedDir()) !== null && _c !== void 0 ? _c : paths.cwd())
+            .diffSummary()
+            .then((summary) => summary.files.length > 0);
+        if (changesMade) {
+            await (0, simple_git_1.default)((_d = paths.requestedDir()) !== null && _d !== void 0 ? _d : paths.cwd()).add('.');
+            await this.pauseAndConfirm(this.pauseMessage(), io);
+            const commit = this.gitCommit();
+            const message = commit.message + '\n\n' + commit.description;
+            await (0, create_1.commitAll)((_e = paths.requestedDir()) !== null && _e !== void 0 ? _e : paths.cwd(), message);
+            this.command.log('\u001B[A     => ' + chalk_1.default.bgCyan.bold('   COMMIT   ') + ' ' + chalk_1.default.dim(commit.message));
+            this.command.log('');
+        }
+        else {
+            this.command.log('\u001B[A     => ' + chalk_1.default.bgGreen.bold(' NO CHANGES '));
+            this.command.log('');
+        }
+        return fs;
+    }
+    async applyReplacements(file, code, advanced) {
+        var _a, _b;
+        let newPath = file;
+        let newFiles;
+        for (const callback of this.replacements(file, code)) {
+            // eslint-disable-next-line no-await-in-loop
+            const result = await callback(file, code, advanced);
+            if (result === null || result === void 0 ? void 0 : result.newFiles) {
+                newFiles = result.newFiles;
+            }
+            if (result === null || result === void 0 ? void 0 : result.delete) {
+                return {
+                    delete: true,
+                    updated: null,
+                    newFiles,
+                };
+            }
+            if (!result)
+                continue;
+            // eslint-disable-next-line no-await-in-loop
+            code = await this.updateCode(file, code, result.updated);
+            if (((_a = result.imports) === null || _a === void 0 ? void 0 : _a.length) || (result.updated && typeof result.updated !== 'string' && 'program' in result.updated)) {
+                try {
+                    advanced = (0, ast_1.parseCode)(code);
+                }
+                catch (error) {
+                    this.command.warn(`Failed to parse code for ${file}, code: \n${code}`);
+                    throw error;
+                }
+                (_b = result.imports) === null || _b === void 0 ? void 0 : _b.forEach((imp) => {
+                    this.ensureImport(file, advanced, imp);
+                });
+                // eslint-disable-next-line no-await-in-loop
+                code = await (0, ast_1.generateCode)(advanced, false);
+            }
+            if (result.newPath) {
+                newPath = result.newPath;
+            }
+        }
+        return {
+            newPath,
+            newFiles,
+            updated: code,
+        };
+    }
+    ensureImport(file, advanced, imp) {
+        var _a;
+        const frontend = file.split('/src/')[1].split('/')[0];
+        const ast = advanced;
+        // Remove old import first.
+        let index = null;
+        let postAdd = null;
+        if (imp.replacesPath) {
+            index = ast.program.body.findIndex((node) => {
+                if (!t.isImportDeclaration(node))
+                    return false;
+                return node.source.value === imp.replacesPath;
+            });
+            const replaces = (0, types_1.cloneNode)(ast.program.body[index]);
+            replaces.specifiers = replaces.specifiers.filter((specifier) => !t.isImportDefaultSpecifier(specifier));
+            if (imp.import.defaultImport && ((_a = replaces === null || replaces === void 0 ? void 0 : replaces.specifiers) === null || _a === void 0 ? void 0 : _a.length)) {
+                postAdd = () => ast.program.body.splice(index, 0, replaces);
+            }
+            if (index >= 0) {
+                ast.program.body.splice(index, 1);
+            }
+        }
+        (0, ast_1.populateImports)(ast, imp.import, {}, {}, frontend, index);
+        postAdd === null || postAdd === void 0 ? void 0 : postAdd();
+    }
+    advancedContent(file, code) {
+        const lang = file.split('.').pop();
+        if (lang === 'json') {
+            // remove comments
+            code = code.replace(/^\s*\/\/.*$/gm, '');
+            // remove loose ,
+            code = code.replace(/,\s*}/g, '}');
+            try {
+                return JSON.parse(code);
+            }
+            catch (_a) {
+                this.command.error(`Failed to parse JSON file ${file}`);
+            }
+        }
+        if (['js', 'ts', 'jsx', 'tsx'].includes(lang || '')) {
+            return (0, ast_1.parseCode)(code);
+        }
+        return null;
+    }
+    async updateCode(file, code, updated) {
+        const lang = file.split('.').pop();
+        if (['js', 'ts', 'jsx', 'tsx'].includes(lang || '') && typeof updated === 'string') {
+            return (0, ast_1.formatCode)(updated, false);
+        }
+        if (typeof updated === 'string') {
+            return updated;
+        }
+        if (lang === 'json') {
+            const space = file === 'composer.json' ? 4 : 2;
+            return JSON.stringify(updated, null, space);
+        }
+        if (updated && 'program' in updated) {
+            try {
+                return (0, ast_1.generateCode)(updated, false);
+            }
+            catch (error) {
+                this.command.warn(`Failed to generate code for ${file}, code: \n${code}`);
+                throw error;
+            }
+        }
+        return code;
+    }
+    async pauseAndConfirm(message, io) {
+        const stepMarker = chalk_1.default.bgWhite.black.bold('    DONE    ');
+        this.command.log('\u001B[A     => ' + stepMarker + ' ' + message);
+        this.command.log('');
+        await this.command.continueWhenReady(io);
+    }
+    async alreadyCommited(path, message) {
+        const log = await (0, simple_git_1.default)(path).log({
+            file: '.',
+            maxCount: 20,
+        });
+        return log.all.some((commit) => commit.message === message);
+    }
+}
+exports.BaseUpgradeStep = BaseUpgradeStep;

package/lib/steps/upgrade/twopointoh/dependencies.d.ts

@@ -0,0 +1,10 @@
+import { BaseUpgradeStep, GitCommit, Replacement } from './base';
+export default class Dependencies extends BaseUpgradeStep {
+    type: string;
+    replacements(file: string): Replacement[];
+    targets(): string[];
+    gitCommit(): GitCommit;
+    pauseMessage(): string;
+    updateComposerJson(): Replacement;
+    updatePackageJson(): Replacement;
+}