@scandipwa/magento-scripts 1.16.0 → 2.0.0-alpha.1

package/lib/tasks/file-system/create-nginx-config.js

@@ -1,4 +1,3 @@
-const os = require('os');
 const path = require('path');
 const setConfigFile = require('../../util/set-config');
 const UnknownError = require('../../errors/unknown-error');
@@ -24,7 +23,7 @@ const createNginxConfig = () => ({
             }
         } = overridenConfiguration;
 
-        const isLinux = os.platform() === 'linux';
+        const isLinux = ctx.platform === 'linux';
         const isNativeLinux = isLinux && !isWsl;
         const hostMachine = isNativeLinux ? '127.0.0.1' : 'host.docker.internal';
         const hostPort = isNativeLinux ? ports.app : 80;
@@ -41,7 +40,7 @@ const createNginxConfig = () => ({
                 overwrite: true,
                 templateArgs: {
                     ports,
-                    mageRoot: baseConfig.magentoDir,
+                    mageRoot: baseConfig.containerMagentoDir,
                     hostMachine,
                     hostPort,
                     config: overridenConfiguration

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

@@ -1,24 +1,39 @@
 const semver = require('semver');
 const UnknownError = require('../../errors/unknown-error');
 const setConfigFile = require('../../util/set-config');
+const { getEnabledExtensionsFromImage } = require('../docker/project-image-builder');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const createPhpConfig = () => ({
     title: 'Setting PHP config',
-    task: async ({ config: { php, baseConfig, overridenConfiguration: { configuration } }, debug, ports }) => {
-        const isXDebug2 = semver.satisfies(configuration.php.extensions.xdebug.version, '2');
+    task: async (ctx) => {
+        const {
+            config: {
+                php,
+                baseConfig
+            },
+            debug
+        } = ctx;
+        const containers = ctx.config.docker.getContainers(ctx.ports);
+        const phpExtensions = await getEnabledExtensionsFromImage(containers.php.debugImage);
+        const isXDebug2 = semver.satisfies(phpExtensions.xdebug, '2');
+
+        const isLinux = ctx.platform === 'linux';
+        const isNativeLinux = isLinux && !ctx.isWsl;
+        const hostMachine = isNativeLinux ? '127.0.0.1' : 'host.docker.internal';
+
         try {
             await setConfigFile({
                 configPathname: php.iniPath,
                 template: php.iniTemplatePath,
                 overwrite: true,
                 templateArgs: {
-                    ports,
                     debug,
-                    mageRoot: baseConfig.magentoDir,
-                    isXDebug2
+                    mageRoot: baseConfig.containerMagentoDir,
+                    isXDebug2,
+                    hostMachine
                 }
             });
         } catch (e) {

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

@@ -1,4 +1,3 @@
-const path = require('path');
 const UnknownError = require('../../errors/unknown-error');
 const setConfigFile = require('../../util/set-config');
 
@@ -7,14 +6,19 @@ const setConfigFile = require('../../util/set-config');
  */
 const createPhpFpmConfig = () => ({
     title: 'Setting php-fpm config',
-    task: async ({ ports, config: { php, baseConfig } }) => {
+    task: async (ctx) => {
+        const { config: { php } } = ctx;
+        const isLinux = ctx.platform === 'linux';
+        const isNativeLinux = isLinux && !ctx.isWsl;
+        const port = isNativeLinux ? ctx.ports.fpm : 9000;
+
         try {
             await setConfigFile({
                 configPathname: php.fpmConfPath,
-                template: path.join(baseConfig.templateDir, 'php-fpm.template.conf'),
+                template: php.fpmTemplatePath,
                 overwrite: true,
                 templateArgs: {
-                    ports
+                    port
                 }
             });
         } catch (e) {

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

@@ -1,17 +1,26 @@
 const path = require('path');
 const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
 const pathExists = require('../../../util/path-exists');
+const {
+    urlKey, typeKey, versionKey, nameKey
+} = require('./keys');
 const { formatPathForPHPStormConfig } = require('./xml-utils');
 
 const pathToModulesConfig = path.join(process.cwd(), '.idea', 'modules.xml');
 const excludeFoldersPaths = [
     'bin',
     'dev',
-    'pub',
-    'setup',
+    'pub/static',
     'var/cache',
     'var/page_cache',
-    'var/log'
+    'var/log',
+    'var/composer_home',
+    'var/view_preprocessed'
+].map((p) => `file://$MODULE_DIR$/${p}`);
+
+const mustBeIncludedPaths = [
+    'pub',
+    'setup'
 ].map((p) => `file://$MODULE_DIR$/${p}`);
 
 /**
@@ -24,26 +33,23 @@ const getProjectConfigFilePath = async () => {
     return modulesConfigData.project.component.modules.module['@_filepath'].replace('$PROJECT_DIR$', process.cwd());
 };
 
-/**
- * @returns {Array<{'@_url': string}>}
- */
-const getExcludedFoldersConfig = (projectConfigData) => {
+const setupDefaultsForExcludedFoldersConfig = (projectConfigData) => {
     if (!projectConfigData.module) {
         projectConfigData.module = {
-            '@_type': 'WEB_MODULE',
-            '@_version': '4'
+            [typeKey]: 'WEB_MODULE',
+            [versionKey]: '4'
         };
     }
 
     if (!projectConfigData.module.component) {
         projectConfigData.module.component = {
-            '@_name': 'NewModuleRootManager',
+            [nameKey]: 'NewModuleRootManager',
             orderEntry: [
                 {
-                    '@_type': 'inheritedJdk'
+                    [typeKey]: 'inheritedJdk'
                 },
                 {
-                    '@_type': 'sourceFolder',
+                    [typeKey]: 'sourceFolder',
                     '@_forTest': 'false'
                 }
             ]
@@ -52,37 +58,42 @@ const getExcludedFoldersConfig = (projectConfigData) => {
 
     if (!projectConfigData.module.component.content) {
         projectConfigData.module.component.content = {
-            '@_url': 'file://$MODULE_DIR$'
+            [urlKey]: 'file://$MODULE_DIR$'
         };
     }
 
     if (!projectConfigData.module.component.content.excludeFolder) {
         projectConfigData.module.component.content.excludeFolder = [];
     }
-
-    return projectConfigData
-        .module.component.content.excludeFolder;
 };
 
-const setupExcludedFolders = (excludedFoldersConfig) => {
+const setupExcludedFolders = (projectConfigData) => {
+    const { excludeFolder } = projectConfigData.module.component.content;
     let hasChanges = false;
     // filter excluded folders to get ones that needs to be added to excluded folders list
     const missingExcludedFolders = excludeFoldersPaths
         .filter(
-            (excludeFoldersPath) => !excludedFoldersConfig.some(
-                (config) => config['@_url'] === excludeFoldersPath
+            (excludeFoldersPath) => !excludeFolder.some(
+                (config) => config[urlKey] === excludeFoldersPath
             )
         );
 
     if (missingExcludedFolders.length > 0) {
         hasChanges = true;
         missingExcludedFolders.forEach((missingExcludedFolder) => {
-            excludedFoldersConfig.unshift({
-                '@_url': missingExcludedFolder
+            projectConfigData.module.component.content.excludeFolder.unshift({
+                [urlKey]: missingExcludedFolder
             });
         });
     }
 
+    const hasSomePathsThatMustBeFiltered = excludeFolder.some((config) => mustBeIncludedPaths.includes(config[urlKey]));
+
+    if (hasSomePathsThatMustBeFiltered) {
+        projectConfigData.module.component.content.excludeFolder = excludeFolder.filter((config) => !mustBeIncludedPaths.includes(config[urlKey]));
+        hasChanges = true;
+    }
+
     return hasChanges;
 };
 
@@ -94,13 +105,13 @@ const getIMLFilePath = async () => {
 
         const modulesConfig = {
             '?xml': {
-                '@_version': '1.0',
+                [versionKey]: '1.0',
                 '@_encoding': 'UTF-8'
             },
             project: {
-                '@_version': '4',
+                [versionKey]: '4',
                 component: {
-                    '@_name': 'ProjectModuleManager',
+                    [nameKey]: 'ProjectModuleManager',
                     modules: [
                         {
                             module: {
@@ -129,8 +140,8 @@ const setupExcludedFoldersConfig = () => ({
             const projectFilePath = await getProjectConfigFilePath();
             if (await pathExists(projectFilePath)) {
                 const projectConfigData = await loadXmlFile(projectFilePath);
-                const excludedFoldersConfig = getExcludedFoldersConfig(projectConfigData);
-                const hasChanges = setupExcludedFolders(excludedFoldersConfig);
+                setupDefaultsForExcludedFoldersConfig(projectConfigData);
+                const hasChanges = setupExcludedFolders(projectConfigData);
                 if (hasChanges) {
                     await buildXmlFile(projectFilePath, projectConfigData);
                 } else {
@@ -144,12 +155,13 @@ const setupExcludedFoldersConfig = () => ({
         const projectFilePath = await getIMLFilePath();
         const projectConfigData = {
             '?xml': {
-                '@_version': '1.0',
+                [versionKey]: '1.0',
                 '@_encoding': 'UTF-8'
             }
         };
-        const excludedFoldersConfig = getExcludedFoldersConfig(projectConfigData);
-        setupExcludedFolders(excludedFoldersConfig);
+
+        setupDefaultsForExcludedFoldersConfig(projectConfigData);
+        setupExcludedFolders(projectConfigData);
 
         await buildXmlFile(projectFilePath, projectConfigData);
     }

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

@@ -5,6 +5,7 @@ const setupInspectionToolsConfig = require('./inspection-tools-config');
 const setupExcludedFoldersConfig = require('./exclude-folder-config');
 const setupStylelintConfig = require('./stylelint-config');
 const setupESLintConfig = require('./eslint-config');
+const setupPhpDockerSettingsConfig = require('./php-docker-settings-config');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
@@ -14,6 +15,7 @@ const createPhpStormConfig = () => ({
     task: (ctx, task) => task.newListr([
         setupWorkspaceConfig(),
         setupPhpConfig(),
+        setupPhpDockerSettingsConfig(),
         setupDatabaseConfig(),
         setupInspectionToolsConfig(),
         setupExcludedFoldersConfig(),

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

@@ -4,11 +4,25 @@ const nameKey = '@_name';
 const valueKey = '@_value';
 const toolPathKey = '@_tool_path';
 const standardsKey = '@_standards';
+const urlKey = '@_url';
+const typeKey = '@_type';
+const versionKey = '@_version';
+
+/**
+ * Makes a xml property key
+ * @param {string} key
+ * @returns {string}
+ */
+const propertyKey = (key) => `@_${key}`;
 
 module.exports = {
     classKey,
     nameKey,
     valueKey,
     toolPathKey,
-    standardsKey
+    standardsKey,
+    urlKey,
+    typeKey,
+    versionKey,
+    propertyKey
 };

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

@@ -5,6 +5,7 @@ const setupMessDetector = require('./mess-detector-config');
 const setupPHPCodeSniffer = require('./php-code-sniffer-config');
 const { getPhpConfig } = require('./php-config');
 const setupPHPCSFixer = require('./php-cs-fixer-config');
+const setupPHPInterpreters = require('./php-interpreters-config');
 const setupPHPProjectSharedConfiguration = require('./php-project-shared-configuration-config');
 
 /**
@@ -13,7 +14,7 @@ const setupPHPProjectSharedConfiguration = require('./php-project-shared-configu
 const setupPhpConfig = () => ({
     title: 'Set up PHP configuration',
     task: async (ctx, task) => {
-        const phpConfig = getPhpConfig(ctx.config.overridenConfiguration);
+        const phpConfig = getPhpConfig(ctx);
 
         if (await pathExists(phpConfig.path)) {
             const phpConfigContent = setupXMLStructure(await loadXmlFile(phpConfig.path));
@@ -22,6 +23,7 @@ const setupPhpConfig = () => ({
                 setupMessDetector(phpConfigs),
                 setupPHPCodeSniffer(phpConfigs),
                 setupPHPCSFixer(phpConfigs),
+                setupPHPInterpreters(phpConfigs, ctx),
                 setupPHPProjectSharedConfiguration(phpConfigs, phpConfig.phpLanguageLevel)
             ]);
 
@@ -41,6 +43,7 @@ const setupPhpConfig = () => ({
             setupMessDetector(phpConfigs),
             setupPHPCodeSniffer(phpConfigs),
             setupPHPCSFixer(phpConfigs),
+            setupPHPInterpreters(phpConfigs, ctx),
             setupPHPProjectSharedConfiguration(phpConfigs, phpConfig.phpLanguageLevel)
         ]);
 

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

@@ -2,10 +2,10 @@ const path = require('path');
 const { baseConfig } = require('../../../../config');
 
 /**
- * @param {import('../../../../../typings/index').CMAConfiguration} app
+ * @param {import('../../../../../typings/context').ListrContext} ctx
  */
-const getPhpConfig = (app) => {
-    const [majorPHPVersion, minorPHPVersion] = app.configuration.php.version.split('.');
+const getPhpConfig = (ctx) => {
+    const [majorPHPVersion, minorPHPVersion] = ctx.phpVersion.split('.');
     const phpLanguageLevel = `${ majorPHPVersion }.${ minorPHPVersion }`;
 
     return {

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

@@ -0,0 +1,81 @@
+const { nameKey, propertyKey } = require('../keys');
+
+const PHP_INTERPRETERS_COMPONENT_NAME = 'PhpInterpreters';
+
+/**
+ * @param {Array} phpConfigs
+ * @param {import('../../../../../typings/context').ListrContext} ctx
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPInterpreters = async (phpConfigs, ctx) => {
+    let hasChanges = false;
+    const phpInterpretersComponent = phpConfigs.find(
+        (phpConfig) => phpConfig[nameKey] === PHP_INTERPRETERS_COMPONENT_NAME
+    );
+
+    const { php } = ctx.config.docker.getContainers(ctx.ports);
+    const currentInterpreterImage = ctx.debug ? php.debugImage : php.image;
+
+    const defaultPhpInterpreterConfiguration = {
+        [nameKey]: currentInterpreterImage,
+        [propertyKey('id')]: '2fbe75d5-bc8f-4adb-8e62-ddb0ccee6428',
+        [propertyKey('home')]: 'docker://DATA',
+        [propertyKey('debugger_id')]: 'php.debugger.XDebug',
+        remote_data: {
+            [propertyKey('INTERPRETER_PATH')]: 'php',
+            [propertyKey('HELPERS_PATH')]: '/opt/.phpstorm_helpers',
+            [propertyKey('VALID')]: 'true',
+            [propertyKey('RUN_AS_ROOT_VIA_SUDO')]: 'false',
+            [propertyKey('DOCKER_ACCOUNT_NAME')]: 'Docker',
+            [propertyKey('DOCKER_IMAGE_NAME')]: currentInterpreterImage,
+            [propertyKey('DOCKER_REMOTE_PROJECT_PATH')]: ctx.config.baseConfig.containerMagentoDir
+        }
+    };
+
+    if (phpInterpretersComponent) {
+        if (!phpInterpretersComponent.interpreters) {
+            hasChanges = true;
+            phpInterpretersComponent.interpreters = {};
+        }
+
+        if (!Array.isArray(phpInterpretersComponent.interpreters.interpreter)) {
+            hasChanges = true;
+            phpInterpretersComponent.interpreters.interpreter = [phpInterpretersComponent.interpreters.interpreter];
+        }
+
+        const phpInterpreterConfiguration = phpInterpretersComponent.interpreters.interpreter.find(
+            (interpreter) => interpreter[nameKey] === php.image || interpreter[nameKey] === php.debugImage
+        );
+
+        if (!phpInterpreterConfiguration) {
+            hasChanges = true;
+            phpInterpretersComponent.interpreters.interpreter.push(defaultPhpInterpreterConfiguration);
+        } else {
+            if (phpInterpreterConfiguration[nameKey] !== currentInterpreterImage) {
+                hasChanges = true;
+                phpInterpreterConfiguration[nameKey] = currentInterpreterImage;
+            }
+            if (phpInterpreterConfiguration.remote_data[propertyKey('DOCKER_IMAGE_NAME')] !== currentInterpreterImage) {
+                hasChanges = true;
+                phpInterpreterConfiguration.remote_data[propertyKey('DOCKER_IMAGE_NAME')] = currentInterpreterImage;
+            }
+
+            if (phpInterpreterConfiguration.remote_data[propertyKey('DOCKER_REMOTE_PROJECT_PATH')] !== ctx.config.baseConfig.containerMagentoDir) {
+                hasChanges = true;
+                phpInterpreterConfiguration.remote_data[propertyKey('DOCKER_REMOTE_PROJECT_PATH')] = ctx.config.baseConfig.containerMagentoDir;
+            }
+        }
+    } else {
+        hasChanges = true;
+        phpConfigs.push({
+            [nameKey]: PHP_INTERPRETERS_COMPONENT_NAME,
+            interpreters: {
+                interpreter: defaultPhpInterpreterConfiguration
+            }
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPInterpreters;

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

@@ -0,0 +1,42 @@
+const { loadXmlFile, buildXmlFile } = require('../../../../config/xml-parser');
+const pathExists = require('../../../../util/path-exists');
+const { setupXMLStructure } = require('../setup-xml-structure');
+const { getPhpDockerSettingsConfig } = require('./php-docker-settings-config');
+const setupPHPDockerContainerSettingsConfig = require('./setup-php-docker-container-settings-config');
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext>}
+ */
+const setupPhpDockerSettingsConfig = () => ({
+    title: 'Set up PHP Docker Settings configuration',
+    task: async (ctx, task) => {
+        const phpDockerSettingsConfig = getPhpDockerSettingsConfig();
+
+        if (await pathExists(phpDockerSettingsConfig.path)) {
+            const phpDockerSettingsConfigContent = setupXMLStructure(await loadXmlFile(phpDockerSettingsConfig.path));
+            const phpDockerSettingsConfigs = phpDockerSettingsConfigContent.project.component;
+            const hasChanges = await Promise.all([
+                setupPHPDockerContainerSettingsConfig(phpDockerSettingsConfigs, ctx)
+            ]);
+
+            if (hasChanges.includes(true)) {
+                await buildXmlFile(phpDockerSettingsConfig.path, phpDockerSettingsConfigContent);
+            } else {
+                task.skip();
+            }
+
+            return;
+        }
+
+        const phpDockerSettingsConfigContent = setupXMLStructure({});
+        const phpDockerSettingsConfigs = phpDockerSettingsConfigContent.project.component;
+
+        await Promise.all([
+            setupPHPDockerContainerSettingsConfig(phpDockerSettingsConfigs, ctx)
+        ]);
+
+        await buildXmlFile(phpDockerSettingsConfig.path, phpDockerSettingsConfigContent);
+    }
+});
+
+module.exports = setupPhpDockerSettingsConfig;

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

@@ -0,0 +1,9 @@
+const path = require('path');
+
+const getPhpDockerSettingsConfig = () => ({
+    path: path.join(process.cwd(), '.idea', 'php-docker-settings.xml')
+});
+
+module.exports = {
+    getPhpDockerSettingsConfig
+};

package/lib/tasks/file-system/create-phpstorm-config/php-docker-settings-config/setup-php-docker-container-settings-config.js

@@ -0,0 +1,66 @@
+const { propertyKey } = require('../keys');
+
+const PHP_DOCKER_CONTAINER_SETTINGS_COMPONENT_NAME = 'PhpDockerContainerSettings';
+
+/**
+ * @param {Array} phpDockerSettingsConfigs
+ * @param {import('../../../../../typings/context').ListrContext} ctx
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPDockerContainerSettingsConfig = async (phpDockerSettingsConfigs, ctx) => {
+    let hasChanges = false;
+    const phpDockerContainerSettingsComponent = phpDockerSettingsConfigs.find(
+        (phpDockerSettingsConfig) => phpDockerSettingsConfig[propertyKey('name')] === PHP_DOCKER_CONTAINER_SETTINGS_COMPONENT_NAME
+    );
+
+    const defaultList = {
+        map: {
+            entry: {
+                [propertyKey('key')]: '2fbe75d5-bc8f-4adb-8e62-ddb0ccee6428',
+                value: {
+                    DockerContainerSettings: {
+                        option: [
+                            {
+                                [propertyKey('name')]: 'runCliOptions',
+                                [propertyKey('value')]: ''
+                            },
+                            {
+                                [propertyKey('name')]: 'version',
+                                [propertyKey('value')]: '1'
+                            },
+                            {
+                                [propertyKey('name')]: 'volumeBindings',
+                                list: {
+                                    DockerVolumeBindingImpl: {
+                                        option: [
+                                            {
+                                                [propertyKey('name')]: 'containerPath',
+                                                [propertyKey('value')]: ctx.config.baseConfig.containerMagentoDir
+                                            },
+                                            {
+                                                [propertyKey('name')]: 'hostPath',
+                                                [propertyKey('value')]: '$PROJECT_DIR$'
+                                            }
+                                        ]
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                }
+            }
+        }
+    };
+
+    if (!phpDockerContainerSettingsComponent) {
+        hasChanges = true;
+        phpDockerSettingsConfigs.push({
+            [propertyKey('name')]: PHP_DOCKER_CONTAINER_SETTINGS_COMPONENT_NAME,
+            list: defaultList
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPDockerContainerSettingsConfig;

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

@@ -1,29 +1,31 @@
-const xmlConfiguration = {
+const { propertyKey } = require('./keys');
+
+const xmlConfiguration = () => ({
     '?xml': {
-        '@_version': '1.0',
-        '@_encoding': 'UTF-8'
+        [propertyKey('version')]: '1.0',
+        [propertyKey('encoding')]: 'UTF-8'
     },
     project: {
-        '@_version': '4',
+        [propertyKey('version')]: '4',
         component: []
     }
-};
+});
 
 const setupXMLStructure = (data) => {
     if (!data) {
-        data = xmlConfiguration;
+        data = xmlConfiguration();
     }
 
     if (data['?xml'] === undefined) {
-        data['?xml'] = xmlConfiguration['?xml'];
+        data['?xml'] = xmlConfiguration()['?xml'];
     }
 
     if (data.project === undefined) {
-        data.project = xmlConfiguration.project;
+        data.project = xmlConfiguration().project;
     }
 
     if (data.project.component === undefined) {
-        data.project.component = xmlConfiguration.project.component;
+        data.project.component = [];
     }
 
     if (!Array.isArray(data.project.component) && Boolean(data.project.component)) {

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

@@ -3,6 +3,7 @@ const fs = require('fs');
 const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
 const pathExists = require('../../../util/path-exists');
 const { valueKey, nameKey } = require('./keys');
+const { setupXMLStructure } = require('./setup-xml-structure');
 
 const STYLELINT_CONFIGURATION_COMPONENT_NAME = 'StylelintConfiguration';
 
@@ -26,7 +27,7 @@ const setupStylelintConfig = () => ({
     task: async (ctx, task) => {
         if (await pathExists(pathToStylelintConfig)) {
             let hasChanges = false;
-            const styleLintConfigurationData = await loadXmlFile(pathToStylelintConfig);
+            const styleLintConfigurationData = setupXMLStructure(await loadXmlFile(pathToStylelintConfig));
 
             if (styleLintConfigurationData.project.component && !Array.isArray(styleLintConfigurationData.project.component)) {
                 hasChanges = true;