@flarum/cli 2.0.0-beta.8 → 3.0.0

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("./base");
+class Infrastructure extends base_1.BaseUpgradeStep {
+    constructor() {
+        super(...arguments);
+        this.type = 'Update the extension infrastructure.';
+    }
+    replacements(file) {
+        const replacements = [];
+        if (file.endsWith('.yml')) {
+            replacements.push(this.updateWorkflow());
+        }
+        if (file.endsWith('.neon')) {
+            replacements.push(this.updatePhpStan());
+        }
+        return replacements;
+    }
+    targets() {
+        return ['.github/workflows/*.yml', 'phpstan.neon'];
+    }
+    gitCommit() {
+        return {
+            message: 'chore(2.0): update infrastructure',
+            description: 'Update the extension infrastructure',
+        };
+    }
+    pauseMessage() {
+        return 'Infrastructure updated. Please review the changes then proceed.';
+    }
+    updateWorkflow() {
+        return (_file, code) => ({
+            updated: 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"]\''),
+        });
+    }
+    updatePhpStan() {
+        return (_file, code) => ({
+            updated: code
+                // remove lines
+                // checkMissingIterableValueType: false
+                // checkGenericClassInNonGenericObjectType: false
+                .replace(/^(\s+checkMissingIterableValueType: false\n|\s+checkGenericClassInNonGenericObjectType: false\n)/gm, ''),
+        });
+    }
+}
+exports.default = Infrastructure;

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

@@ -0,0 +1,12 @@
+import { BaseUpgradeStep, GitCommit, Replacement } from './base';
+export default class LessChanges extends BaseUpgradeStep {
+    type: string;
+    static MODE_SPECIFIC_VARS: string[];
+    static VARS: string[];
+    static MIXINS: string[];
+    replacements(file: string): Replacement[];
+    targets(): string[];
+    gitCommit(): GitCommit;
+    pauseMessage(): string;
+    static vars(): string[];
+}

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

