@zohodesk/react-cli 1.1.27-exp.1 → 1.1.27-exp.2

package/packages/client_build_tool/lib/shared/bundler/webpack/pluginConfigs/configSelectorWeightPlugin.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configSelectorWeightPlugin = configSelectorWeightPlugin;
+
+var _SelectorWeightPlugin = _interopRequireDefault(require("../custom_plugins/SelectorWeightPlugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configSelectorWeightPlugin(options) {
+  const {
+    selectorWeight
+  } = options.css.plugins;
+
+  if (!selectorWeight.enable) {
+    return null;
+  }
+
+  return new _SelectorWeightPlugin.default({
+    selectorWeightConfig: selectorWeight.configFile,
+    defaultSelector: selectorWeight.defaultSelector,
+    customFileDetails: selectorWeight.customFileDetails,
+    excludeStrings: selectorWeight.excludeStrings,
+    patterns: selectorWeight.patterns
+  });
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/pluginConfigs/configServiceWorkerPlugin.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configServiceWorkerPlugin = configServiceWorkerPlugin;
+
+var _nameTemplates = require("../common/nameTemplates");
+
+var _ServiceWorkerPlugin = _interopRequireDefault(require("../custom_plugins/ServiceWorkerPlugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configServiceWorkerPlugin(options) {
+  const {
+    serviceWorker
+  } = options;
+  const {
+    publicPath
+  } = options;
+  const {
+    chunkSplitEnable
+  } = options.i18nChunkSplit;
+  const {
+    enableRTLSplit
+  } = options.css.plugins.rtlSplit;
+
+  if (!serviceWorker.enable) {
+    return null;
+  }
+
+  const i18nFileNameTemplate = (0, _nameTemplates.nameTemplates)('i18njs', options);
+  return new _ServiceWorkerPlugin.default({ ...serviceWorker,
+    publicPath,
+    i18nFileNameTemplate,
+    chunkSplitEnable,
+    enableRTLSplit,
+    entryPointName: 'main'
+  });
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/pluginConfigs/configSourceMapPlugin.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configSourceMapPlugin = configSourceMapPlugin;
+
+var _SourceMapPlugin = require("../custom_plugins/SourceMapPlugin");
+
+function configSourceMapPlugin(options) {
+  const {
+    createSeparateSMap
+  } = options;
+
+  if (createSeparateSMap === false) {
+    return null;
+  }
+
+  return new _SourceMapPlugin.SourceMapPlugin();
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/pluginConfigs/configTPHashMappingPlugin.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configTPHashMappingPlugin = configTPHashMappingPlugin;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _TPHashMappingPlugin = require("../custom_plugins/TPHashMappingPlugin");
+
+var _modeUtils = require("../common/modeUtils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configTPHashMappingPlugin(options) {
+  const {
+    fileHashMappingToVariable,
+    context,
+    mode
+  } = options;
+
+  if ((0, _modeUtils.isProductionMode)(mode) && fileHashMappingToVariable) {
+    return new _TPHashMappingPlugin.TPHashMappingPlugin({
+      fileMappings: fileHashMappingToVariable,
+      tpFolder: `${_path.default.join(process.cwd(), context)}`
+    });
+  }
+
+  ;
+  return null;
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/pluginConfigs/configVariableConversionPlugin.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configVariableConversionPlugin = configVariableConversionPlugin;
+
+var _VariableConversionCollector = _interopRequireDefault(require("../custom_plugins/VariableConversionCollector"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configVariableConversionPlugin(options) {
+  const {
+    cssVariableReplacement
+  } = options.css.plugins;
+
+  if (cssVariableReplacement.enable === false) {
+    return false;
+  }
+
+  return new _VariableConversionCollector.default({
+    configFile: cssVariableReplacement.configFile,
+    patterns: cssVariableReplacement.patterns
+  });
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/plugins.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.plugins = plugins;
+
+var _configHtmlWebpackPlugin = require("./pluginConfigs/configHtmlWebpackPlugin");
+
+var _configEnvVariables = require("./pluginConfigs/configEnvVariables");
+
+var _configI18nSplitPlugin = require("./pluginConfigs/configI18nSplitPlugin");
+
+var _configMiniCSSExtractPlugin = require("./pluginConfigs/configMiniCSSExtractPlugin");
+
+var _configRtlCssPlugin = require("./pluginConfigs/configRtlCssPlugin");
+
+var _configIgnorePlugin = require("./pluginConfigs/configIgnorePlugin");
+
+var _configCdnChangePlugin = require("./pluginConfigs/configCdnChangePlugin");
+
+var _configServiceWorkerPlugin = require("./pluginConfigs/configServiceWorkerPlugin");
+
+var _configProgressPlugin = require("./pluginConfigs/configProgressPlugin");
+
+var _configBundleAnalyzer = require("./pluginConfigs/configBundleAnalyzer");
+
+var _configSelectorWeightPlugin = require("./pluginConfigs/configSelectorWeightPlugin");
+
+var _configVariableConversionPlugin = require("./pluginConfigs/configVariableConversionPlugin");
+
+var _configEFCTemplatePlugin = require("./pluginConfigs/configEFCTemplatePlugin");
+
+var _configResourceHintsPlugin = require("./pluginConfigs/configResourceHintsPlugin");
+
+var _configManifestJsonPlugin = require("./pluginConfigs/configManifestJsonPlugin");
+
+var _configCopyPublicFolders = require("./pluginConfigs/configCopyPublicFolders");
+
+var _configSourceMapPlugin = require("./pluginConfigs/configSourceMapPlugin");
+
+var _configTPHashMappingPlugin = require("./pluginConfigs/configTPHashMappingPlugin");
+
+var _configCustomAttributesPlugin = require("./pluginConfigs/configCustomAttributesPlugin");
+
+var _configBundleIntegrityReport = require("./pluginConfigs/configBundleIntegrityReport");
+
+var _configRuntimeResourceCleanup = require("./pluginConfigs/configRuntimeResourceCleanup");
+
+var _configCustomScriptLoadingStrategyPlugin = require("./pluginConfigs/configCustomScriptLoadingStrategyPlugin");
+
+// import { IgnorePlugin } from 'webpack';
+function plugins(options) {
+  const {
+    webpackPlugins
+  } = options;
+  return [(0, _configEnvVariables.configEnvVariables)(options), (0, _configCustomAttributesPlugin.configCustomAttributesPlugin)(options), (0, _configTPHashMappingPlugin.configTPHashMappingPlugin)(options), (0, _configCopyPublicFolders.configCopyPublicFolders)(options), (0, _configIgnorePlugin.configIgnorePlugin)(options), (0, _configMiniCSSExtractPlugin.configMiniCSSExtractPlugin)(options), (0, _configSelectorWeightPlugin.configSelectorWeightPlugin)(options), (0, _configVariableConversionPlugin.configVariableConversionPlugin)(options), (0, _configI18nSplitPlugin.configI18nSplitPlugin)(options), (0, _configRtlCssPlugin.configRtlCssPlugin)(options), (0, _configHtmlWebpackPlugin.configHtmlWebpackPlugin)(options), (0, _configCustomScriptLoadingStrategyPlugin.configCustomScriptLoadingStrategyPlugin)(options), (0, _configCdnChangePlugin.configCdnChangePlugin)(options), (0, _configServiceWorkerPlugin.configServiceWorkerPlugin)(options), (0, _configEFCTemplatePlugin.configEFCTemplatePlugin)(options), (0, _configResourceHintsPlugin.configResourceHintsPlugin)(options), (0, _configBundleAnalyzer.configBundleAnalyzer)(options), (0, _configManifestJsonPlugin.configManifestJsonPlugin)(options), (0, _configSourceMapPlugin.configSourceMapPlugin)(options), (0, _configProgressPlugin.configProgressPlugin)(options), (0, _configBundleIntegrityReport.configBundleIntegrityReport)(options), (0, _configRuntimeResourceCleanup.configRuntimeResourceCleanup)(options), ...webpackPlugins].filter(Boolean);
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/resolvers.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loaderResolver = loaderResolver;
+exports.moduleResolver = moduleResolver;
+
+var _client_packages_group = require("@zohodesk/client_packages_group");
+
+var _constants = require("../../constants");
+
+var _libAlias = require("./common/libAlias");
+
+var _requireLocalOrGlobal = require("../../utils/requireLocalOrGlobal");
+
+var _logger = require("../../../logger");
+
+/* eslint-disable no-use-before-define */
+const defaultPackageGroupNpm = '@zohodesk/client_packages_group';
+
+function decideNodeModulesPath(moduleResolvePath) {
+  if (typeof moduleResolvePath === 'string' && moduleResolvePath) {
+    const resolverPkg = (0, _requireLocalOrGlobal.requireAllPossible)(moduleResolvePath);
+
+    if (resolverPkg.local) {
+      (0, _logger.verboseLogger)(`Local '${moduleResolvePath}' package taken as Module Resolver`);
+      return resolverPkg.local.nodeModulesPath;
+    }
+
+    if (resolverPkg.global) {
+      (0, _logger.messageLogger)(`Global '${moduleResolvePath}' package taken as Module Resolver`);
+      return resolverPkg.global.nodeModulesPath;
+    }
+
+    (0, _logger.errorLogger)(`
+        You have given 'resolve.moduleResolvePath' as "${moduleResolvePath}".
+        But it seems that file path have some problem;`);
+    process.exit(0);
+  }
+
+  const globalResolverPkg = (0, _requireLocalOrGlobal.requireGlobal)(defaultPackageGroupNpm);
+
+  if (globalResolverPkg) {
+    (0, _logger.messageLogger)(`Global '${defaultPackageGroupNpm}' package taken as Module Resolver`);
+    return globalResolverPkg.nodeModulesPath;
+  }
+
+  (0, _logger.verboseLogger)(`CBT default '${defaultPackageGroupNpm}' package taken as Module Resolver`);
+  return _client_packages_group.nodeModulesPath;
+}
+
+function moduleResolver(options) {
+  const {
+    preferLocalFirst,
+    alias,
+    defaultAlias,
+    moduleResolvePath
+  } = options.resolve;
+  const nodeModulesPath = decideNodeModulesPath(moduleResolvePath);
+  return {
+    modules: useAppNodeModulesAsPreferred(preferLocalFirst, [nodeModulesPath, _constants.cliNodeModulesPath].filter(Boolean)),
+    alias: { ...(defaultAlias ? _libAlias.libAlias : {}),
+      ...(alias || {})
+    },
+    extensions: ['.ts', '.js', '.json', '.tsx']
+  };
+}
+
+function loaderResolver(options) {
+  const {
+    preferLocalFirst
+  } = options.resolve;
+  return {
+    modules: useAppNodeModulesAsPreferred(preferLocalFirst, [_constants.cliNodeModulesPath])
+  };
+}
+
+function useAppNodeModulesAsPreferred(preferLocalFirst = false, paths = []) {
+  const filteredPaths = paths.filter(Boolean);
+  return preferLocalFirst ? ['node_modules', ...filteredPaths, _constants.appNodeModules] : [...filteredPaths, 'node_modules', _constants.appNodeModules];
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/splitChunksConfig.js

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.splitChunksConfig = splitChunksConfig;
+
+var _defaultVendorPatternList = require("./defaultVendorPatternList");
+
+var _getFilenameFromModule = require("./getFilenameFromModule");
+
+var _checkIsPatternsMatchFilename = require("./loaderConfigs/checkIsPatternsMatchFilename");
+
+function splitChunksConfig(options) {
+  const {
+    vendorPatterns,
+    customChunks,
+    customChunksBaseConfig
+  } = options;
+
+  const isVendor = function isVendor(webpackModule) {
+    const userRequest = (0, _getFilenameFromModule.getFilenameFromModule)(webpackModule);
+    const patterns = [..._defaultVendorPatternList.defaultVendorPatternList, ...vendorPatterns];
+    return (0, _checkIsPatternsMatchFilename.checkIsPatternsMatchFilename)(patterns, userRequest);
+  };
+
+  const isReact = webpackModule => {
+    const userRequest = (0, _getFilenameFromModule.getFilenameFromModule)(webpackModule);
+    return (0, _checkIsPatternsMatchFilename.checkIsPatternsMatchFilename)(_defaultVendorPatternList.reactBundleIncludeList, userRequest);
+  };
+
+  const defaultChunks = {
+    'react.vendor': {
+      name: 'react.vendor',
+      chunks: 'all',
+      minChunks: 1,
+      test: isReact,
+      enforce: true,
+      priority: 30
+    },
+    vendor: {
+      name: 'vendor',
+      chunks: 'all',
+      minChunks: 1,
+      test: isVendor,
+      priority: 20
+    }
+  };
+  const customChunksConfig = {};
+  customChunks.reverse().forEach((cacheGroupObj, index) => {
+    const cacheGroupName = cacheGroupObj.cacheGroupName || cacheGroupObj.name; // eslint-disable-next-line no-use-before-define
+
+    const obj = getCacheGroup(cacheGroupObj, index);
+    customChunksConfig[cacheGroupName] = obj;
+  });
+  const splitChunksConfig = {
+    minSize: 12000,
+    ...(customChunksBaseConfig || {}),
+    cacheGroups: {
+      default: false,
+      defaultVendors: false,
+      ...defaultChunks,
+      ...customChunksConfig
+    }
+  };
+  return splitChunksConfig;
+}
+
+function getCacheGroup(obj, index) {
+  let {
+    minChunks,
+    priority,
+    chunks = 'all'
+  } = obj;
+  const {
+    name,
+    patterns,
+    enforce,
+    minSize,
+    maxSize,
+    reuseExistingChunk,
+    automaticNameDelimiter
+  } = obj;
+  chunks = obj.chunks || 'all';
+  minChunks = obj.minChunks || 2;
+  priority = obj.priority || 10 * (index + 2);
+  const cacheGroup = {
+    name,
+    test: m => {
+      const userRequest = (0, _getFilenameFromModule.getFilenameFromModule)(m);
+      return userRequest && (0, _checkIsPatternsMatchFilename.checkIsPatternsMatchFilename)(patterns, userRequest);
+    },
+    chunks,
+    minChunks,
+    priority,
+    enforce
+  };
+
+  if (minSize !== undefined) {
+    cacheGroup.minSize = minSize;
+  }
+
+  if (maxSize !== undefined) {
+    cacheGroup.maxSize = maxSize;
+  }
+
+  if (reuseExistingChunk !== undefined) {
+    cacheGroup.reuseExistingChunk = reuseExistingChunk;
+  }
+
+  if (automaticNameDelimiter !== undefined) {
+    cacheGroup.automaticNameDelimiter = automaticNameDelimiter;
+  }
+
+  return cacheGroup;
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/statsConfig.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.statsConfig = statsConfig;
+
+// eslint-disable-next-line no-unused-vars
+function statsConfig(options) {
+  let {
+    statsLogConfig
+  } = options;
+  statsLogConfig = statsLogConfig || {};
+
+  if (typeof statsLogConfig === 'string') {
+    return statsLogConfig;
+  }
+
+  return {
+    preset: 'minimal',
+    warnings: false,
+    children: false,
+    colors: true,
+    errorDetails: true,
+    ...statsLogConfig // excludeAssets: /i18n/,
+    // excludeAssets: /./,
+    // warningsFilter: /\[mini-css-extract-plugin\]/
+
+  };
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/tsLoaders.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tsLoaders = tsLoaders;
+
+var _babelLoaderConfig = require("./loaderConfigs/babelLoaderConfig");
+
+function tsLoaders(options) {
+  return [{
+    test: /\.tsx$/,
+    exclude: /node_modules/,
+    use: [(0, _babelLoaderConfig.babelLoaderConfig)(options)] // include: path.join(appPath, folder)
+
+  }];
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/utils/__test__/getArrayWithDefaultWithCustomEqual.test.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _updateArrayWithDefault = require("../updateArrayWithDefault");
+
+describe('getArrayWithDefault with custom isEqual', () => {
+  const mapper = a => a === '...' ? a : {
+    subKey: a
+  };
+
+  const defaultValuesArray = ['a', 'b', 'c', 'd', 'e'].map(mapper);
+
+  const customIsEqual = (a, b) => a.subKey === b.subKey;
+
+  it('usual extra one option in the last', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['...', 'z'].map(mapper), defaultValuesArray, customIsEqual);
+    const expectedValue = ['a', 'b', 'c', 'd', 'e', 'z'].map(mapper);
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual extra 2 option in the last', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['...', 'z', 'y'].map(mapper), defaultValuesArray, customIsEqual);
+    const expectedValue = ['a', 'b', 'c', 'd', 'e', 'z', 'y'].map(mapper);
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual extra one option in the front', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['z', '...'].map(mapper), defaultValuesArray, customIsEqual);
+    const expectedValue = ['z', 'a', 'b', 'c', 'd', 'e'].map(mapper);
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual extra 2 option in the front', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['z', 'y', '...'].map(mapper), defaultValuesArray, customIsEqual);
+    const expectedValue = ['z', 'y', 'a', 'b', 'c', 'd', 'e'].map(mapper);
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual already given one option in the last', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['...', 'c'].map(mapper), defaultValuesArray, customIsEqual);
+    const expectedValue = ['a', 'b', 'd', 'e', 'c'].map(mapper);
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual already given 2 option in the last', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['...', 'd', 'b'].map(mapper), defaultValuesArray, customIsEqual);
+    const expectedValue = ['a', 'c', 'e', 'd', 'b'].map(mapper);
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual already given one option in the front', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['c', '...'].map(mapper), defaultValuesArray, customIsEqual);
+    const expectedValue = ['c', 'a', 'b', 'd', 'e'].map(mapper);
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual already given 2 option in the front', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['b', 'd', '...'].map(mapper), defaultValuesArray, customIsEqual);
+    const expectedValue = ['b', 'd', 'a', 'c', 'e'].map(mapper);
+    expect(values).toEqual(expectedValue);
+  });
+});

package/packages/client_build_tool/lib/shared/bundler/webpack/utils/__test__/updateArrayWithDefault.test.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _updateArrayWithDefault = require("../updateArrayWithDefault");
+
+describe('getArrayWithDefault', () => {
+  const defaultValuesArray = ['a', 'b', 'c', 'd', 'e'];
+  it('usual extra one option in the last', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['...', 'z'], defaultValuesArray);
+    const expectedValue = ['a', 'b', 'c', 'd', 'e', 'z'];
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual extra 2 option in the last', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['...', 'z', 'y'], defaultValuesArray);
+    const expectedValue = ['a', 'b', 'c', 'd', 'e', 'z', 'y'];
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual extra one option in the front', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['z', '...'], defaultValuesArray);
+    const expectedValue = ['z', 'a', 'b', 'c', 'd', 'e'];
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual extra 2 option in the front', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['z', 'y', '...'], defaultValuesArray);
+    const expectedValue = ['z', 'y', 'a', 'b', 'c', 'd', 'e'];
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual already given one option in the last', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['...', 'c'], defaultValuesArray);
+    const expectedValue = ['a', 'b', 'd', 'e', 'c'];
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual already given 2 option in the last', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['...', 'd', 'b'], defaultValuesArray);
+    const expectedValue = ['a', 'c', 'e', 'd', 'b'];
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual already given one option in the front', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['c', '...'], defaultValuesArray);
+    const expectedValue = ['c', 'a', 'b', 'd', 'e'];
+    expect(values).toEqual(expectedValue);
+  });
+  it('usual already given 2 option in the front', () => {
+    const values = (0, _updateArrayWithDefault.getArrayWithDefault)(['b', 'd', '...'], defaultValuesArray);
+    const expectedValue = ['b', 'd', 'a', 'c', 'e'];
+    expect(values).toEqual(expectedValue);
+  });
+});

package/packages/client_build_tool/lib/shared/bundler/webpack/utils/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTypeOf = getTypeOf;
+exports.isJsFile = exports.isDirRelatedCss = exports.isCssFile = exports.isCss = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const isCss = filename => _path.default.extname(filename) === '.css';
+
+exports.isCss = isCss;
+
+const isDirRelatedCss = filename => filename.includes('[dir]');
+
+exports.isDirRelatedCss = isDirRelatedCss;
+
+const isJsFile = file => /\.js$/.test(file);
+
+exports.isJsFile = isJsFile;
+
+const isCssFile = file => /\.css$/.test(file);
+
+exports.isCssFile = isCssFile;
+
+function getTypeOf(value) {
+  return Object.prototype.toString.call(value).split(/\s/)[1].replace(/\]/, '').toLowerCase();
+}

package/packages/client_build_tool/lib/shared/bundler/webpack/utils/object-manipulation.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertObjectToStringGen = convertObjectToStringGen;
+exports.removeKeysFromObject = removeKeysFromObject;
+
+/* eslint-disable no-restricted-syntax */
+function objectPathMatcher(currentKey, objHierarchy = [], keysToBeRemoved = []) {
+  const objPathKey = objHierarchy.length > 0 ? `${objHierarchy.join('.')}.${currentKey}` : currentKey;
+  return keysToBeRemoved.some(key => {
+    const isWildPath = /^\*/.test(key);
+
+    if (isWildPath) {
+      const newKey = key.replace(/\*\.?/, '');
+      return objPathKey.includes(newKey);
+    }
+
+    return key === objPathKey;
+  });
+}
+/*
+    1) *.keyTobeRemoved -> means match every object path, this key will be removed
+    2) keyToBeremoved -> means root object key
+    3) nestedPath.keyToBeRemoved -> means only that nested path key
+    4) don't need to account for array iteration, just object key path is enough in the key to be removed.
+*/
+
+
+function removeKeysFromObject(obj, keysToBeRemoved, prevKeys = []) {
+  if (Array.isArray(obj)) {
+    return obj.map(item => removeKeysFromObject(item, keysToBeRemoved, prevKeys));
+  }
+
+  if (obj && typeof obj === 'object') {
+    const filteredKeyObject = {};
+    const ObjectKeys = Object.keys(obj);
+
+    for (const objectKey of ObjectKeys) {
+      const isKeyToBeRemoved = objectPathMatcher(objectKey, prevKeys, keysToBeRemoved);
+
+      if (!isKeyToBeRemoved) {
+        filteredKeyObject[objectKey] = removeKeysFromObject(obj[objectKey], keysToBeRemoved, [...prevKeys, objectKey]);
+      }
+    }
+
+    return filteredKeyObject;
+  }
+
+  return obj;
+}
+
+function* convertObjectToStringGen(obj) {
+  if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean' || obj === null) {
+    yield JSON.stringify(obj);
+  } else if (Array.isArray(obj)) {
+    yield '[';
+    let isFirst = true;
+
+    for (let item of obj) {
+      if (item === undefined) {
+        item = null;
+      }
+
+      yield `${isFirst ? '' : ','}`;
+      yield* convertObjectToStringGen(item);
+      isFirst = false;
+    }
+
+    yield ']';
+  } else {
+    yield '{';
+    let isFirst = true;
+    const entries = Object.entries(obj);
+
+    for (const [itemKey, itemValue] of entries) {
+      if (itemValue !== undefined) {
+        yield `${isFirst ? '' : ','}${JSON.stringify(itemKey)}: `;
+        yield* convertObjectToStringGen(itemValue);
+        isFirst = false;
+      }
+    }
+
+    yield '}';
+  }
+}