@flarum/cli 3.0.12 → 3.0.14

package/lib/steps/upgrade/twopointoh/frontend/code-splitting/usage-of-lazy-modules.js

@@ -11,13 +11,14 @@ class UsageOfLazyModules extends base_1.BaseUpgradeStep {
         super(...arguments);
         this.type = 'Adapt to accessing/extending lazy loaded Flarum modules.';
         // Array.from(flarum.reg.chunks.entries().flatMap(e => e[1].modules.map(m => e[1].namespace + ':' + m))).join('\n')
+        // LabelValue and LoadingPost were lazy once, and are in the main bundle
+        // now (flarum/framework#4235), so they are imported as usual.
         // core:forum/components/ReplyComposer
         // core:forum/components/ComposerBody
         // core:common/components/ConfirmDocumentUnload
         // core:forum/components/LogInModal
         // core:forum/components/ForgotPasswordModal
         // core:forum/components/PostStream
-        // core:forum/components/LoadingPost
         // core:forum/components/ReplyPlaceholder
         // core:forum/components/PostStreamScrubber
         // core:forum/components/SearchModal
@@ -36,7 +37,6 @@ class UsageOfLazyModules extends base_1.BaseUpgradeStep {
         // core:forum/components/AccessTokensList
         // core:forum/components/NewAccessTokenModal
         // core:forum/states/UserSecurityPageState
-        // core:common/components/LabelValue
         // core:forum/components/NotificationsPage
         // core:forum/components/Composer
         // core:forum/components/ComposerButton
@@ -53,15 +53,11 @@ class UsageOfLazyModules extends base_1.BaseUpgradeStep {
                     'ForgotPasswordModal',
                     'NotificationsPage',
                     'ComposerBody',
-                    'ConfirmDocumentUnload',
-                    'LoadingPost',
                     'ReplyPlaceholder',
                     'PostStreamScrubber',
-                    'SearchModal',
                     'SignUpModal',
                     'DiscussionComposer',
                     'EditPostComposer',
-                    'ComposerBody',
                     'LogInModal',
                     'PostStream',
                     'ReplyComposer',
@@ -75,16 +71,16 @@ class UsageOfLazyModules extends base_1.BaseUpgradeStep {
                     'UserSecurityPageState',
                     'ComposerButton',
                 ],
-                common: ['EditUserModal', 'LabelValue', 'ConfirmDocumentUnload'],
+                common: ['EditUserModal', 'ConfirmDocumentUnload', 'SearchModal'],
             },
             'flarum/tags': {
                 admin: [],
-                forum: ['TagDiscussionModal', 'TagSelectionModal', 'ToggleButton'],
-                common: [],
+                forum: ['TagDiscussionModal', 'ToggleButton'],
+                common: ['TagSelectionModal'],
             },
             'flarum/emoji': {
                 admin: [],
-                forum: ['EmojiMap'],
+                forum: ['emojiMap'],
                 common: [],
             },
             current: {
@@ -184,11 +180,16 @@ class UsageOfLazyModules extends base_1.BaseUpgradeStep {
     updateComposerLoad() {
         return (_file, code, advanced) => {
             const ast = advanced;
+            let addsOverride = false;
             this.forEachLazyModule(code, ({ module, importPath }) => {
                 // before = app.composer.load(${module}, { ... }, ...);
                 // after = app.composer.load(() => import('${importPath}'), { ... }, ...);
                 const lines = [];
-                const composers = this.composers;
+                // A composer's prototype lines move into the then() of the file's own
+                // load of it, which has the module. Without one, they are given like
+                // any other lazy module's.
+                const movesToLoad = this.composers.includes(module) && loadsComposer(ast, module);
+                const overrideName = importedName(ast, 'flarum/common/extend', 'override');
                 // pick up {module}.prototype... lines to add to the .then(() => { lines }) at the end of the call expression.
                 (0, traverse_1.default)(ast, {
                     ExpressionStatement(path) {
@@ -212,17 +213,18 @@ class UsageOfLazyModules extends base_1.BaseUpgradeStep {
                             return;
                         if (object.name !== module)
                             return;
-                        if (composers.includes(module)) {
+                        if (movesToLoad) {
                             lines.push(node);
                             path.remove();
                         }
                         else if ((t.isFunctionExpression(expression.right) || t.isArrowFunctionExpression(expression.right)) &&
-                            (t.isIdentifier(left.property) || t.isStringLiteral(left.property))) {
-                            // SettingsPage.prototype['draftsItems'] = ...;
-                            // change to extend('flarum/forum/components/SettingsPage', 'draftItems', ...);
+                            ((t.isIdentifier(left.property) && !left.computed) || t.isStringLiteral(left.property))) {
+                            // SettingsPage.prototype['draftsItems'] = function () {...};
+                            // change to override('flarum/forum/components/SettingsPage', 'draftsItems', function (original) {...});
                             const methodName = t.isIdentifier(left.property) ? left.property.name : left.property.value;
-                            const extend = t.callExpression(t.identifier('extend'), [t.stringLiteral(importPath), t.stringLiteral(methodName), expression.right]);
-                            path.replaceWith(t.expressionStatement(extend));
+                            path.replaceWith(overrideMethod(overrideName !== null && overrideName !== void 0 ? overrideName : 'override', importPath, methodName, expression.right));
+                            if (!overrideName)
+                                addsOverride = true;
                         }
                     },
                 });
@@ -307,6 +309,7 @@ class UsageOfLazyModules extends base_1.BaseUpgradeStep {
             });
             return {
                 updated: ast,
+                imports: addsOverride ? [{ import: { name: 'override', path: 'flarum/common/extend', defaultImport: false } }] : [],
             };
         };
     }
@@ -349,10 +352,28 @@ class UsageOfLazyModules extends base_1.BaseUpgradeStep {
     }
     removeImportLines() {
         return (_file, code) => {
-            this.forEachLazyModule(code, ({ module, importLine }) => {
+            this.forEachLazyModule(code, ({ module, importPath, importedAs, importLine }) => {
+                var _a, _b;
                 if (code.includes(` extends ${module}`)) {
                     return;
                 }
+                // Types are erased from the build, so a type import costs nothing.
+                if (/^type\s/.test(importedAs.trim())) {
+                    return;
+                }
+                // The other replacements load what they can as it's needed. Whatever
+                // still uses the import, such as JSX rendering the component, would
+                // break without it, and only the author knows where to load it. A name
+                // inside a string, such as a module path, is no use of it.
+                const names = (_b = (_a = importedAs.match(/[$A-Z_a-z][\w$]*/g)) === null || _a === void 0 ? void 0 : _a.filter((name) => name !== 'as' && name !== 'default')) !== null && _b !== void 0 ? _b : [];
+                const rest = code.replace(importLine, '');
+                if (names.some((name) => new RegExp(`(?<![\\w$./'"])${name.replace(/\$/g, '\\$')}(?![\\w$'"])`).test(rest))) {
+                    const todo = `// @TODO: ${module} is lazy loaded in 2.0, so this import is undefined until its chunk has loaded. Load it with \`await import('${importPath}')\` before using it. https://docs.flarum.org/2.x/extend/code-splitting\n`;
+                    if (!code.includes(todo + importLine)) {
+                        code = code.replace(importLine, todo + importLine);
+                    }
+                    return;
+                }
                 code = code
                     // then remove the import.
                     .replace(importLine, '');
@@ -416,3 +437,74 @@ class UsageOfLazyModules extends base_1.BaseUpgradeStep {
     }
 }
 exports.default = UsageOfLazyModules;
+/** Whether the file loads the composer itself, with app.composer.load(Composer, ...). */
+function loadsComposer(ast, module) {
+    let loads = false;
+    (0, traverse_1.default)(ast, {
+        CallExpression(path) {
+            const callee = path.node.callee;
+            const firstArg = path.node.arguments[0];
+            if (t.isMemberExpression(callee) &&
+                t.isIdentifier(callee.property, { name: 'load' }) &&
+                t.isMemberExpression(callee.object) &&
+                t.isIdentifier(callee.object.property, { name: 'composer' }) &&
+                t.isIdentifier(callee.object.object, { name: 'app' }) &&
+                t.isIdentifier(firstArg, { name: module })) {
+                loads = true;
+                path.stop();
+            }
+        },
+    });
+    return loads;
+}
+/** The name a file imports one of a module's exports by, if it does. */
+function importedName(ast, source, name) {
+    for (const node of ast.program.body) {
+        if (!t.isImportDeclaration(node) || node.source.value !== source)
+            continue;
+        for (const specifier of node.specifiers) {
+            if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported, { name })) {
+                return specifier.local.name;
+            }
+        }
+    }
+    return null;
+}
+/** A name for a new binding in the function, that hides none it uses. */
+function unusedName(node, name) {
+    const used = new Set();
+    t.traverseFast(node, (child) => {
+        if (t.isIdentifier(child))
+            used.add(child.name);
+    });
+    while (used.has(name))
+        name = '_' + name;
+    return name;
+}
+/**
+ * Module.prototype.method = fn; given with override() by the module's path,
+ * which replaces the method as the assignment did once the module loads. The
+ * original method comes first, after a TypeScript this parameter: a function
+ * that reads its arguments with `arguments` is called with them as they were.
+ */
+function overrideMethod(override, importPath, methodName, method) {
+    const original = t.identifier(unusedName(method, 'original'));
+    let replacement;
+    let readsArguments = false;
+    t.traverseFast(method, (child) => {
+        if (t.isIdentifier(child, { name: 'arguments' }))
+            readsArguments = true;
+    });
+    if (t.isFunctionExpression(method) && readsArguments) {
+        const args = t.identifier(unusedName(method, 'args'));
+        const call = t.callExpression(t.memberExpression(method, t.identifier('apply')), [t.thisExpression(), args]);
+        replacement = t.functionExpression(null, [original, t.restElement(args)], t.blockStatement([t.returnStatement(call)]));
+    }
+    else {
+        const first = method.params[0];
+        const at = t.isIdentifier(first, { name: 'this' }) ? 1 : 0;
+        replacement = t.cloneNode(method);
+        replacement.params.splice(at, 0, original);
+    }
+    return t.expressionStatement(t.callExpression(t.identifier(override), [t.stringLiteral(importPath), t.stringLiteral(methodName), replacement]));
+}

package/lib/steps/upgrade/twopointoh/frontend/export-registry/import-ext.js

@@ -77,17 +77,12 @@ class ImportExt extends base_1.BaseUpgradeStep {
     updateImportsFromFlarumExtensions() {
         return (_file, code) => {
             // replace `import module from 'flarum/ext/module-path';` with `import module from 'ext:flarum/extension/module-path';`
-            // extension must not be one of [forum, admin, common]
-            const regex = new RegExp(/import\s+(\w+)\s+from\s+["'](flarum\/(?!\b(?:common|admin|forum|utils|helpers|components|models)\b).*\/[\w/]+)["']/gim);
-            // First collect all the imports that are from extensions
-            const imports = code.match(regex);
-            if (imports === null || imports === void 0 ? void 0 : imports.length) {
-                this.importingFromExtensions = [
-                    ...this.importingFromExtensions,
-                    ...imports.map((imp) => {
-                        return imp.match(/from ["'](flarum\/\w+).*\/([\w/]+)["']/)[1];
-                    }),
-                ];
+            // wherever the code names a module: in imports and exports of any kind, import(), require(),
+            // and `declare module`, which augments the module. extension must not be one of [forum, admin, common].
+            const regex = /(\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*|\bdeclare\s+module\s+|\bimport\s+)(["'])(flarum\/(?!\b(?:common|admin|forum|utils|helpers|components|models)\b)[\w-]+\/[^\s"']+)\2/gm;
+            // First collect all the extensions imported from
+            for (const match of code.matchAll(regex)) {
+                this.importingFromExtensions.push(match[3].split('/').slice(0, 2).join('/'));
             }
             // add todos to update imports that use other extensions
             const uniqueUseExtensions = [...new Set(this.useExtensions)];
@@ -96,7 +91,7 @@ class ImportExt extends base_1.BaseUpgradeStep {
             });
             return {
                 updated: code
-                    .replace(regex, `import $1 from 'ext:$2'`)
+                    .replace(regex, '$1$2ext:$3$2')
                     // imports from @flarum/core no longer supported, replace with flarum/
                     .replace(/import\s+(\w+)\s+from\s+["']@flarum\/core\/([\w/]+)["']/gim, `import $1 from 'flarum/$2'`),
             };
@@ -112,10 +107,12 @@ class ImportExt extends base_1.BaseUpgradeStep {
             (_a = advanced.compilerOptions).paths || (_a.paths = {});
             const paths = advanced.compilerOptions.paths;
             uniqueExtensions.forEach((ext) => {
-                if (paths[ext]) {
-                    delete paths[ext];
-                }
-                paths[`ext:${ext}`] = [`../vendor/${ext}/js/dist-typings/*`];
+                var _a;
+                // Where the 1.x mapping found the typings, which isn't always vendor.
+                const typings = paths[`${ext}/*`];
+                delete paths[ext];
+                delete paths[`${ext}/*`];
+                paths[_a = `ext:${ext}/*`] || (paths[_a] = typings !== null && typings !== void 0 ? typings : [`../vendor/${ext}/js/dist-typings/*`]);
             });
             return {
                 updated: advanced,

package/lib/steps/upgrade/twopointoh/frontend/misc.d.ts

@@ -2,6 +2,13 @@ import { BaseUpgradeStep, GitCommit, Replacement } from '../base';
 export default class MiscFrontendChanges extends BaseUpgradeStep {
     type: string;
     replacements(file: string): Replacement[];
+    /**
+     * 2.0's AvatarEditor opens the file picker on click, and uploads a dropped
+     * image, whenever user.hasUploadedAvatar() is false. 1.x went by
+     * avatarUrl(), so an extension that gives users an avatar some other way,
+     * as a Gravatar one does, now gets an upload instead of its menu.
+     */
+    flagAvatarEditor(): Replacement;
     targets(): string[];
     gitCommit(): GitCommit;
     pauseMessage(): string;
@@ -11,7 +18,23 @@ export default class MiscFrontendChanges extends BaseUpgradeStep {
     private updateIndexPage;
     private updateAvatarIcon;
     private updateOtherRefs;
+    /**
+     * `app.initializers.has(name)` becomes `'id' in flarum.extensions`, where the
+     * upgrade knows the ID for certain: a bundled extension's, or one the
+     * extension's composer.json names. An initializer is not always named after
+     * its extension, so a check it can't be sure of gets a @TODO instead.
+     */
     private updateInitializers;
+    /**
+     * For `app.initializers.has('name')`: the ID of the extension it checks for,
+     * or null when the upgrade can't be sure of it. Undefined for anything else.
+     */
+    private checkedExtension;
+    private named;
+    /**
+     * The extensions the composer.json names, by package name and by ID.
+     */
+    private namedExtensions;
     private updateUploadImageButton;
     private updateExtendModal;
 }

package/lib/steps/upgrade/twopointoh/frontend/misc.js

@@ -5,11 +5,50 @@ const base_1 = require("../base");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const t = tslib_1.__importStar(require("@babel/types"));
 const traverse_1 = tslib_1.__importDefault(require("@babel/traverse"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
 const ast_1 = require("../../../../utils/ast");
+const babel_ts_1 = require("../../../../utils/babel-ts");
+const composer_1 = require("../../../../utils/composer");
+/** The bundled extensions' IDs, which are their initializers' names in 2.0. */
+const BUNDLED = new Set([
+    'flarum-akismet',
+    'flarum-approval',
+    'flarum-audit',
+    'flarum-bbcode',
+    'flarum-deck',
+    'flarum-embed',
+    'flarum-emoji',
+    'flarum-extension-manager',
+    'flarum-flags',
+    'flarum-gdpr',
+    'flarum-lang-english',
+    'flarum-likes',
+    'flarum-lock',
+    'flarum-markdown',
+    'flarum-mentions',
+    'flarum-messages',
+    'flarum-nicknames',
+    'flarum-pusher',
+    'flarum-realtime',
+    'flarum-statistics',
+    'flarum-sticky',
+    'flarum-subscriptions',
+    'flarum-suspend',
+    'flarum-tags',
+]);
+/** The 1.x names of the bundled initializers 2.0 renamed (flarum/framework#4003). */
+const RENAMED = {
+    lock: 'flarum-lock',
+    subscriptions: 'flarum-subscriptions',
+    'flarum/nicknames': 'flarum-nicknames',
+};
+const CHECK_TODO = "@TODO: check whether the extension is enabled with '<its extension ID>' in flarum.extensions instead";
 class MiscFrontendChanges extends base_1.BaseUpgradeStep {
     constructor() {
         super(...arguments);
         this.type = 'Miscellaneous frontend changes.';
+        this.named = null;
     }
     // - [`IndexPage.prototype.sidebar` -> `IndexSidebar`](https://github.com/flarum/framework/blob/72f89c0209a5c4bbdc5482ecbdc2435dcd57550f/framework/core/js/src/forum/components/IndexSidebar.tsx)
     // - [`IndexPage.prototype.navItems` -> `IndexSidebar.prototype.navItems`](https://github.com/flarum/framework/blob/72f89c0209a5c4bbdc5482ecbdc2435dcd57550f/framework/core/js/src/forum/components/IndexSidebar.tsx)
@@ -31,8 +70,23 @@ class MiscFrontendChanges extends base_1.BaseUpgradeStep {
             this.updateInitializers(),
             this.updateUploadImageButton(),
             ...this.updateExtendModal(),
+            this.flagAvatarEditor(),
         ];
     }
+    /**
+     * 2.0's AvatarEditor opens the file picker on click, and uploads a dropped
+     * image, whenever user.hasUploadedAvatar() is false. 1.x went by
+     * avatarUrl(), so an extension that gives users an avatar some other way,
+     * as a Gravatar one does, now gets an upload instead of its menu.
+     */
+    flagAvatarEditor() {
+        return (file, code) => {
+            if (/["']flarum\/forum\/components\/AvatarEditor["']/.test(code)) {
+                this.leaveTodo(file, 'It uses AvatarEditor, which in 2.0 opens the file picker, or uploads a dropped image, whenever user.hasUploadedAvatar() is false, not when there is no avatarUrl(). Check what it does for users without an uploaded avatar.');
+            }
+            return null;
+        };
+    }
     targets() {
         return ['js/src/**/*'];
     }
@@ -258,8 +312,7 @@ class MiscFrontendChanges extends base_1.BaseUpgradeStep {
                                         return t.jsxAttribute(t.jsxIdentifier(key.toString()), t.isStringLiteral(prop.value) ? prop.value : t.jsxExpressionContainer(prop.value));
                                     }
                                     catch (error) {
-                                        console.log({ [key.toString()]: prop.value });
-                                        throw error;
+                                        throw new Error(`Could not turn the "${key.toString()}" attr into a JSX attribute: ${error.message}`);
                                     }
                                 });
                             }
@@ -315,7 +368,8 @@ class MiscFrontendChanges extends base_1.BaseUpgradeStep {
                 updated: code
                     .replace(/this\.currentTag/g, 'app.currentTag')
                     .replace('app.search.', 'app.search.state.')
-                    .replace('app.extensionData', 'app.registry')
+                    .replace(/\bapp\.extensionData\b/g, 'app.registry')
+                    .replace(/\b(app\.registry\s*\.\s*)getAllExtensionPermissions\b/g, '$1getAllPermissions')
                     .replace("extend(BasicsPage.prototype, 'homePageItems'", "extend(BasicsPage, 'homePageItems'")
                     .replace('className="NotificationList', 'className="HeaderList')
                     .replace('className: "NotificationList', 'className: "HeaderList')
@@ -325,18 +379,103 @@ class MiscFrontendChanges extends base_1.BaseUpgradeStep {
             };
         };
     }
+    /**
+     * `app.initializers.has(name)` becomes `'id' in flarum.extensions`, where the
+     * upgrade knows the ID for certain: a bundled extension's, or one the
+     * extension's composer.json names. An initializer is not always named after
+     * its extension, so a check it can't be sure of gets a @TODO instead.
+     */
     updateInitializers() {
         return (_file, code) => {
-            if (!code.includes('this.currentTag'))
+            if (!/initializers\s*\.\s*has\s*\(/.test(code))
+                return null;
+            const edits = [];
+            const flagged = new Set();
+            (0, traverse_1.default)((0, babel_ts_1.parse)(code), {
+                CallExpression: (p) => {
+                    var _a;
+                    const id = this.checkedExtension(p.node);
+                    if (id === undefined)
+                        return;
+                    if (id) {
+                        edits.push({ start: p.node.start, end: p.node.end, text: `('${id}' in flarum.extensions)` });
+                        return;
+                    }
+                    // Above the statement, where a comment can't land in JSX or a string.
+                    const statement = p.getStatementParent();
+                    if (!statement || ((_a = statement.node.leadingComments) === null || _a === void 0 ? void 0 : _a.some((comment) => comment.value.includes(CHECK_TODO))))
+                        return;
+                    const lineStart = code.lastIndexOf('\n', statement.node.start - 1) + 1;
+                    if (flagged.has(lineStart))
+                        return;
+                    flagged.add(lineStart);
+                    const indent = /^[\t ]*/.exec(code.slice(lineStart))[0];
+                    const docs = 'https://docs.flarum.org/2.x/extend/extending-extensions';
+                    edits.push({
+                        start: lineStart,
+                        end: lineStart,
+                        text: `${indent}// ${CHECK_TODO} (${docs}). An initializer is not always named after its extension, and some were renamed in 2.0.\n`,
+                    });
+                },
+            });
+            if (edits.length === 0)
                 return null;
             return {
-                updated: code
-                    .replace(/initializers\.has\(["']lock["']\)/g, "initializers.has('flarum-lock')")
-                    .replace(/initializers\.has\(["']subscriptions["']\)/g, "initializers.has('flarum-subscriptions')")
-                    .replace(/initializers\.has\(["']flarum\/nicknames["']\)/g, "initializers.add('flarum-nicknames')"),
+                updated: edits
+                    .sort((a, b) => b.start - a.start)
+                    .reduce((result, edit) => result.slice(0, edit.start) + edit.text + result.slice(edit.end), code),
             };
         };
     }
+    /**
+     * For `app.initializers.has('name')`: the ID of the extension it checks for,
+     * or null when the upgrade can't be sure of it. Undefined for anything else.
+     */
+    checkedExtension(call) {
+        var _a, _b;
+        const callee = call.callee;
+        if (!t.isMemberExpression(callee) || callee.computed || !t.isIdentifier(callee.property, { name: 'has' }))
+            return undefined;
+        const initializers = callee.object;
+        if (!t.isMemberExpression(initializers) || initializers.computed || !t.isIdentifier(initializers.property, { name: 'initializers' })) {
+            return undefined;
+        }
+        const owner = initializers.object;
+        if (!t.isIdentifier(owner, { name: 'app' }) && !(t.isMemberExpression(owner) && t.isIdentifier(owner.property, { name: 'app' }))) {
+            return undefined;
+        }
+        const [name] = call.arguments;
+        if (call.arguments.length !== 1 || !t.isStringLiteral(name))
+            return undefined;
+        return (_a = RENAMED[name.value]) !== null && _a !== void 0 ? _a : (BUNDLED.has(name.value) ? name.value : (_b = this.namedExtensions().get(name.value)) !== null && _b !== void 0 ? _b : null);
+    }
+    /**
+     * The extensions the composer.json names, by package name and by ID.
+     */
+    namedExtensions() {
+        var _a, _b, _c, _d, _e, _f;
+        if (this.named)
+            return this.named;
+        this.named = new Map();
+        let composer = {};
+        try {
+            composer = JSON.parse(fs_1.default.readFileSync(path_1.default.join(this.root, 'composer.json'), 'utf8'));
+        }
+        catch (_g) {
+            return this.named;
+        }
+        const packages = [
+            ...Object.keys((_a = composer.require) !== null && _a !== void 0 ? _a : {}),
+            ...Object.keys((_b = composer['require-dev']) !== null && _b !== void 0 ? _b : {}),
+            ...Object.keys((_c = composer.suggest) !== null && _c !== void 0 ? _c : {}),
+            ...((_f = (_e = (_d = composer.extra) === null || _d === void 0 ? void 0 : _d['flarum-extension']) === null || _e === void 0 ? void 0 : _e['optional-dependencies']) !== null && _f !== void 0 ? _f : []),
+        ].filter((name) => typeof name === 'string' && name.includes('/'));
+        for (const name of packages) {
+            this.named.set(name, (0, composer_1.extensionId)(name));
+            this.named.set((0, composer_1.extensionId)(name), (0, composer_1.extensionId)(name));
+        }
+        return this.named;
+    }
     updateUploadImageButton() {
         return (file, code) => {
             if (!code.includes('UploadImageButton'))

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

@@ -1,10 +1,25 @@
-import { BaseUpgradeStep, GitCommit, Replacement } from './base';
+import { AdvancedContent, BaseUpgradeStep, GitCommit, Replacement } from './base';
 export default class Infrastructure extends BaseUpgradeStep {
     type: string;
     replacements(file: string): Replacement[];
     targets(): string[];
+    advancedContent(_file: string, _code: string): AdvancedContent;
     gitCommit(): GitCommit;
     pauseMessage(): string;
     updateWorkflow(): Replacement;
+    /**
+     * The reusable frontend workflow commits the built JS to `main_git_branch`,
+     * which still names 1.x. Point it at a 2.x branch when there is one. Other
+     * values are left alone: an extension's 2.x code is often on main.
+     */
+    updateMainGitBranch(code: string): Promise<string>;
+    /** Whether the extension's repository has the branch, locally or on a remote. */
+    protected hasBranch(name: string): Promise<boolean>;
+    /**
+     * Read the global typings of every Flarum package in vendor, as a new
+     * extension does, not only core's. The file is edited as text so its
+     * comments stay.
+     */
+    updateTsConfigInclude(): Replacement;
     updatePhpStan(): Replacement;
 }

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

@@ -1,6 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const simple_git_1 = tslib_1.__importDefault(require("simple-git"));
 const base_1 = require("./base");
+// Where 1.x extensions got core's global typings from, and where 2.x ones get
+// the global typings of every Flarum package they depend on.
+const CORE_GLOBAL_TYPINGS = '"../vendor/flarum/core/js/dist-typings/@types/**/*"';
+const VENDOR_GLOBAL_TYPINGS = '"../vendor/*/*/js/dist-typings/@types/**/*"';
+const indentation = (line) => line.length - line.trimStart().length;
+/**
+ * Drop a workflow's `php_versions` input, so the reusable workflow tests the
+ * PHP versions Flarum 2.0 supports and keeps up as that changes. A `with:`
+ * left without inputs goes too.
+ */
+function dropPhpVersions(code) {
+    const lines = code.split('\n');
+    const kept = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (!/^\s*php_versions:/.test(lines[i])) {
+            kept.push(lines[i]);
+            continue;
+        }
+        // A folded or literal value continues on the more indented lines below.
+        while (i + 1 < lines.length && lines[i + 1].trim() !== '' && indentation(lines[i + 1]) > indentation(lines[i])) {
+            i++;
+        }
+    }
+    return kept
+        .filter((line, i) => {
+        if (!/^\s*with:\s*(#.*)?$/.test(line))
+            return true;
+        const next = kept.slice(i + 1).find((other) => other.trim() !== '');
+        return next !== undefined && indentation(next) > indentation(line);
+    })
+        .join('\n');
+}
 class Infrastructure extends base_1.BaseUpgradeStep {
     constructor() {
         super(...arguments);
@@ -14,10 +48,18 @@ class Infrastructure extends base_1.BaseUpgradeStep {
         if (file.endsWith('.neon')) {
             replacements.push(this.updatePhpStan());
         }
+        if (file === 'js/tsconfig.json') {
+            replacements.push(this.updateTsConfigInclude());
+        }
         return replacements;
     }
     targets() {
-        return ['.github/workflows/*.yml', 'phpstan.neon'];
+        return ['.github/workflows/*.yml', 'phpstan.neon', 'js/tsconfig.json'];
+    }
+    // Every file is only edited as text: a tsconfig.json the JSON parser can't
+    // read shouldn't stop the workflows being updated.
+    advancedContent(_file, _code) {
+        return null;
     }
     gitCommit() {
         return {
@@ -29,15 +71,55 @@ class Infrastructure extends base_1.BaseUpgradeStep {
         return 'Infrastructure updated. Please review the changes then proceed.';
     }
     updateWorkflow() {
-        return (_file, code) => ({
-            updated: code
+        return async (_file, code) => ({
+            updated: await this.updateMainGitBranch(dropPhpVersions(code
                 .replace('REUSABLE_backend.yml@1.x', 'REUSABLE_backend.yml@2.x')
                 .replace('REUSABLE_frontend.yml@1.x', 'REUSABLE_frontend.yml@2.x')
                 .replace('REUSABLE_backend.yml@main', 'REUSABLE_backend.yml@2.x')
-                .replace('REUSABLE_frontend.yml@main', 'REUSABLE_frontend.yml@2.x')
-                .replace(/php_versions: '\["[^']+]'/, 'php_versions: \'["8.2", "8.3", "8.4"]\''),
+                .replace('REUSABLE_frontend.yml@main', 'REUSABLE_frontend.yml@2.x'))),
         });
     }
+    /**
+     * The reusable frontend workflow commits the built JS to `main_git_branch`,
+     * which still names 1.x. Point it at a 2.x branch when there is one. Other
+     * values are left alone: an extension's 2.x code is often on main.
+     */
+    async updateMainGitBranch(code) {
+        const setting = /^([\t ]*)main_git_branch:([\t ]*)(["']?)1\.x\3/m;
+        const match = code.match(setting);
+        if (!match)
+            return code;
+        if (await this.hasBranch('2.x')) {
+            return code.replace(setting, (_line, indent, space, quote) => `${indent}main_git_branch:${space}${quote}2.x${quote}`);
+        }
+        const todo = `${match[1]}# @TODO: Set main_git_branch to the branch your Flarum 2.x code is on. The built JS is committed to it.`;
+        // An earlier run already left it.
+        if (code.includes(todo))
+            return code;
+        return code.replace(setting, (line) => `${todo}\n${line}`);
+    }
+    /** Whether the extension's repository has the branch, locally or on a remote. */
+    async hasBranch(name) {
+        try {
+            const branches = await (0, simple_git_1.default)(this.root).branch(['--all']);
+            return branches.all.some((branch) => branch === name || (branch.startsWith('remotes/') && branch.endsWith(`/${name}`)));
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Read the global typings of every Flarum package in vendor, as a new
+     * extension does, not only core's. The file is edited as text so its
+     * comments stay.
+     */
+    updateTsConfigInclude() {
+        return (_file, code) => {
+            if (!code.includes(CORE_GLOBAL_TYPINGS) || code.includes(VENDOR_GLOBAL_TYPINGS))
+                return null;
+            return { updated: code.replace(CORE_GLOBAL_TYPINGS, VENDOR_GLOBAL_TYPINGS) };
+        };
+    }
     updatePhpStan() {
         return (_file, code) => ({
             updated: code