Add "include_node_modules" option to configureBabel

Author: Lyrkan

index.js

@@ -649,6 +649,12 @@ class Encore {
      *              A Webpack Condition passed to the JS/JSX rule that
      *              determines which files and folders should not be
      *              processed by Babel (https://webpack.js.org/configuration/module/#condition).
+     *              Cannot be used if the "include_node_modules" option is
+     *              also set.
+     *      * {string[]} include_node_modules
+     *              If set that option will include the given Node modules to
+     *              the files that are processed by Babel. Cannot be used if
+     *              the "exclude" option is also set.
      *
      * @param {function} callback
      * @param {object} encoreOptions

lib/WebpackConfig.js

@@ -80,7 +80,7 @@ class WebpackConfig {
             fonts: false
         };
         this.babelOptions = {
-            exclude: /(node_modules|bower_components)/,
+            exclude: /(node_modules|bower_components)/
         };
 
         // Features/Loaders options callbacks
@@ -316,11 +316,40 @@ class WebpackConfig {
         this.babelConfigurationCallback = callback;
 
         for (const optionKey of Object.keys(options)) {
-            if (!(optionKey in this.babelOptions)) {
+            if (optionKey === 'include_node_modules') {
+                if (Object.keys(options).includes('exclude')) {
+                    throw new Error('"include_node_modules" and "exclude" options can\'t be used together when calling configureBabel().');
+                }
+
+                if (!Array.isArray(options[optionKey])) {
+                    throw new Error('Option "include_node_modules" passed to configureBabel() must be an Array.');
+                }
+
+                this.babelOptions['exclude'] = (filePath) => {
+                    // Don't exclude modules outside of node_modules/bower_components
+                    if (!/(node_modules|bower_components)/.test(filePath)) {
+                        return false;
+                    }
+
+                    // Don't exclude whitelisted Node modules
+                    const whitelistedModules = options[optionKey].map(
+                        module => path.join('node_modules', module) + path.sep
+                    );
+
+                    for (const modulePath of whitelistedModules) {
+                        if (filePath.includes(modulePath)) {
+                            return false;
+                        }
+                    }
+
+                    // Exclude other modules
+                    return true;
+                };
+            } else if (!(optionKey in this.babelOptions)) {
                 throw new Error(`Invalid option "${optionKey}" passed to configureBabel(). Valid keys are ${Object.keys(this.babelOptions).join(', ')}`);
+            } else {
+                this.babelOptions[optionKey] = options[optionKey];
             }
-
-            this.babelOptions[optionKey] = options[optionKey];
         }
     }
 

test/WebpackConfig.js

@@ -410,6 +410,44 @@ describe('WebpackConfig object', () => {
             expect(String(config.babelOptions.exclude)).to.equal(String(/(node_modules|bower_components)/));
         });
 
+        it('Calling with "exclude" option', () => {
+            const config = createConfig();
+            config.configureBabel(() => {}, { exclude: 'foo' });
+
+            expect(config.babelOptions.exclude).to.equal('foo');
+        });
+
+        it('Calling with "include_node_modules" option', () => {
+            const config = createConfig();
+            config.configureBabel(() => {}, { include_node_modules: ['foo', 'bar'] });
+
+            expect(config.babelOptions.exclude).to.be.a('Function');
+
+            const includedPaths = [
+                path.join('test', 'lib', 'index.js'),
+                path.join('test', 'node_modules', 'foo', 'index.js'),
+                path.join('test', 'node_modules', 'foo', 'lib', 'index.js'),
+                path.join('test', 'node_modules', 'bar', 'lib', 'index.js'),
+                path.join('test', 'node_modules', 'baz', 'node_modules', 'foo', 'index.js'),
+            ];
+
+            const excludedPaths = [
+                path.join('test', 'bower_components', 'foo', 'index.js'),
+                path.join('test', 'bower_components', 'bar', 'index.js'),
+                path.join('test', 'bower_components', 'baz', 'index.js'),
+                path.join('test', 'node_modules', 'baz', 'lib', 'index.js'),
+                path.join('test', 'node_modules', 'baz', 'lib', 'foo', 'index.js')
+            ];
+
+            for (const filePath of includedPaths) {
+                expect(config.babelOptions.exclude(filePath)).to.equal(false);
+            }
+
+            for (const filePath of excludedPaths) {
+                expect(config.babelOptions.exclude(filePath)).to.equal(true);
+            }
+        });
+
         it('Calling with non-callback throws an error', () => {
             const config = createConfig();
 
@@ -427,19 +465,28 @@ describe('WebpackConfig object', () => {
             }).to.throw('configureBabel() cannot be called because your app already has Babel configuration');
         });
 
-        it('Pass valid config', () => {
+        it('Pass invalid config', () => {
             const config = createConfig();
-            config.configureBabel(() => {}, { exclude: 'foo' });
 
-            expect(config.babelOptions.exclude).to.equal('foo');
+            expect(() => {
+                config.configureBabel(() => {}, { fake_option: 'foo' });
+            }).to.throw('Invalid option "fake_option" passed to configureBabel()');
         });
 
-        it('Pass invalid config', () => {
+        it('Calling with both "include_node_modules" and "exclude" options', () => {
             const config = createConfig();
 
             expect(() => {
-                config.configureBabel(() => {}, { fake_option: 'foo' });
-            }).to.throw('Invalid option "fake_option" passed to configureBabel()');
+                config.configureBabel(() => {}, { exclude: 'foo', include_node_modules: ['bar', 'baz'] });
+            }).to.throw('can\'t be used together');
+        });
+
+        it('Calling with an invalid "include_node_modules" option value', () => {
+            const config = createConfig();
+
+            expect(() => {
+                config.configureBabel(() => {}, { include_node_modules: 'foo' });
+            }).to.throw('must be an Array');
         });
     });