@scandipwa/magento-scripts 1.13.5-alpha.1 → 1.14.1-alpha.1

package/lib/tasks/file-system/create-phpstorm-config/php-config/php-project-shared-configuration-config.js

@@ -0,0 +1,69 @@
+const {
+    nameKey,
+    valueKey
+} = require('../keys');
+
+const PHP_PROJECT_SHARED_CONFIGURATION_COMPONENT_NAME = 'PhpProjectSharedConfiguration';
+
+const SUGGESTED_CHANGE_DEFAULT_LANGUAGE_LEVEL_OPTION_NAME = 'suggestChangeDefaultLanguageLevel';
+
+const phpLanguageLevelKey = '@_php_language_level';
+
+/**
+ * @param {Array} phpConfigs
+ * @param {String} currentPhpLanguageLevel
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPProjectSharedConfiguration = async (phpConfigs, currentPhpLanguageLevel) => {
+    let hasChanges = false;
+    const phpProjectSharedConfigurationComponent = phpConfigs.find(
+        (phpConfig) => phpConfig[nameKey] === PHP_PROJECT_SHARED_CONFIGURATION_COMPONENT_NAME
+    );
+
+    const defaultSuggestChangeDefaultLanguageLevelOption = {
+        [nameKey]: SUGGESTED_CHANGE_DEFAULT_LANGUAGE_LEVEL_OPTION_NAME,
+        [valueKey]: currentPhpLanguageLevel
+    };
+
+    if (phpProjectSharedConfigurationComponent) {
+        if (phpProjectSharedConfigurationComponent.option && !Array.isArray(phpProjectSharedConfigurationComponent.option)) {
+            hasChanges = true;
+            phpProjectSharedConfigurationComponent.option = [phpProjectSharedConfigurationComponent.option];
+        } else if (!phpProjectSharedConfigurationComponent.option) {
+            hasChanges = true;
+            phpProjectSharedConfigurationComponent.option = [];
+        }
+
+        if (phpProjectSharedConfigurationComponent[phpLanguageLevelKey] !== currentPhpLanguageLevel) {
+            hasChanges = true;
+            phpProjectSharedConfigurationComponent[phpLanguageLevelKey] = currentPhpLanguageLevel;
+        }
+
+        const suggestedChangeDefaultLanguageLevelOption = phpProjectSharedConfigurationComponent.option.find(
+            (phpProjectSharedConfigOption) => phpProjectSharedConfigOption[nameKey] === SUGGESTED_CHANGE_DEFAULT_LANGUAGE_LEVEL_OPTION_NAME
+        );
+
+        if (suggestedChangeDefaultLanguageLevelOption) {
+            if (suggestedChangeDefaultLanguageLevelOption[valueKey] !== 'false') {
+                hasChanges = true;
+                suggestedChangeDefaultLanguageLevelOption[valueKey] = 'false';
+            }
+        } else {
+            hasChanges = true;
+            phpProjectSharedConfigurationComponent.option.push(defaultSuggestChangeDefaultLanguageLevelOption);
+        }
+    } else {
+        hasChanges = true;
+        phpConfigs.push({
+            [nameKey]: PHP_PROJECT_SHARED_CONFIGURATION_COMPONENT_NAME,
+            [phpLanguageLevelKey]: currentPhpLanguageLevel,
+            option: [
+                defaultSuggestChangeDefaultLanguageLevelOption
+            ]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPProjectSharedConfiguration;

package/lib/tasks/file-system/create-phpstorm-config/stylelint-config.js

@@ -0,0 +1,77 @@
+const path = require('path');
+const fs = require('fs');
+const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
+const pathExists = require('../../../util/path-exists');
+const { valueKey, nameKey } = require('./keys');
+
+const STYLELINT_CONFIGURATION_COMPONENT_NAME = 'StylelintConfiguration';
+
+const pathToStylelintConfig = path.join(process.cwd(), '.idea', 'stylesheetLinters', 'stylelint.xml');
+const pathToStylelintConfigDir = path.parse(pathToStylelintConfig).dir;
+
+const DEFAULT_STYLE_PATTERN = '{**/*,*}.{css,scss}';
+
+const defaultESLintComponentConfiguration = {
+    [nameKey]: STYLELINT_CONFIGURATION_COMPONENT_NAME,
+    'file-patterns': {
+        [valueKey]: DEFAULT_STYLE_PATTERN
+    }
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const setupStylelintConfig = () => ({
+    title: 'Set up Stylelint configuration',
+    task: async (ctx, task) => {
+        if (await pathExists(pathToStylelintConfig)) {
+            let hasChanges = false;
+            const styleLintConfigurationData = await loadXmlFile(pathToStylelintConfig);
+
+            if (styleLintConfigurationData.project.component && !Array.isArray(styleLintConfigurationData.project.component)) {
+                hasChanges = true;
+                styleLintConfigurationData.project.component = [styleLintConfigurationData.project.component];
+            }
+
+            const styleLintConfigurationComponent = styleLintConfigurationData.project.component.find(
+                (component) => component[nameKey] === STYLELINT_CONFIGURATION_COMPONENT_NAME
+            );
+
+            if (!styleLintConfigurationComponent) {
+                hasChanges = true;
+                styleLintConfigurationData.project.component.push(defaultESLintComponentConfiguration);
+            }
+
+            if (hasChanges) {
+                await buildXmlFile(pathToStylelintConfig, styleLintConfigurationData);
+            } else {
+                task.skip();
+            }
+
+            return;
+        }
+
+        if (!await pathExists(pathToStylelintConfigDir)) {
+            await fs.promises.mkdir(pathToStylelintConfigDir, {
+                recursive: true
+            });
+        }
+
+        const styleLintConfigurationData = {
+            '?xml': {
+                '@_version': '1.0',
+                '@_encoding': 'UTF-8'
+            },
+            project: {
+                '@_version': '4',
+                component: [
+                    defaultESLintComponentConfiguration
+                ]
+            }
+        };
+
+        await buildXmlFile(pathToStylelintConfig, styleLintConfigurationData);
+    }
+});
+
+module.exports = setupStylelintConfig;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/composer-settings-config.js

@@ -0,0 +1,98 @@
+const path = require('path');
+const { baseConfig } = require('../../../../config');
+const pathExists = require('../../../../util/path-exists');
+const { nameKey } = require('../keys');
+const { formatPathForPHPStormConfig } = require('../xml-utils');
+
+const COMPOSER_SETTINGS_COMPONENT_NAME = 'ComposerSettings';
+
+const pharPathKey = '@_pharPath';
+const doNotAskKey = '@_doNotAsk';
+const synchronizationStateKey = '@_synchronizationState';
+
+const composerJsonPath = path.join(process.cwd(), 'composer.json');
+const composerJsonFormattedPath = formatPathForPHPStormConfig(composerJsonPath);
+const composerPharPath = path.join(baseConfig.cacheDir, 'composer', 'composer.phar');
+const composerPharFormattedPath = formatPathForPHPStormConfig(composerPharPath);
+
+const defaultComposerSettingsProperties = {
+    [doNotAskKey]: 'true',
+    [synchronizationStateKey]: 'SYNCHRONIZE'
+};
+
+// TODO Ideally, we want to setup interpreter for compose.phar
+
+// It should look like this:
+// <component name="ComposerSettings" synchronizationState="DONT_SYNCHRONIZE">
+//     <pharConfigPath>$PROJECT_DIR$/composer.json</pharConfigPath>
+//     <execution>
+//         <phar
+//             pharPath="$PROJECT_DIR$/node_modules/.create-magento-app-cache/composer/composer.phar"
+//             interpreterId="f19b09e2-16e7-491f-9056-3299df58e578"
+//         />
+//     </execution>
+// </component>
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupComposerSettings = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const composerSettingsComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === COMPOSER_SETTINGS_COMPONENT_NAME
+    );
+
+    const isComposerJsonExists = await pathExists(composerJsonPath);
+    const isComposerPharExists = await pathExists(composerPharPath);
+
+    if (composerSettingsComponent) {
+        if (
+            'pharConfigPath' in composerSettingsComponent
+            && isComposerJsonExists
+            && composerSettingsComponent.pharConfigPath !== composerJsonFormattedPath
+        ) {
+            hasChanges = true;
+            composerSettingsComponent.pharConfigPath = composerJsonFormattedPath;
+        }
+
+        const pharConfig = composerSettingsComponent.execution && composerSettingsComponent.execution.phar;
+
+        if (pharConfig && isComposerPharExists && pharConfig[pharPathKey] !== composerPharFormattedPath) {
+            hasChanges = true;
+            pharConfig[pharPathKey] = composerPharFormattedPath;
+        } else if (!pharConfig && isComposerPharExists) {
+            hasChanges = true;
+            composerSettingsComponent.execution = composerSettingsComponent.execution || {};
+            composerSettingsComponent.execution.phar = {
+                [pharPathKey]: composerPharFormattedPath
+            };
+        }
+
+        const composerSettingsMissingProperties = Object.entries(defaultComposerSettingsProperties)
+            .filter(([key]) => !(key in composerSettingsComponent));
+
+        if (composerSettingsMissingProperties.length > 0) {
+            hasChanges = true;
+            composerSettingsMissingProperties.forEach(([key, value]) => {
+                composerSettingsComponent[key] = value;
+            });
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: COMPOSER_SETTINGS_COMPONENT_NAME,
+            ...defaultComposerSettingsProperties,
+            pharConfigPath: composerJsonFormattedPath,
+            execution: {
+                phar: {
+                    [pharPathKey]: composerPharFormattedPath
+                }
+            }
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupComposerSettings;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/format-setting-config.js

@@ -0,0 +1,57 @@
+const {
+    nameKey,
+    valueKey
+} = require('../keys');
+
+const FORMAT_ON_SAVE_OPTIONS_COMPONENT_NAME = 'FormatOnSaveOptions';
+
+const MY_FORMAT_ONLY_CHANGED_LINES_OPTION_NAME = 'myFormatOnlyChangedLines';
+const MY_RUN_ON_SAVE_OPTION_NAME = 'myRunOnSave';
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupFormatOnSave = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const formatOnSaveOptionsComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === FORMAT_ON_SAVE_OPTIONS_COMPONENT_NAME
+    );
+
+    if (formatOnSaveOptionsComponent) {
+        if (formatOnSaveOptionsComponent.option && !Array.isArray(formatOnSaveOptionsComponent.option)) {
+            hasChanges = true;
+            formatOnSaveOptionsComponent.option = [formatOnSaveOptionsComponent.option];
+        } else if (!formatOnSaveOptionsComponent.option) {
+            hasChanges = true;
+            formatOnSaveOptionsComponent.option = [];
+        }
+
+        const missingOptions = [MY_FORMAT_ONLY_CHANGED_LINES_OPTION_NAME, MY_RUN_ON_SAVE_OPTION_NAME].filter(
+            (optionName) => !formatOnSaveOptionsComponent.option.some((option) => option[nameKey] === optionName)
+        );
+
+        if (missingOptions.length > 0) {
+            hasChanges = true;
+            missingOptions.forEach((missingOption) => {
+                formatOnSaveOptionsComponent.option.push({
+                    [nameKey]: missingOption,
+                    [valueKey]: 'true'
+                });
+            });
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: FORMAT_ON_SAVE_OPTIONS_COMPONENT_NAME,
+            option: [MY_FORMAT_ONLY_CHANGED_LINES_OPTION_NAME, MY_RUN_ON_SAVE_OPTION_NAME].map((option) => ({
+                [nameKey]: option,
+                [valueKey]: 'true'
+            }))
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupFormatOnSave;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/index.js

@@ -0,0 +1,66 @@
+const { loadXmlFile, buildXmlFile } = require('../../../../config/xml-parser');
+const pathExists = require('../../../../util/path-exists');
+const setupComposerSettings = require('./composer-settings-config');
+const setupFormatOnSave = require('./format-setting-config');
+const setupPHPDebugGeneral = require('./php-debug-general-config');
+const setupPHPServers = require('./php-server-config');
+const setupPropertiesComponent = require('./properties-component-config');
+const setupRunManager = require('./run-manager-config');
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext>}
+ */
+const setupWorkspaceConfig = () => ({
+    title: 'Set up Workspace configuration',
+    task: async (ctx, task) => {
+        const {
+            config: {
+                phpStorm
+            }
+        } = ctx;
+
+        if (await pathExists(phpStorm.xdebug.path)) {
+            const workspaceConfiguration = await loadXmlFile(phpStorm.xdebug.path);
+            const workspaceConfigs = workspaceConfiguration.project.component;
+            const hasChanges = await Promise.all([
+                setupPHPDebugGeneral(workspaceConfigs, phpStorm),
+                setupPHPServers(workspaceConfigs, phpStorm),
+                setupRunManager(workspaceConfigs, phpStorm),
+                setupPropertiesComponent(workspaceConfigs)
+            ]);
+
+            if (hasChanges.includes(true)) {
+                await buildXmlFile(phpStorm.php.path, workspaceConfiguration);
+            } else {
+                task.skip();
+            }
+
+            return;
+        }
+
+        const workspaceConfiguration = {
+            '?xml': {
+                '@_version': '1.0',
+                '@_encoding': 'UTF-8'
+            },
+            project: {
+                '@_version': '4',
+                component: []
+            }
+        };
+        const workspaceConfigs = workspaceConfiguration.project.component;
+
+        await Promise.all([
+            setupPHPDebugGeneral(workspaceConfigs, phpStorm),
+            setupPHPServers(workspaceConfigs, phpStorm),
+            setupRunManager(workspaceConfigs, phpStorm),
+            setupPropertiesComponent(workspaceConfigs),
+            setupComposerSettings(workspaceConfigs),
+            setupFormatOnSave(workspaceConfigs)
+        ]);
+
+        await buildXmlFile(phpStorm.xdebug.path, workspaceConfiguration);
+    }
+});
+
+module.exports = setupWorkspaceConfig;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-debug-general-config.js

@@ -0,0 +1,64 @@
+const {
+    nameKey
+} = require('../keys');
+
+const PHP_DEBUG_GENERAL_COMPONENT_NAME = 'PhpDebugGeneral';
+
+const portKey = '@_port';
+const xdebugDebugPortKey = '@_xdebug_debug_port';
+const ignoreConnectionsThroughUnregisteredServersKey = '@_ignore_connections_through_unregistered_servers';
+
+/**
+ * @param {Array} workspaceConfigs
+ * @param {import('../../../../../typings/phpstorm').PHPStormConfig} phpStormConfiguration
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPDebugGeneral = async (workspaceConfigs, phpStormConfiguration) => {
+    const { xdebug } = phpStormConfiguration;
+    let hasChanges = false;
+    const phpDebugGeneralComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_DEBUG_GENERAL_COMPONENT_NAME
+    );
+
+    if (phpDebugGeneralComponent) {
+        if (phpDebugGeneralComponent.xdebug_debug_ports && !Array.isArray(phpDebugGeneralComponent.xdebug_debug_ports)) {
+            hasChanges = true;
+            phpDebugGeneralComponent.xdebug_debug_ports = [phpDebugGeneralComponent.xdebug_debug_ports];
+        } else if (!phpDebugGeneralComponent.xdebug_debug_ports) {
+            hasChanges = true;
+            phpDebugGeneralComponent.xdebug_debug_ports = [];
+        }
+
+        if (!(xdebugDebugPortKey in phpDebugGeneralComponent)) {
+            hasChanges = true;
+            phpDebugGeneralComponent[xdebugDebugPortKey] = xdebug.v3Port;
+        }
+
+        const missingXDebugPorts = [xdebug.v3Port, xdebug.v2Port].filter(
+            (port) => !phpDebugGeneralComponent.xdebug_debug_ports.some((xPort) => xPort[portKey] === port)
+        );
+
+        if (missingXDebugPorts.length > 0) {
+            hasChanges = true;
+            missingXDebugPorts.forEach((port) => {
+                phpDebugGeneralComponent.xdebug_debug_ports.push({
+                    [portKey]: port
+                });
+            });
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_DEBUG_GENERAL_COMPONENT_NAME,
+            [xdebugDebugPortKey]: xdebug.v3Port,
+            [ignoreConnectionsThroughUnregisteredServersKey]: 'true',
+            xdebug_debug_ports: [xdebug.v3Port, xdebug.v2Port].map((port) => ({
+                [portKey]: port
+            }))
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPDebugGeneral;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-server-config.js

@@ -0,0 +1,60 @@
+const { nameKey } = require('../keys');
+
+const PHP_SERVERS_COMPONENT_NAME = 'PhpServers';
+
+const hostKey = '@_host';
+
+/**
+ * @param {Array} workspaceConfigs
+ * @param {import('../../../../../typings/phpstorm').PHPStormConfig} phpStormConfiguration
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPServers = async (workspaceConfigs, phpStormConfiguration) => {
+    const { xdebug } = phpStormConfiguration;
+    let hasChanges = false;
+    const phpServersComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_SERVERS_COMPONENT_NAME
+    );
+
+    const defaultServerConfig = {
+        [hostKey]: xdebug.debugServerAddress,
+        id: '7e16e907-9ce3-4559-9d26-a30a5650d11f',
+        [nameKey]: xdebug.serverName
+    };
+
+    if (phpServersComponent) {
+        if (phpServersComponent.servers && !Array.isArray(phpServersComponent.servers)) {
+            hasChanges = true;
+            phpServersComponent.servers = [phpServersComponent.servers];
+        } else if (!phpServersComponent.servers) {
+            hasChanges = true;
+            phpServersComponent.servers = [];
+        }
+
+        const serverConfiguration = phpServersComponent.servers.find((server) => server.server[nameKey] === xdebug.serverName);
+
+        if (serverConfiguration && serverConfiguration.server[hostKey] !== xdebug.debugServerAddress) {
+            hasChanges = true;
+            serverConfiguration.server[hostKey] = xdebug.debugServerAddress;
+        } else if (!serverConfiguration) {
+            hasChanges = true;
+            phpServersComponent.servers.push({
+                server: defaultServerConfig
+            });
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_SERVERS_COMPONENT_NAME,
+            servers: [
+                {
+                    server: defaultServerConfig
+                }
+            ]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPServers;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/properties-component-config.js

@@ -0,0 +1,51 @@
+const path = require('path');
+// const { baseConfig } = require('../../../../config');
+const { getCSAThemes } = require('../../../../util/CSA-theme');
+const pathExists = require('../../../../util/path-exists');
+const { nameKey } = require('../keys');
+// const { formatPathForPHPStormConfig } = require('../xml-utils');
+
+const PROPERTIES_COMPONENT_NAME = 'PropertiesComponent';
+
+const defaultProperties = {
+    keyToString: {
+        'RunOnceActivity.OpenProjectViewOnStart': 'true',
+        'RunOnceActivity.ShowReadmeOnStart': 'true'
+    }
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPropertiesComponent = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const propertiesComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PROPERTIES_COMPONENT_NAME
+    );
+
+    if (propertiesComponent) {
+        // check later
+    } else {
+        hasChanges = true;
+        const themes = await getCSAThemes();
+        if (themes.length > 0) {
+            const theme = themes[0];
+            const themeESLintPath = path.join(process.cwd(), theme.themePath, 'node_modules', 'eslint');
+            if (await pathExists(themeESLintPath)) {
+                defaultProperties.keyToString['node.js.selected.package.eslint'] = themeESLintPath;
+                defaultProperties.keyToString['js.linters.configure.manually.selectedeslint'] = 'true';
+                defaultProperties.keyToString['node.js.detected.package.eslint'] = 'true';
+                defaultProperties.keyToString['settings.editor.selected.configurable'] = 'settings.javascript.linters.eslint';
+            }
+        }
+        workspaceConfigs.push({
+            [nameKey]: PROPERTIES_COMPONENT_NAME,
+            '#text': JSON.stringify(defaultProperties)
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPropertiesComponent;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/run-manager-config.js

@@ -0,0 +1,74 @@
+const { nameKey } = require('../keys');
+
+const RUN_MANAGER_COMPONENT_NAME = 'RunManager';
+
+const PHP_REMOTE_DEBUG_RUN_CONFIGURATION_TYPE = 'PhpRemoteDebugRunConfigurationType';
+
+const serverNameKey = '@_server_name';
+const sessionIdKey = '@_session_id';
+
+/**
+ * @param {Array} workspaceConfigs
+ * @param {import('../../../../../typings/phpstorm').PHPStormConfig} phpStormConfiguration
+ * @returns {Promise<Boolean>}
+ */
+const setupRunManager = async (workspaceConfigs, phpStormConfiguration) => {
+    const { xdebug } = phpStormConfiguration;
+    let hasChanges = false;
+    const runManagerComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === RUN_MANAGER_COMPONENT_NAME
+    );
+
+    const defaultRunManagerConfiguration = {
+        [nameKey]: xdebug.runManagerName,
+        '@_type': PHP_REMOTE_DEBUG_RUN_CONFIGURATION_TYPE,
+        '@_factoryName': 'PHP Remote Debug',
+        '@_filter_connections': 'FILTER',
+        [serverNameKey]: xdebug.serverName,
+        [sessionIdKey]: xdebug.sessionId,
+        method: {
+            '@_v': '2'
+        }
+    };
+
+    if (runManagerComponent) {
+        if (runManagerComponent.configuration && !Array.isArray(runManagerComponent.configuration)) {
+            hasChanges = true;
+            runManagerComponent.configuration = [runManagerComponent.configuration];
+        } else if (!runManagerComponent.configuration) {
+            hasChanges = true;
+            runManagerComponent.configuration = [];
+        }
+
+        const phpRemoteDebugRunConfiguration = runManagerComponent.configuration.find(
+            (configuration) => configuration['@_type'] === PHP_REMOTE_DEBUG_RUN_CONFIGURATION_TYPE && configuration[nameKey] === xdebug.runManagerName
+        );
+
+        if (phpRemoteDebugRunConfiguration) {
+            if (phpRemoteDebugRunConfiguration[serverNameKey] !== xdebug.serverName) {
+                hasChanges = true;
+                phpRemoteDebugRunConfiguration[serverNameKey] = xdebug.serverName;
+            }
+
+            if (phpRemoteDebugRunConfiguration[sessionIdKey] !== xdebug.sessionId) {
+                hasChanges = true;
+                phpRemoteDebugRunConfiguration[sessionIdKey] = xdebug.sessionId;
+            }
+        } else {
+            hasChanges = true;
+            runManagerComponent.configuration.push(defaultRunManagerConfiguration);
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: RUN_MANAGER_COMPONENT_NAME,
+            configuration: [
+                defaultRunManagerConfiguration
+            ]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupRunManager;

package/lib/tasks/file-system/create-phpstorm-config/xml-utils.js

@@ -0,0 +1,5 @@
+const formatPathForPHPStormConfig = (p) => p.replace(process.cwd(), '$PROJECT_DIR$');
+
+module.exports = {
+    formatPathForPHPStormConfig
+};

package/lib/tasks/file-system/index.js

@@ -1,7 +1,7 @@
 const createNginxConfig = require('./create-nginx-config');
 const createPhpConfig = require('./create-php-config');
 const createPhpFpmConfig = require('./create-php-fpm-config');
-const createPhpStormConfig = require('./create-php-storm-config');
+const createPhpStormConfig = require('./create-phpstorm-config');
 const createVSCodeConfig = require('./create-vscode-config');
 
 /**

package/lib/tasks/php/compile-options.js

@@ -74,7 +74,8 @@ const compileOptions = {
             CPATH: '$CPATH:$(brew --prefix openssl@1.1)/include',
             CXX: 'g++ -DTRUE=1 -DFALSE=0',
             CC: 'gcc -DTRUE=1 -DFALSE=0',
-            LDFLAGS: '$(brew --prefix openssl@1.1)/lib/libssl.dylib $(brew --prefix openssl@1.1)/lib/libcrypto.dylib'
+            LDFLAGS: '$(brew --prefix openssl@1.1)/lib/libssl.dylib $(brew --prefix openssl@1.1)/lib/libcrypto.dylib',
+            CFLAGS: '-Wno-implicit-function-declaration' // https://github.com/phpbrew/phpbrew/issues/1222
         }
     }
 };

package/lib/tasks/php/compile.js

@@ -16,7 +16,7 @@ const compile = () => ({
                 platformCompileOptions.extraOptions.push('--with-libdir=lib64');
             }
         }
-        const commandEnv = Object.entries(platformCompileOptions.env || {}).map(([key, value]) => `${key}="${value}"`).join(' && ');
+        const commandEnv = Object.entries(platformCompileOptions.env || {}).map(([key, value]) => `export ${key}="${value}"`).join(' && ');
         const phpCompileCommand = `${commandEnv ? `${commandEnv} && ` : ''} \
         phpbrew install -j ${platformCompileOptions.cpuCount} ${php.version} ${platformCompileOptions.variants.join(' ')} \
         -- ${platformCompileOptions.extraOptions.join(' ')}`;