@scandipwa/magento-scripts 1.14.0 → 1.14.1-alpha.2

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/php-cs-fixer-validation-inspection-config.js

@@ -0,0 +1,60 @@
+const {
+    classes: {
+        PHP_CS_FIXER_VALIDATION_INSPECTION
+    }
+} = require('./config');
+const { classKey } = require('../keys');
+const setupCodingStandardOption = require('./coding-standard-config');
+const setupCustomRuleSetPathOption = require('./custom-ruleset-path-config');
+const setupDefaultProperties = require('./default-properties-config');
+
+/**
+ * @param {Array} inspectionToolsData
+ * @returns {Promise<Boolean>}
+ */
+const setupPhpCSFixerValidationInspection = async (inspectionToolsData) => {
+    let hasChanges = false;
+    const phpCSFixerConfig = inspectionToolsData.find(
+        (inspectionToolData) => inspectionToolData[classKey] === PHP_CS_FIXER_VALIDATION_INSPECTION
+    );
+
+    if (phpCSFixerConfig) {
+        const hasChangesInProperties = setupDefaultProperties(phpCSFixerConfig);
+        if (hasChangesInProperties) {
+            hasChanges = true;
+        }
+
+        if (phpCSFixerConfig.option) {
+            const hasCodingStandardChanges = await setupCodingStandardOption(phpCSFixerConfig);
+            if (hasCodingStandardChanges) {
+                hasChanges = true;
+            }
+
+            const hasCustomRuleSetChanges = await setupCustomRuleSetPathOption(phpCSFixerConfig);
+            if (hasCustomRuleSetChanges) {
+                hasChanges = true;
+            }
+        } else {
+            hasChanges = true;
+            phpCSFixerConfig.option = [];
+            await setupCodingStandardOption(phpCSFixerConfig);
+            await setupCustomRuleSetPathOption(phpCSFixerConfig);
+        }
+    } else {
+        hasChanges = true;
+        const phpCSFixerConfig = {
+            [classKey]: PHP_CS_FIXER_VALIDATION_INSPECTION,
+            option: []
+        };
+
+        setupDefaultProperties(phpCSFixerConfig);
+        await setupCodingStandardOption(phpCSFixerConfig);
+        await setupCustomRuleSetPathOption(phpCSFixerConfig);
+
+        inspectionToolsData.push(phpCSFixerConfig);
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPhpCSFixerValidationInspection;

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/php-cs-validation-inspection-config.js

@@ -0,0 +1,119 @@
+const {
+    classes: {
+        PHP_CS_VALIDATION_INSPECTION
+    },
+    options: {
+        CODING_STANDARD_OPTION_NAME,
+        MAGENTO2_CODING_STANDARD_OPTION_VALUE,
+        EXTENSIONS_OPTION_NAME,
+        WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME,
+        WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_VALUE,
+        SHOW_SNIFF_NAMES_OPTION_NAME
+    }
+} = require('./config');
+const {
+    classKey,
+    nameKey,
+    valueKey
+} = require('../keys');
+const setupDefaultProperties = require('./default-properties-config');
+const setupMagento2CodingStandardOption = require('./magento-coding-standard-config');
+
+const phpCSConfigDefaultOptions = [
+    {
+        [nameKey]: CODING_STANDARD_OPTION_NAME,
+        [valueKey]: MAGENTO2_CODING_STANDARD_OPTION_VALUE
+    },
+    {
+        [nameKey]: WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME,
+        [valueKey]: WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_VALUE
+    },
+    {
+        [nameKey]: SHOW_SNIFF_NAMES_OPTION_NAME,
+        [valueKey]: 'true'
+    },
+    {
+        [nameKey]: EXTENSIONS_OPTION_NAME,
+        [valueKey]: 'php'
+    }
+];
+
+const setupPhpCSValidationInspection = async (inspectionToolsData) => {
+    let hasChanges = false;
+    const phpCSConfig = inspectionToolsData.find(
+        (inspectionToolData) => inspectionToolData[classKey] === PHP_CS_VALIDATION_INSPECTION
+    );
+
+    if (phpCSConfig) {
+        const hasChangesInProperties = setupDefaultProperties(phpCSConfig);
+        if (hasChangesInProperties) {
+            hasChanges = true;
+        }
+
+        if (phpCSConfig.option) {
+            const hasCodingStandardChanges = await setupMagento2CodingStandardOption(phpCSConfig);
+            if (hasCodingStandardChanges) {
+                hasChanges = true;
+            }
+
+            const warningHighlightLevelNameOption = phpCSConfig.option.find(
+                (option) => option[nameKey] === WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME
+            );
+
+            if (!warningHighlightLevelNameOption) {
+                hasChanges = true;
+                phpCSConfig.option.push({
+                    [nameKey]: WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME,
+                    [valueKey]: WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_VALUE
+                });
+            }
+
+            const showSniffNamesOption = phpCSConfig.option.find(
+                (option) => option[nameKey] === SHOW_SNIFF_NAMES_OPTION_NAME
+            );
+
+            if (!showSniffNamesOption) {
+                hasChanges = true;
+                phpCSConfig.option.push({
+                    [nameKey]: SHOW_SNIFF_NAMES_OPTION_NAME,
+                    [valueKey]: 'true'
+                });
+            }
+
+            // we want php code sniffer to lint only php files
+            // for other files (js, css, scss) we have separate linter setups
+            const extensionsOption = phpCSConfig.option.find(
+                (option) => option[nameKey] === EXTENSIONS_OPTION_NAME
+            );
+
+            if (extensionsOption && extensionsOption[valueKey] !== 'php') {
+                hasChanges = true;
+                extensionsOption[valueKey] = 'php';
+            } else if (!extensionsOption) {
+                hasChanges = true;
+                phpCSConfig.option.push({
+                    [nameKey]: EXTENSIONS_OPTION_NAME,
+                    [valueKey]: 'php'
+                });
+            }
+        } else {
+            hasChanges = true;
+            phpCSConfig.option = phpCSConfigDefaultOptions;
+        }
+    } else {
+        hasChanges = true;
+
+        const phpCSConfig = {
+            [classKey]: PHP_CS_VALIDATION_INSPECTION,
+            option: phpCSConfigDefaultOptions
+        };
+
+        setupDefaultProperties(phpCSConfig);
+
+        inspectionToolsData.push(phpCSConfig);
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPhpCSValidationInspection;

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

@@ -0,0 +1,37 @@
+const {
+    classes: {
+        STYLELINT_INSPECTION
+    }
+} = require('./config');
+const { classKey } = require('../keys');
+const setupDefaultProperties = require('./default-properties-config');
+
+/**
+ * Set up Styelint configuration
+ *
+ * *function is async so it will be properly handled in Promise.all*
+ * @param {Array} inspectionToolsData
+ * @returns {Promise<Boolean>}
+ */
+const setupStyleLintInspection = async (inspectionToolsData) => {
+    let hasChanges = false;
+    const stylelintConfig = inspectionToolsData.find(
+        (inspectionToolData) => inspectionToolData[classKey] === STYLELINT_INSPECTION
+    );
+
+    if (stylelintConfig) {
+        hasChanges = setupDefaultProperties(stylelintConfig);
+    } else {
+        hasChanges = true;
+        inspectionToolsData.push({
+            [classKey]: STYLELINT_INSPECTION,
+            '@_enabled': 'true',
+            '@_level': 'ERROR',
+            '@_enabled_by_default': 'true'
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupStyleLintInspection;

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

@@ -0,0 +1,14 @@
+// xml property key names
+const classKey = '@_class';
+const nameKey = '@_name';
+const valueKey = '@_value';
+const toolPathKey = '@_tool_path';
+const standardsKey = '@_standards';
+
+module.exports = {
+    classKey,
+    nameKey,
+    valueKey,
+    toolPathKey,
+    standardsKey
+};

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

@@ -0,0 +1,67 @@
+const { loadXmlFile, buildXmlFile } = require('../../../../config/xml-parser');
+const pathExists = require('../../../../util/path-exists');
+const setupMessDetector = require('./mess-detector-config');
+const setupPHPCodeSniffer = require('./php-code-sniffer-config');
+const setupPHPCSFixer = require('./php-cs-fixer-config');
+const setupPHPProjectSharedConfiguration = require('./php-project-shared-configuration-config');
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext>}
+ */
+const setupPhpConfig = () => ({
+    title: 'Set up PHP configuration',
+    task: async (ctx, task) => {
+        const {
+            config: {
+                phpStorm,
+                phpStorm: {
+                    php: {
+                        phpLanguageLevel
+                    }
+                }
+            }
+        } = ctx;
+
+        if (await pathExists(phpStorm.php.path)) {
+            const phpConfigContent = await loadXmlFile(phpStorm.php.path);
+            const phpConfigs = phpConfigContent.project.component;
+            const hasChanges = await Promise.all([
+                setupMessDetector(phpConfigs),
+                setupPHPCodeSniffer(phpConfigs),
+                setupPHPCSFixer(phpConfigs),
+                setupPHPProjectSharedConfiguration(phpConfigs, phpLanguageLevel)
+            ]);
+
+            if (hasChanges.includes(true)) {
+                await buildXmlFile(phpStorm.php.path, phpConfigContent);
+            } else {
+                task.skip();
+            }
+
+            return;
+        }
+
+        const phpConfigContent = {
+            '?xml': {
+                '@_version': '1.0',
+                '@_encoding': 'UTF-8'
+            },
+            project: {
+                '@_version': '4',
+                component: []
+            }
+        };
+        const phpConfigs = phpConfigContent.project.component;
+
+        await Promise.all([
+            setupMessDetector(phpConfigs),
+            setupPHPCodeSniffer(phpConfigs),
+            setupPHPCSFixer(phpConfigs),
+            setupPHPProjectSharedConfiguration(phpConfigs, phpLanguageLevel)
+        ]);
+
+        await buildXmlFile(phpStorm.php.path, phpConfigContent);
+    }
+});
+
+module.exports = setupPhpConfig;

package/lib/tasks/file-system/create-phpstorm-config/php-config/mess-detector-config.js

@@ -0,0 +1,57 @@
+const path = require('path');
+const pathExists = require('../../../../util/path-exists');
+const { nameKey, toolPathKey } = require('../keys');
+const { formatPathForPHPStormConfig } = require('../xml-utils');
+
+const phpMDBinaryPath = path.join(process.cwd(), 'vendor', 'bin', 'phpmd');
+const phpMDBinaryFormattedPath = formatPathForPHPStormConfig(phpMDBinaryPath);
+
+const defaultMessDetectorSetting = {
+    MessDetectorConfiguration: {
+        [toolPathKey]: phpMDBinaryFormattedPath
+    }
+};
+
+/**
+ * @param {Array} phpConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupMessDetector = async (phpConfigs) => {
+    let hasChanges = false;
+    const messDetectorComponent = phpConfigs.find(
+        (phpConfig) => phpConfig[nameKey] === 'MessDetector'
+    );
+
+    const isPhpMDBinPathExists = await pathExists(phpMDBinaryPath);
+
+    if (messDetectorComponent && isPhpMDBinPathExists) {
+        if (!Array.isArray(messDetectorComponent.phpmd_settings)) {
+            hasChanges = true;
+            messDetectorComponent.phpmd_settings = [messDetectorComponent.phpmd_settings];
+        }
+
+        const messDetectorConfiguration = messDetectorComponent.phpmd_settings.find(
+            (phpmdSetting) => phpmdSetting.MessDetectorConfiguration
+        );
+
+        if (messDetectorConfiguration && messDetectorConfiguration[toolPathKey] !== phpMDBinaryFormattedPath) {
+            hasChanges = true;
+            messDetectorConfiguration[toolPathKey] = phpMDBinaryFormattedPath;
+        } else if (!messDetectorConfiguration) {
+            hasChanges = true;
+            messDetectorComponent.phpmd_settings.push(defaultMessDetectorSetting);
+        }
+    } else if (isPhpMDBinPathExists) {
+        hasChanges = true;
+        phpConfigs.push({
+            [nameKey]: 'MessDetector',
+            phpmd_settings: [
+                defaultMessDetectorSetting
+            ]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupMessDetector;

package/lib/tasks/file-system/create-phpstorm-config/php-config/php-code-sniffer-config.js

@@ -0,0 +1,76 @@
+const path = require('path');
+const pathExists = require('../../../../util/path-exists');
+const { nameKey, toolPathKey, standardsKey } = require('../keys');
+const { formatPathForPHPStormConfig } = require('../xml-utils');
+
+const PHP_CODE_SNIFFER_COMPONENT_NAME = 'PhpCodeSniffer';
+
+const beautifierPathKey = '@_beautifier_path';
+
+const phpCodeSnifferStandards = 'MySource;PEAR;PHPCompatibility;PSR1;PSR12;PSR2;Squiz;Zend';
+const phpCodeSnifferBinaryPath = path.join(process.cwd(), 'vendor', 'bin', 'phpcs');
+const phpCodeSnifferBinaryFormattedPath = formatPathForPHPStormConfig(phpCodeSnifferBinaryPath);
+
+const phpCodeSnifferBeautifierBinaryPath = path.join(process.cwd(), 'vendor', 'bin', 'phpcbf');
+const phpCodeSnifferBeautifierBinaryFormattedPath = formatPathForPHPStormConfig(phpCodeSnifferBeautifierBinaryPath);
+
+const defaultPHPCSSetting = {
+    PhpCSConfiguration: {
+        [toolPathKey]: phpCodeSnifferBinaryFormattedPath,
+        [standardsKey]: phpCodeSnifferStandards,
+        [beautifierPathKey]: phpCodeSnifferBeautifierBinaryFormattedPath
+    }
+};
+
+/**
+ * @param {Array} phpConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPCodeSniffer = async (phpConfigs) => {
+    let hasChanges = false;
+    const phpCodeSnifferComponent = phpConfigs.find(
+        (phpConfig) => phpConfig[nameKey] === PHP_CODE_SNIFFER_COMPONENT_NAME
+    );
+
+    const isPhpCodeSnifferBinPathExists = await pathExists(phpCodeSnifferBinaryPath);
+    const isPhpCodeSnifferBeautifierBinPathExists = await pathExists(phpCodeSnifferBeautifierBinaryPath);
+    const isAllPHPCSBinsExists = isPhpCodeSnifferBinPathExists && isPhpCodeSnifferBeautifierBinPathExists;
+
+    if (phpCodeSnifferComponent && isAllPHPCSBinsExists) {
+        if (!Array.isArray(phpCodeSnifferComponent.phpcs_settings)) {
+            hasChanges = true;
+            phpCodeSnifferComponent.phpcs_settings = [phpCodeSnifferComponent.phpcs_settings];
+        }
+
+        const phpCodeSnifferConfiguration = phpCodeSnifferComponent.phpcs_settings.find(
+            (phpcsSetting) => phpcsSetting.PhpCSConfiguration
+        );
+
+        if (phpCodeSnifferConfiguration) {
+            if (phpCodeSnifferConfiguration[toolPathKey] !== phpCodeSnifferBinaryFormattedPath) {
+                hasChanges = true;
+                phpCodeSnifferConfiguration[toolPathKey] = phpCodeSnifferBinaryFormattedPath;
+            }
+
+            if (phpCodeSnifferConfiguration[beautifierPathKey] !== phpCodeSnifferBeautifierBinaryFormattedPath) {
+                hasChanges = true;
+                phpCodeSnifferConfiguration[beautifierPathKey] = phpCodeSnifferBeautifierBinaryFormattedPath;
+            }
+        } else {
+            hasChanges = true;
+            phpCodeSnifferComponent.phpcs_settings.push(defaultPHPCSSetting);
+        }
+    } else if (isAllPHPCSBinsExists) {
+        hasChanges = true;
+        phpConfigs.push({
+            [nameKey]: PHP_CODE_SNIFFER_COMPONENT_NAME,
+            phpcs_settings: [
+                defaultPHPCSSetting
+            ]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPCodeSniffer;

package/lib/tasks/file-system/create-phpstorm-config/php-config/php-cs-fixer-config.js

@@ -0,0 +1,63 @@
+const path = require('path');
+const pathExists = require('../../../../util/path-exists');
+const { nameKey, toolPathKey, standardsKey } = require('../keys');
+const { formatPathForPHPStormConfig } = require('../xml-utils');
+
+const PHP_CS_FIXER_COMPONENT_NAME = 'PhpCSFixer';
+
+const phpCSFixerStandards = 'PSR1;PSR2;Symfony;DoctrineAnnotation;PHP70Migration;PHP71Migration';
+const phpCSFixerBinaryPath = path.join(process.cwd(), 'vendor', 'bin', 'php-cs-fixer');
+const phpCSFixerBinaryFormattedPath = formatPathForPHPStormConfig(phpCSFixerBinaryPath);
+
+const defaultPHPCSFixerSettings = {
+    PhpCSFixerConfiguration: {
+        [toolPathKey]: phpCSFixerBinaryFormattedPath,
+        [standardsKey]: phpCSFixerStandards
+    }
+};
+
+/**
+ * @param {Array} phpConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPCSFixer = async (phpConfigs) => {
+    let hasChanges = false;
+    const phpCSFixerComponent = phpConfigs.find(
+        (phpConfig) => phpConfig[nameKey] === PHP_CS_FIXER_COMPONENT_NAME
+    );
+
+    const isPhpCSFixerBinPathExists = await pathExists(phpCSFixerBinaryPath);
+
+    if (phpCSFixerComponent && isPhpCSFixerBinPathExists) {
+        if (!Array.isArray(phpCSFixerComponent.phpcsfixer_settings)) {
+            hasChanges = true;
+            phpCSFixerComponent.phpcsfixer_settings = [phpCSFixerComponent.phpcsfixer_settings];
+        }
+
+        const phpCSFixerConfiguration = phpCSFixerComponent.phpcsfixer_settings.find(
+            (phpcsfixerSetting) => phpcsfixerSetting.PhpCSFixerConfiguration
+        );
+
+        if (phpCSFixerConfiguration) {
+            if (phpCSFixerConfiguration[toolPathKey] !== phpCSFixerBinaryFormattedPath) {
+                hasChanges = true;
+                phpCSFixerConfiguration[toolPathKey] = phpCSFixerBinaryFormattedPath;
+            }
+        } else {
+            hasChanges = true;
+            phpCSFixerComponent.phpcsfixer_settings.push(defaultPHPCSFixerSettings);
+        }
+    } else if (isPhpCSFixerBinPathExists) {
+        hasChanges = true;
+        phpConfigs.push({
+            [nameKey]: PHP_CS_FIXER_COMPONENT_NAME,
+            phpcsfixer_settings: [
+                defaultPHPCSFixerSettings
+            ]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPCSFixer;

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;