@@ -0,0 +1,217 @@
+"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 LessChanges extends base_1.BaseUpgradeStep {
+    constructor() {
+        super(...arguments);
+        this.type = 'LESS code changes to more vanilla CSS';
+    }
+    replacements(file) {
+        if (!file.endsWith('.less'))
+            return [];
+        const replacements = {};
+        const declarations = {};
+        return [
+            // Replace color functions with CSS variable declarations and usage.
+            (_file, code) => {
+                // match all color functions
+                const colorFunctions = code.match(/(fade|lighten|darken|mix|saturate|desaturate|shade|fadein|fadeout|spin|tint|greyscale|contrast)\([^)]+\)/g);
+                colorFunctions === null || colorFunctions === void 0 ? void 0 : colorFunctions.forEach((colorFunction) => {
+                    const content = colorFunction.match(/(fade|lighten|darken|mix|saturate|desaturate|shade|fadein|fadeout|spin|tint|greyscale|contrast)\(([^)]+)\)/);
+                    let needsReplacement = false;
+                    for (const variable of LessChanges.MODE_SPECIFIC_VARS) {
+                        if (content === null || content === void 0 ? void 0 : content[2].includes(`@${variable}`)) {
+                            needsReplacement = true;
+                            break;
+                        }
+                    }
+                    if (needsReplacement) {
+                        const varName = content[2].match(/@([\dA-z-]+)/)[1];
+                        const modifier = content[1];
+                        const degree = content[2].replace(/[^\d.]/g, '');
+                        const newVarName = `--${varName}-${modifier}-${degree}`;
+                        replacements[colorFunction] = `var(${newVarName})`;
+                        declarations[newVarName] = {
+                            dark: colorFunction.replace(`@${varName}`, `@${varName}-dark`),
+                            light: colorFunction.replace(`@${varName}`, `@${varName}-light`),
+                        };
+                    }
+                });
+                return null;
+            },
+            // Basic replacements.
+            (_file, code) => {
+                const replaceWithCssVars = (code) => code
+                    // property: @variable => property: var(--variable)
+                    .replace(/^(\s+)([^:@]+):\s*(.*)@([\dA-z-]+)([^;]*);(.*)$/gim, (_, indent, property, before, variable, after, comments) => {
+                    if (LessChanges.vars().includes(variable) &&
+                        !/(fade|lighten|darken|mix|saturate|desaturate|shade|fadein|fadeout|spin|tint|greyscale|contrast)\(/.test(before)) {
+                        return `${indent}${property}: ${before}var(--${variable})${after};${comments}`;
+                    }
+                    return _;
+                });
+                for (const [colorFunction, replacement] of Object.entries(replacements)) {
+                    code = code.replace(colorFunction, replacement);
+                }
+                for (const mixin of LessChanges.MIXINS) {
+                    code = code.replace(new RegExp(`\\.${mixin}\\((.*?)\\);`, 'g'), `${mixin}: $1;`);
+                }
+                code = replaceWithCssVars(replaceWithCssVars(code))
+                    // light/dark mode
+                    .replace(/\s+&\s*when\s*\(\s*@config-dark-mode\s*\)\s*{/, '[data-theme^=dark] & {')
+                    .replace(/\s+&\s*when\s*\(\s*@config-dark-mode\s*=\s*true\s*\)\s*{/, '[data-theme^=dark] & {')
+                    .replace(/\s+&\s*when\s*\(\s*@config-dark-mode\s*=\s*false\s*\)\s*{/, '[data-theme^=light] & {')
+                    // colored header
+                    .replace(/\s+&\s*when\s*\(\s*@config-colored-header\s*\)\s*{/, '[data-colored-header=true] & {')
+                    .replace(/\s+&\s*when\s*\(\s*@config-colored-header\s*=\s*true\s*\)\s*{/, '[data-colored-header=true] & {')
+                    .replace(/\s+&\s*when\s*\(\s*@config-colored-header\s*=\s*false\s*\)\s*{/, '[data-colored-header=false] & {')
+                    // what couldn't be changed
+                    .replace(/^(.*@config-dark-mode.*)$/gm, '$1 /* @TODO: use [data-theme^=dark] and [data-theme^=light] instead */')
+                    .replace(/^(.*@config-colored-header.*)$/gm, '$1 /* @TODO: use [data-colored-header=true] and [data-colored-header=false] instead */')
+                    // calculations
+                    .replace(/:\s*(var\(.*?\)\s*[*+/-]\s*[^;]+);/g, ': calc(~"$1");')
+                    .replace(/:\s*(-\s*var\(.*?\)\s*[*+/-]\s*[^;]+);/g, ': calc(~"0px$1");');
+                if (Object.entries(declarations).length > 0) {
+                    let newLightVars = '[data-theme^=light] {';
+                    let newDarkVars = '[data-theme^=dark] {';
+                    for (const [varName, { light, dark }] of Object.entries(declarations)) {
+                        newLightVars += `\n  ${varName}: ${light};`;
+                        newDarkVars += `\n  ${varName}: ${dark};`;
+                    }
+                    newLightVars += '\n}';
+                    newDarkVars += '\n}';
+                    code += `\n\n${newLightVars}\n${newDarkVars}`;
+                }
+                return {
+                    updated: code,
+                };
+            },
+        ];
+    }
+    targets() {
+        return ['less/**/*', 'resources/less/**/*'];
+    }
+    gitCommit() {
+        return {
+            message: 'chore(2.0): `LESS` code changes',
+            description: 'Many variables have been renamed to light/dark specific names and most are now used as CSS variables instead.',
+        };
+    }
+    pauseMessage() {
+        const link = 'https://docs.flarum.org/2.x/extend/update-2_0/#less-preprocessing';
+        const readMore = chalk_1.default.dim(`Read more: ${link}`);
+        const dataThemeDark = chalk_1.default.yellow.bold('[data-theme^=dark]');
+        const dataThemeLight = chalk_1.default.yellow.bold('[data-theme^=light]');
+        const dataColoredHeader = chalk_1.default.yellow.bold('[data-colored-header=true]');
+        const dataColoredHeaderFalse = chalk_1.default.yellow.bold('[data-colored-header=false]');
+        const configDarkMode = chalk_1.default.yellow('@config-dark-mode');
+        const configColoredHeader = chalk_1.default.yellow('@config-colored-header');
+        return `Many variables have been renamed to light/dark specific names and most are now used as CSS variables instead.
+                     Light/Dark modes are now handled using vanilla CSS variables.
+
+                     The ${configDarkMode} and ${configColoredHeader} variables no longer exist, use instead the following selectors:
+                      - ${dataThemeDark} for dark mode
+                      - ${dataThemeLight} for light mode
+                      - ${dataColoredHeader} for colored header
+                      - ${dataColoredHeaderFalse} for non-colored header
+
+                      ${readMore}`;
+    }
+    static vars() {
+        return [...LessChanges.MODE_SPECIFIC_VARS, ...LessChanges.VARS];
+    }
+}
+exports.default = LessChanges;
+LessChanges.MODE_SPECIFIC_VARS = [
+    'body-bg',
+    'text-color',
+    'heading-color',
+    'muted-color',
+    'muted-more-color',
+    'shadow-color',
+    'control-bg',
+    'control-color',
+    'control-danger-bg',
+    'control-danger-color',
+    'header-bg',
+    'header-color',
+    'header-control-bg',
+    'header-control-color',
+    'header-bg-colored',
+    'header-color-colored',
+    'header-control-bg-colored',
+    'header-control-color-colored',
+    'overlay-bg',
+    'code-bg',
+    'code-color',
+];
+LessChanges.VARS = [
+    'primary-color',
+    'secondary-color',
+    'control-success-bg',
+    'control-success-color',
+    'control-warning-bg',
+    'control-warning-color',
+    'error-color',
+    'alert-bg',
+    'alert-color',
+    'alert-error-bg',
+    'alert-error-color',
+    'alert-success-bg',
+    'alert-success-color',
+    'validation-error-color',
+    'drawer-width',
+    'pane-width',
+    'header-height',
+    'header-height-phone',
+    'border-radius',
+    'zindex-header',
+    'zindex-pane',
+    'zindex-composer',
+    'zindex-dropdown',
+    'zindex-modal-background',
+    'zindex-modal',
+    'zindex-alerts',
+    'zindex-tooltip',
+    'tooltip-bg',
+    'tooltip-color',
+    'online-user-circle-color',
+    'link-color',
+    'text-on-dark',
+    'text-on-light',
+];
+LessChanges.MIXINS = [
+    'animation',
+    'animation-name',
+    'animation-duration',
+    'animation-timing-function',
+    'animation-delay',
+    'animation-iteration-count',
+    'animation-direction',
+    'animation-fill-mode',
+    'backface-visibility',
+    'box-shadow',
+    'box-sizing',
+    'content-columns',
+    'hyphens',
+    'scale',
+    'scaleX',
+    'scaleY',
+    'skew',
+    'translate',
+    'translate3d',
+    'rotate',
+    'rotateX',
+    'rotateY',
+    'perspective',
+    'perspective-origin',
+    'transform-origin',
+    'transition',
+    'transition-property',
+    'transition-delay',
+    'transition-duration',
+    'transition-timing-function',
+    'transition-transform',
+];

package/lib/utils/add-extenders.d.ts

@@ -0,0 +1,2 @@
+import { ExtenderDef } from '../providers/php-provider';
+export default function addExtenders(path: string, extenders: ExtenderDef[], frontend: string): void;

package/lib/utils/add-extenders.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const php_provider_1 = require("../providers/php-provider");
+const fs = tslib_1.__importStar(require("fs"));
+const t = tslib_1.__importStar(require("@babel/types"));
+const ast_1 = require("./ast");
+function addExtenders(path, extenders, frontend) {
+    var _a;
+    const code = fs.readFileSync(path, 'utf-8');
+    const ast = (0, ast_1.parseCode)(code);
+    const importing = applyImportsForExtenders(ast, extenders, frontend);
+    // The code would contain something like:
+    // const extenders = [
+    //  new Extend.Routes() //
+    //    .add('flags', '/flags', FlagsPage),
+    // ];
+    //
+    // export default extenders;
+    // We need to add the new extender to the array.
+    // We can do this by finding the array and adding the new extender to it.
+    const array = findExtendersArray(ast);
+    const expressions = [];
+    for (const extender of extenders) {
+        const classPath = extender.extender.className;
+        const className = classPath.split('/').pop();
+        // Before creating a newExtender, find an existing one.
+        let newExtender = [...array.elements, ...expressions].find(function (element) {
+            var _a, _b;
+            if ((element === null || element === void 0 ? void 0 : element.type) !== 'SequenceExpression' && (element === null || element === void 0 ? void 0 : element.type) !== 'CallExpression' && (element === null || element === void 0 ? void 0 : element.type) !== 'NewExpression') {
+                return false;
+            }
+            let newExpression = null;
+            if (element.type === 'NewExpression') {
+                newExpression = element;
+            }
+            else {
+                let callExpression = null;
+                if (element.type === 'SequenceExpression') {
+                    callExpression = element.expressions[element.expressions.length - 1];
+                }
+                if (element.type === 'CallExpression') {
+                    callExpression = element;
+                }
+                if (!callExpression) {
+                    return false;
+                }
+                if (((_a = callExpression.callee) === null || _a === void 0 ? void 0 : _a.type) === 'NewExpression') {
+                    newExpression = callExpression.callee;
+                }
+                else if (((_b = callExpression.callee) === null || _b === void 0 ? void 0 : _b.type) === 'MemberExpression') {
+                    newExpression = (0, ast_1.findNewExpressionWithinNestedMemberExpression)(callExpression.callee);
+                }
+            }
+            if (!newExpression) {
+                return false;
+            }
+            const sameName = newExpression.callee.type === 'MemberExpression'
+                ? newExpression.callee.property.name === className
+                : newExpression.callee.name === className;
+            return sameName && (0, ast_1.sameArguments)(ast, newExpression.arguments, extender.extender.args);
+        });
+        const extenderExists = Boolean(newExtender);
+        // Create the new extender expression.
+        if (!newExtender) {
+            newExtender = t.newExpression(t.identifier(importing.qualifiedModule(classPath)), ((_a = extender.extender.args) === null || _a === void 0 ? void 0 : _a.map((arg) => {
+                return (0, ast_1.argumentsExpressions)([arg])[0];
+            })) || []);
+        }
+        let callExpression = null;
+        // Wrap the new extender in a statement for method calls if any
+        if (extender.methodCalls) {
+            for (const methodCall of extender.methodCalls) {
+                if ((0, ast_1.findCallExpression)(newExtender, methodCall)) {
+                    continue;
+                }
+                callExpression = t.callExpression(t.memberExpression(callExpression !== null && callExpression !== void 0 ? callExpression : newExtender, t.identifier(methodCall.methodName)), methodCall.args ? (0, ast_1.argumentsExpressions)(methodCall.args) : []);
+            }
+        }
+        const expression = callExpression ? callExpression : newExtender;
+        if (extenderExists) {
+            // replace
+            array.elements[array.elements.indexOf(newExtender)] = expression;
+        }
+        else {
+            expressions.push(expression);
+        }
+    }
+    array.elements.push(...expressions);
+    (0, ast_1.generateCode)(ast, true).then((formattedCode) => fs.writeFileSync(path, formattedCode));
+}
+exports.default = addExtenders;
+function applyImportsForExtenders(ast, extenders, frontend) {
+    const modules = extenders.map((extender) => extender.extender.className);
+    modules.push(...extenders.flatMap((extender) => { var _a; return ((_a = extender.extender.args) === null || _a === void 0 ? void 0 : _a.filter((arg) => arg.type === php_provider_1.ExpressionType.CLASS_CONST).map((arg) => arg.value)) || []; }), ...extenders.flatMap((extender) => {
+        var _a;
+        return ((_a = extender.methodCalls) === null || _a === void 0 ? void 0 : _a.flatMap((methodCall) => { var _a; return ((_a = methodCall.args) === null || _a === void 0 ? void 0 : _a.filter((arg) => arg.type === php_provider_1.ExpressionType.CLASS_CONST).map((arg) => arg.value)) || []; })) || [];
+    }));
+    return (0, ast_1.applyImports)(ast, frontend, modules.map((module) => {
+        return {
+            name: module.split('/').pop(),
+            path: module,
+            defaultImport: true,
+        };
+    }));
+}
+function findExtendersArray(ast) {
+    let defaultExport = ast.program.body.find((node) => {
+        return node.type === 'ExportDefaultDeclaration' && node.declaration.type === 'ArrayExpression';
+    });
+    if (!defaultExport) {
+        ast.program.body.push((defaultExport = t.exportDefaultDeclaration(t.arrayExpression([]))));
+    }
+    return defaultExport.declaration;
+}

package/lib/utils/ast.d.ts

@@ -0,0 +1,22 @@
+import * as t from '@babel/types';
+import { MemberExpression, NewExpression } from '@babel/types';
+import { ExpressionSpec, MethodCallSpec } from '../providers/php-provider';
+export declare function parseCode(code: string): t.File;
+export declare function generateCode(ast: t.File, extenders?: boolean): Promise<string>;
+export type ModuleImport = {
+    name: string;
+    path: string;
+    defaultImport: boolean;
+    preferGroupImport?: boolean;
+    useNamedGroupImport?: string | null;
+};
+export declare function applyImports(ast: t.File, frontend: string, modules: ModuleImport[]): {
+    qualifiedModule: (name: string | ModuleImport) => string;
+};
+export declare function populateImports(ast: t.File, module: ModuleImport, defaultImports: Record<string, t.ImportDefaultSpecifier | null>, specificImports: Record<string, t.ImportSpecifier[] | null>, frontend: string, insertAt?: number | null): void;
+export declare function findNewExpressionWithinNestedMemberExpression(memberExpression: MemberExpression): NewExpression | null;
+export declare function findCallExpression(newExtender: t.NewExpression | t.SequenceExpression | t.CallExpression, methodCall: MethodCallSpec): boolean;
+export declare function argumentsExpressions(args: ExpressionSpec[]): Array<t.Expression>;
+export declare function sameArguments(ast: t.File, usedArguments: Array<t.Expression | t.SpreadElement | t.JSXNamespacedName | t.ArgumentPlaceholder>, extenderArgs: ExpressionSpec[] | undefined): boolean;
+export declare function formatCode(code: string, extenders?: boolean): Promise<string>;
+export declare function getFunctionName(node: t.Node): string | null;

package/lib/utils/ast.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionName = exports.formatCode = exports.sameArguments = exports.argumentsExpressions = exports.findCallExpression = exports.findNewExpressionWithinNestedMemberExpression = exports.populateImports = exports.applyImports = exports.generateCode = exports.parseCode = void 0;
+const tslib_1 = require("tslib");
+const t = tslib_1.__importStar(require("@babel/types"));
+const php_provider_1 = require("../providers/php-provider");
+const prettier_1 = tslib_1.__importDefault(require("prettier"));
+const prettierrc_json_1 = tslib_1.__importDefault(require("@flarum/prettier-config/prettierrc.json"));
+// import { parse } from '@babel/parser';
+// import generate from '@babel/generator';
+const recast = tslib_1.__importStar(require("recast"));
+function parseCode(code) {
+    try {
+        return recast.parse(code, {
+            parser: require('recast/parsers/babel-ts'),
+        });
+    }
+    catch (error) {
+        console.log(code);
+        throw error;
+    }
+}
+exports.parseCode = parseCode;
+async function generateCode(ast, extenders = false) {
+    // @ts-ignore
+    const generatedCode = recast.print(ast, {
+        parser: require('recast/parsers/babel-ts'),
+    }).code;
+    // Format the code
+    return formatCode(generatedCode, extenders);
+}
+exports.generateCode = generateCode;
+function applyImports(ast, frontend, modules) {
+    const defaultImports = {};
+    const specificImports = {};
+    modules.forEach((module) => populateImports(ast, module, defaultImports, specificImports, frontend));
+    return {
+        qualifiedModule(module) {
+            let isFullPath = true;
+            if (typeof module === 'string') {
+                isFullPath = module.includes('/');
+                module = {
+                    name: module.split('/').pop(),
+                    path: module,
+                    defaultImport: true,
+                };
+            }
+            let specificImportDeclarations = null;
+            if (isFullPath) {
+                specificImportDeclarations = specificImports[`${module.path}:${module.name}`];
+            }
+            else {
+                Object.keys(specificImports).forEach((key) => {
+                    if (key.endsWith(`:${module.name}`)) {
+                        specificImportDeclarations = specificImports[key];
+                    }
+                });
+            }
+            const specifier = specificImportDeclarations === null || specificImportDeclarations === void 0 ? void 0 : specificImportDeclarations.find((specifier) => { var _a; return ((_a = specifier === null || specifier === void 0 ? void 0 : specifier.imported) === null || _a === void 0 ? void 0 : _a.name) === module.name; });
+            if (specifier) {
+                return specifier.local.name;
+            }
+            let defaultImportDeclaration = null;
+            if (isFullPath) {
+                defaultImportDeclaration = defaultImports[`${module.path}:${module.name}`];
+            }
+            else {
+                Object.keys(defaultImports).forEach((key) => {
+                    if (key.endsWith(`:${module.name}`)) {
+                        defaultImportDeclaration = defaultImports[key];
+                    }
+                });
+            }
+            if (!module.defaultImport || module.preferGroupImport || (defaultImportDeclaration === null || defaultImportDeclaration === void 0 ? void 0 : defaultImportDeclaration.local.name) !== module.name) {
+                return `${defaultImportDeclaration.local.name}.${module.name}`;
+            }
+            return (defaultImportDeclaration === null || defaultImportDeclaration === void 0 ? void 0 : defaultImportDeclaration.local.name) || module.name;
+        },
+    };
+}
+exports.applyImports = applyImports;
+function relativizePath(path, root) {
+    return path.replace(new RegExp(`^${root}`), '.').replace(/^common/, '../common');
+}
+function populateImports(ast, module, defaultImports, specificImports, frontend, insertAt = null) {
+    var _a, _b, _c;
+    const preferDefaultImport = module.defaultImport || (module.preferGroupImport && module.useNamedGroupImport);
+    let defaultImportDeclaration = null;
+    const relativePath = relativizePath(module.path, frontend);
+    const searchedPaths = [relativePath];
+    if (module.preferGroupImport || module.defaultImport) {
+        searchedPaths.push(relativePath.split('/').slice(0, -1).join('/'));
+    }
+    if (preferDefaultImport) {
+        defaultImportDeclaration = ((_b = (_a = ast.program.body.find((node) => {
+            return (node.type === 'ImportDeclaration' &&
+                searchedPaths.includes(node.source.value) &&
+                node.specifiers.some((specifier) => specifier.type === 'ImportDefaultSpecifier'));
+        })) === null || _a === void 0 ? void 0 : _a.specifiers[0]) !== null && _b !== void 0 ? _b : null);
+    }
+    let specificImportDeclarations = (_c = ast.program.body.find((node) => {
+        return (node.type === 'ImportDeclaration' &&
+            searchedPaths.includes(node.source.value) &&
+            node.specifiers.some((specifier) => specifier.type === 'ImportSpecifier'));
+    })) === null || _c === void 0 ? void 0 : _c.specifiers;
+    if (!defaultImportDeclaration && !(specificImportDeclarations === null || specificImportDeclarations === void 0 ? void 0 : specificImportDeclarations.length) && preferDefaultImport) {
+        if (!module.preferGroupImport) {
+            defaultImportDeclaration = t.importDefaultSpecifier(t.identifier(module.name));
+            const declaration = t.importDeclaration([defaultImportDeclaration], t.stringLiteral(relativePath));
+            if (!insertAt) {
+                ast.program.body.unshift(declaration);
+            }
+            else {
+                ast.program.body.splice(insertAt, 0, declaration);
+            }
+        }
+        else if (module.useNamedGroupImport) {
+            defaultImportDeclaration = t.importDefaultSpecifier(t.identifier(module.useNamedGroupImport));
+            const declaration = t.importDeclaration([defaultImportDeclaration], t.stringLiteral(relativePath.split('/').slice(0, -1).join('/')));
+            if (!insertAt) {
+                ast.program.body.unshift(declaration);
+            }
+            else {
+                ast.program.body.splice(insertAt, 0, declaration);
+            }
+        }
+    }
+    if (!defaultImportDeclaration &&
+        ((specificImportDeclarations && specificImportDeclarations.length > 0) ||
+            (module.preferGroupImport && !module.useNamedGroupImport) ||
+            (!module.defaultImport && !module.preferGroupImport))) {
+        const imported = new Set((specificImportDeclarations === null || specificImportDeclarations === void 0 ? void 0 : specificImportDeclarations.map((specifier) => specifier.imported.name)) || []);
+        const notImported = !imported.has(module.name);
+        if (notImported) {
+            const path = relativizePath(module.preferGroupImport ? module.path.split('/').slice(0, -1).join('/') : module.path, frontend);
+            const newImports = t.importDeclaration([t.importSpecifier(t.identifier(module.name), t.identifier(module.name))], t.stringLiteral(path));
+            if (specificImportDeclarations) {
+                specificImportDeclarations.push(...newImports.specifiers);
+            }
+            else {
+                specificImportDeclarations = newImports.specifiers;
+                if (!insertAt) {
+                    ast.program.body.unshift(newImports);
+                }
+                else {
+                    ast.program.body.splice(insertAt, 0, newImports);
+                }
+            }
+        }
+    }
+    defaultImports[`${module.path}:${module.name}`] = defaultImportDeclaration;
+    specificImports[`${module.path}:${module.name}`] = specificImportDeclarations;
+}
+exports.populateImports = populateImports;
+function findNewExpressionWithinNestedMemberExpression(memberExpression) {
+    if (memberExpression.object.type === 'NewExpression') {
+        return memberExpression.object;
+    }
+    if (memberExpression.object.type === 'CallExpression' && memberExpression.object.callee.type === 'MemberExpression') {
+        return findNewExpressionWithinNestedMemberExpression(memberExpression.object.callee);
+    }
+    return null;
+}
+exports.findNewExpressionWithinNestedMemberExpression = findNewExpressionWithinNestedMemberExpression;
+function findCallExpression(newExtender, methodCall) {
+    if (newExtender.type === 'NewExpression' || newExtender.type === 'SequenceExpression') {
+        return false;
+    }
+    let found = newExtender.type === 'CallExpression' &&
+        newExtender.callee.type === 'MemberExpression' &&
+        newExtender.callee.property.type === 'Identifier' &&
+        newExtender.callee.property.name === methodCall.methodName &&
+        JSON.stringify(newExtender.arguments.map((arg) => arg.value)) ===
+            JSON.stringify((methodCall.args || []).map((arg) => arg.value));
+    if (!found && newExtender.callee.type === 'MemberExpression' && newExtender.callee.object.type === 'CallExpression') {
+        found = findCallExpression(newExtender.callee.object, methodCall);
+    }
+    return found;
+}
+exports.findCallExpression = findCallExpression;
+function argumentsExpressions(args) {
+    return args.map((arg) => {
+        switch (arg.type) {
+            case php_provider_1.ExpressionType.SCALAR:
+                return t.stringLiteral(arg.value);
+            case php_provider_1.ExpressionType.CLASS_CONST:
+                return t.identifier(arg.value.split('/').pop());
+            case php_provider_1.ExpressionType.CLOSURE:
+                return t.arrowFunctionExpression(arg.value.params.map((param) => t.identifier(param.name)), t.blockStatement([]));
+            // case ExpressionType.VARIABLE:
+            default:
+                return t.identifier(arg.value);
+        }
+    });
+}
+exports.argumentsExpressions = argumentsExpressions;
+function sameArguments(ast, usedArguments, extenderArgs) {
+    const argumentValues = usedArguments
+        .map((arg) => {
+        var _a;
+        if (arg.type === 'StringLiteral') {
+            return arg.value;
+        }
+        // return full module path
+        if (arg.type === 'Identifier') {
+            const path = (_a = ast.program.body.find((node) => {
+                return node.type === 'ImportDeclaration' && node.specifiers.some((specifier) => specifier.local.name === arg.name);
+            })) === null || _a === void 0 ? void 0 : _a.source.value;
+            return path ? `${path}/${arg.name}` : arg.name;
+        }
+        return null;
+    })
+        .filter((value) => value !== null);
+    const configuredArgs = (extenderArgs === null || extenderArgs === void 0 ? void 0 : extenderArgs.map((arg) => arg.value)) || [];
+    return JSON.stringify(argumentValues) === JSON.stringify(configuredArgs);
+}
+exports.sameArguments = sameArguments;
+function formatCode(code, extenders = false) {
+    const options = Object.assign(Object.assign({}, prettierrc_json_1.default), { parser: 'babel-ts' });
+    if (extenders) {
+        options.printWidth = 100;
+    }
+    return prettier_1.default.format(code, options);
+}
+exports.formatCode = formatCode;
+function getFunctionName(node) {
+    if (node.type === 'Identifier') {
+        return node.name;
+    }
+    if (node.type === 'MemberExpression') {
+        return `${getFunctionName(node.object)}.${getFunctionName(node.property)}`;
+    }
+    return null;
+}
+exports.getFunctionName = getFunctionName;