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

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

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configBundleAnalyzer = configBundleAnalyzer;
+
+var _webpackBundleAnalyzer = require("webpack-bundle-analyzer");
+
+var _modeUtils = require("../common/modeUtils");
+
+/* eslint-disable no-use-before-define */
+function configBundleAnalyzer(options) {
+  const mode = (0, _modeUtils.getWebpackMode)(options);
+
+  if ((0, _modeUtils.isProductionMode)(mode) && options.bundleAnalyze) {
+    const bundleAnalyzerOptions = getBundleAnalyzerOptions(options);
+    return new _webpackBundleAnalyzer.BundleAnalyzerPlugin(bundleAnalyzerOptions);
+  }
+
+  return null;
+} // eslint-disable-next-line no-unused-vars
+
+
+function getBundleAnalyzerOptions(options) {
+  return {
+    analyzerMode: 'static',
+    // generateStatsFile: false,
+    openAnalyzer: false // statsOptions: {
+    //   source: false,
+    //   normal: true,
+    //   chunks: false,
+    //   chunkGroups: false,
+    //   module: false,
+    //   assets: true,
+    //   assetsSort: 'name'
+    // }
+
+  };
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configBundleIntegrityReport = configBundleIntegrityReport;
+
+var _modeUtils = require("../common/modeUtils");
+
+var _BundleIntegrityReport = require("../custom_plugins/BundleIntegrityReport");
+
+function configBundleIntegrityReport(options) {
+  const webpackMode = (0, _modeUtils.getWebpackMode)(options);
+  const isProduction = (0, _modeUtils.isProductionMode)(webpackMode);
+  const {
+    enable: statsEnable
+  } = options.stats;
+
+  if (isProduction && statsEnable) {
+    return new _BundleIntegrityReport.BundleIntegrityReport({
+      fileName: options.stats.fileName || 'bundle-report-integrity.json',
+      excludeKeysInReport: options.stats.excludeKeys || [],
+      options: {
+        preset: 'verbose',
+        ...options.stats.options,
+        assets: true,
+        chunks: true,
+        modules: true,
+        builtAt: true,
+        hash: true
+      }
+    });
+  }
+
+  return null;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configCSSMinifierPlugin = configCSSMinifierPlugin;
+
+var _cssMinimizerWebpackPlugin = _interopRequireDefault(require("css-minimizer-webpack-plugin"));
+
+var _modeUtils = require("../common/modeUtils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// import UglifyCSSPlugin from '../custom_plugins/UglifyCSSPlugin';
+// eslint-disable-next-line no-unused-vars
+function configCSSMinifierPlugin(options) {
+  const excludeList = options.optimization.cssExcludePath;
+
+  if ((0, _modeUtils.isNotProduction)(options)) {
+    return null;
+  } // return null;
+  // return new UglifyCSSPlugin();
+
+
+  return excludeList !== '' ? new _cssMinimizerWebpackPlugin.default({
+    exclude: excludeList
+  }) : new _cssMinimizerWebpackPlugin.default();
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configCdnChangePlugin = configCdnChangePlugin;
+
+var _modeUtils = require("../common/modeUtils");
+
+var _CdnChangePlugin = _interopRequireDefault(require("../custom_plugins/CdnChangePlugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configCdnChangePlugin(options) {
+  const {
+    cdnMapping,
+    mode
+  } = options;
+
+  if (!cdnMapping.isCdnEnabled || (0, _modeUtils.isDevelopmentMode)(mode)) {
+    return null;
+  }
+
+  return new _CdnChangePlugin.default({ ...cdnMapping,
+    createSeparateSMap: options.createSeparateSMap
+  });
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configCopyPublicFolders = configCopyPublicFolders;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _copyWebpackPlugin = _interopRequireDefault(require("copy-webpack-plugin"));
+
+var _fs = require("fs");
+
+var _updateArrayWithDefault = require("../utils/updateArrayWithDefault");
+
+var _constants = require("../../../constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const defaultPublicFolders = [{
+  // source must be relative path  not absolute path
+  source: 'public',
+  // target is the path that this copied file output path
+  target: 'public',
+  toType: 'dir'
+}];
+
+function folderPatterns(publicFolders) {
+  return publicFolders.map(conf => {
+    const publicFolderActualPath = (0, _constants.joinWithAppPath)(conf.source);
+
+    if (!conf.source || !conf.target || _path.default.isAbsolute(conf.source) || !(0, _fs.existsSync)(publicFolderActualPath)) {
+      return null;
+    }
+
+    return {
+      from: publicFolderActualPath,
+      to: conf.target,
+      toType: conf.toType || 'dir'
+    };
+  }).filter(Boolean);
+}
+
+function configCopyPublicFolders(options) {
+  let {
+    publicFolders
+  } = options;
+  publicFolders = (0, _updateArrayWithDefault.updateArrayWithDefault)(publicFolders, defaultPublicFolders);
+
+  if (publicFolders.length === 0) {
+    return null;
+  }
+
+  const patterns = folderPatterns(publicFolders);
+
+  if (patterns.length === 0) {
+    return null;
+  }
+
+  return new _copyWebpackPlugin.default({
+    patterns
+  });
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configCustomAttributesPlugin = configCustomAttributesPlugin;
+
+var _custom_attribute_plugin = require("../custom_plugins/custom_attribute_plugin");
+
+function configCustomAttributesPlugin(options) {
+  const {
+    customAttributes
+  } = options;
+
+  if (customAttributes.enable) {
+    return new _custom_attribute_plugin.CustomAttributesPlugin(customAttributes);
+  }
+
+  return null;
+}

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

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configCustomScriptLoadingStrategyPlugin = configCustomScriptLoadingStrategyPlugin;
+
+var _CustomScriptLoadingPlugin = require("../custom_plugins/CustomScriptLoadingPlugin");
+
+var _utils = require("../utils");
+
+const defaultScriptLoadingStrategy = 'defer';
+const allowedScriptLoadingStrategies = ['blocking', 'defer', 'async', 'module'];
+
+function isAllowedScriptLoadingStrategyUsed(scriptLoadingStategey) {
+  return allowedScriptLoadingStrategies.includes(scriptLoadingStategey);
+}
+
+function getScriptLoadingStrategyForStringType(scriptLoadingStategey) {
+  if (isAllowedScriptLoadingStrategyUsed(scriptLoadingStategey)) {
+    return scriptLoadingStategey;
+  }
+
+  return defaultScriptLoadingStrategy;
+}
+
+function getScriptLoadingStrategyForObject(scriptLoadingStategey) {
+  if (Object.keys(scriptLoadingStategey).length === 0) {
+    return defaultScriptLoadingStrategy;
+  }
+
+  const isAllowedScriptLoadingStrategy = Object.keys(scriptLoadingStategey).every(key => isAllowedScriptLoadingStrategyUsed(key));
+
+  if (isAllowedScriptLoadingStrategy) {
+    return Object.assign({}, scriptLoadingStategey);
+  }
+
+  console.warn('un supported script loading strategy used', scriptLoadingStategey);
+  return defaultScriptLoadingStrategy;
+}
+
+function getScriptLoadingStrategy(scriptLoadingStategey) {
+  if ((0, _utils.getTypeOf)(scriptLoadingStategey) === 'string') {
+    return {
+      [getScriptLoadingStrategyForStringType(scriptLoadingStategey)]: [/.*/]
+    };
+  }
+
+  if ((0, _utils.getTypeOf)(scriptLoadingStategey) === 'object') {
+    return getScriptLoadingStrategyForObject(scriptLoadingStategey);
+  }
+
+  return {
+    [defaultScriptLoadingStrategy]: [/.*/]
+  };
+}
+
+function configCustomScriptLoadingStrategyPlugin(options) {
+  const {
+    customScriptLoadingStrategey
+  } = options;
+
+  if (customScriptLoadingStrategey) {
+    const currentScriptLoadingStrategy = getScriptLoadingStrategy(customScriptLoadingStrategey.options);
+
+    if ((0, _utils.getTypeOf)(currentScriptLoadingStrategy) === 'object') {
+      return new _CustomScriptLoadingPlugin.CustomScriptLoadingStrategyPlugin({
+        scriptLoadingStategey: currentScriptLoadingStrategy
+      });
+    } else {
+      return null;
+    }
+  } else {
+    return null;
+  }
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configEFCTemplatePlugin = configEFCTemplatePlugin;
+
+var _nameTemplates = require("../common/nameTemplates");
+
+var _EFCTemplatePlugin = require("../custom_plugins/EFCTemplatePlugin");
+
+function configEFCTemplatePlugin(options) {
+  const {
+    publicPath
+  } = options;
+  const {
+    chunkSplitEnable
+  } = options.i18nChunkSplit;
+  const {
+    enableRTLSplit
+  } = options.css.plugins.rtlSplit;
+  const {
+    createSDkFile,
+    hasEFC,
+    entryPointName,
+    outputFile,
+    version,
+    templateFilePath
+  } = options.efc;
+
+  if (!hasEFC || !createSDkFile) {
+    return false;
+  }
+
+  const i18nFileNameTemplate = (0, _nameTemplates.nameTemplates)('i18njs', options);
+  return new _EFCTemplatePlugin.EFCTemplatePlugin({
+    entryPointName,
+    templateFilePath,
+    outputFile,
+    i18nFileNameTemplate,
+    version,
+    publicPath,
+    chunkSplitEnable,
+    enableRTLSplit
+  });
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configEnvVariables = configEnvVariables;
+
+var _webpack = require("webpack");
+
+var _modeUtils = require("../common/modeUtils");
+
+function getDevEnvs(NODE_ENV) {
+  return {
+    __CLIENT__: true,
+    __TEST__: false,
+    __SERVER__: false,
+    __DEVELOPMENT__: true,
+    __LOCAL_PRODUCTION__: false,
+    __DEVTOOLS__: true,
+    __DOCS__: false,
+    'process.env': {
+      NODE_ENV
+    }
+  };
+}
+
+function getProdEnvs(isDevelopment) {
+  return {
+    __CLIENT__: true,
+    __TEST__: false,
+    __SERVER__: false,
+    __DEVELOPMENT__: false,
+    __LOCAL_PRODUCTION__: isDevelopment,
+    __DOCS__: false,
+    'process.env': {
+      NODE_ENV: JSON.stringify('production')
+    }
+  };
+}
+
+function configEnvVariables(options) {
+  // const mode = getWebpackMode(options);
+  const {
+    disableReactDevWarning,
+    mode,
+    devLikeHash
+  } = options;
+  const isDevelopment = devLikeHash;
+  const NODE_ENV = disableReactDevWarning ? JSON.stringify('production') : JSON.stringify('development');
+  return new _webpack.DefinePlugin((0, _modeUtils.isDevelopmentMode)(mode) ? getDevEnvs(NODE_ENV) : getProdEnvs(isDevelopment));
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configHtmlWebpackPlugin = configHtmlWebpackPlugin;
+
+var _constants = require("../../../constants");
+
+var _nameTemplates = require("../common/nameTemplates");
+
+var _modeUtils = require("../common/modeUtils");
+
+var _InitialHtmlPlugin = require("../custom_plugins/InitialHtmlPlugin");
+
+function configHtmlWebpackPlugin(options) {
+  const {
+    htmlTemplate,
+    mode
+  } = options;
+  const {
+    inject,
+    templateFile
+  } = htmlTemplate;
+  const appInitialHTMLTemplatePath = (0, _constants.joinWithAppPath)(templateFile);
+  const minifyHtmlOptions = (0, _modeUtils.isProductionMode)(mode) ? // eslint-disable-next-line no-use-before-define
+  getHTMLMinifyOptions(htmlTemplate) : false;
+  return new _InitialHtmlPlugin.InitialHtmlPlugin({
+    mainChunkName: 'main',
+    filename: (0, _nameTemplates.nameTemplates)('html', options),
+    template: appInitialHTMLTemplatePath,
+    minify: minifyHtmlOptions,
+    inject,
+    scriptLoading: 'defer'
+  });
+}
+
+const defaultHTMLMiniFyOption = {
+  collapseWhitespace: true,
+  minifyCSS: true,
+  minifyJS: true,
+  keepClosingSlash: true,
+  removeComments: false,
+  removeRedundantAttributes: true,
+  removeScriptTypeAttributes: true,
+  removeStyleLinkTypeAttributes: true,
+  useShortDoctype: true
+};
+
+function getHTMLMinifyOptions(htmlTemplate) {
+  const {
+    minify
+  } = htmlTemplate;
+  const minifyHtmlOptions = minify === null ? false : minify;
+  return minifyHtmlOptions === true ? defaultHTMLMiniFyOption : minifyHtmlOptions;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configI18nSplitPlugin = configI18nSplitPlugin;
+
+var _nameTemplates = require("../common/nameTemplates");
+
+var _I18nSplitPlugin = _interopRequireDefault(require("../custom_plugins/I18nSplitPlugin"));
+
+var _resourceBasedPublicPath = require("../common/resourceBasedPublicPath");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configI18nSplitPlugin(options) {
+  const {
+    i18nChunkSplit
+  } = options;
+
+  if (!i18nChunkSplit.chunkSplitEnable) {
+    return null;
+  }
+
+  const i18nPublicPath = (0, _resourceBasedPublicPath.resourceBasedPublicPath)('i18n', options); // const i18nPublicPathAsExpression  = publicPathAsExpression('i18n', options);
+
+  return new _I18nSplitPlugin.default({
+    mainChunkName: 'main',
+    jsResource: i18nChunkSplit.jsResource,
+    localeVarName: i18nChunkSplit.localeVarName,
+    jsonpFunc: i18nChunkSplit.jsonpFunc,
+    templateLabel: i18nChunkSplit.templateLabel,
+    disableDefault: i18nChunkSplit.disableDefault,
+    filename: (0, _nameTemplates.nameTemplates)('i18njs', options),
+    chunkFilename: (0, _nameTemplates.nameTemplates)('i18nchunkjs', options),
+    publicPath: i18nPublicPath,
+    i18nManifestFileName: (0, _nameTemplates.nameTemplates)('i18nmanifest', options),
+    // template: (object, locale) => `window.loadI18n(${JSON.stringify(object)}, ${JSON.stringify(locale)})`,
+    propertiesFolder: i18nChunkSplit.propertiesFolder
+  });
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configIgnorePlugin = configIgnorePlugin;
+
+var _webpack = require("webpack");
+
+// eslint-disable-next-line no-unused-vars
+function configIgnorePlugin(options) {
+  return new _webpack.IgnorePlugin({
+    resourceRegExp: /^\.\/domain$/,
+    contextRegExp: /moment$/
+  });
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configManifestJsonPlugin = configManifestJsonPlugin;
+
+var _ManifestJsonPlugin = require("../custom_plugins/ManifestJsonPlugin");
+
+function configManifestJsonPlugin(options) {
+  const {
+    enable,
+    i18nManifestJson,
+    licenseManifest
+  } = options.manifestJson;
+
+  if (!enable) {
+    return null;
+  }
+
+  const params = [{
+    outputJsonFileName: 'manifest.json',
+    test: f => !/\.i18n\.js$|\.LICENSE\.txt$|\.map$/.test(f),
+    needInitialEntries: true
+  }];
+
+  if (i18nManifestJson) {
+    params.push({
+      outputJsonFileName: 'i18nManifest.json',
+      test: f => /\.i18n\.js$/g.test(f),
+      needInitialEntries: false
+    });
+  }
+
+  if (licenseManifest) {
+    params.push({
+      outputJsonFileName: 'licenseManifest.json',
+      test: f => /\.LICENSE\.txt$/g.test(f),
+      needInitialEntries: false
+    });
+  }
+
+  return new _ManifestJsonPlugin.AddFileToManifestJson(params);
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configMiniCSSExtractPlugin = configMiniCSSExtractPlugin;
+
+var _miniCssExtractPlugin = _interopRequireDefault(require("mini-css-extract-plugin"));
+
+var _nameTemplates = require("../common/nameTemplates");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configMiniCSSExtractPlugin(options) {
+  const {
+    enableRTLSplit
+  } = options.css.plugins.rtlSplit;
+  const cssLTRFileNameTempalte = enableRTLSplit ? (0, _nameTemplates.nameTemplates)('cssdir', options) : (0, _nameTemplates.nameTemplates)('css', options); // eslint-disable-next-line no-undef
+
+  return new _miniCssExtractPlugin.default({
+    filename: cssLTRFileNameTempalte,
+    chunkFilename: cssLTRFileNameTempalte
+  });
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configProgressPlugin = configProgressPlugin;
+
+var _webpack = _interopRequireDefault(require("webpack"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// eslint-disable-next-line no-unused-vars
+function configProgressPlugin(options) {
+  if (!options.printProgress) {
+    return null;
+  }
+
+  return new _webpack.default.ProgressPlugin({
+    handler: (percentage, message, ...args) => {
+      // eslint-disable-next-line no-console
+      console.info(percentage, message, ...args);
+    }
+  });
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configResourceHintsPlugin = configResourceHintsPlugin;
+
+var _ResourceHintsPlugin = _interopRequireDefault(require("../custom_plugins/ResourceHintsPlugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configResourceHintsPlugin(options) {
+  const {
+    publicPath,
+    resourceHints
+  } = options;
+  return new _ResourceHintsPlugin.default({
+    resourceHints,
+    publicPath: JSON.stringify(publicPath)
+  });
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configRtlCssPlugin = configRtlCssPlugin;
+
+var _RtlCssPlugin = require("../custom_plugins/RtlSplitPlugin/RtlCssPlugin");
+
+function configRtlCssPlugin(options) {
+  const {
+    enableRTLSplit,
+    templateLabel,
+    disableMinifySelector,
+    dirVarName
+  } = options.css.plugins.rtlSplit;
+
+  if (!enableRTLSplit) {
+    return null;
+  }
+
+  return new _RtlCssPlugin.RtlCssPlugin({
+    templateLabel,
+    disableMinifySelector,
+    dirVarName
+  });
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configRuntimeResourceCleanup = configRuntimeResourceCleanup;
+
+var _modeUtils = require("../common/modeUtils");
+
+var _RuntimeResourceCleanup = _interopRequireDefault(require("../custom_plugins/RuntimeResourceCleanup"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function configRuntimeResourceCleanup(options) {
+  const chunkLoadingGlobal = (0, _modeUtils.getGlobalCacheStorageName)(options);
+  const {
+    resourceCleanup: runtimeResourceCleanupEnabled,
+    hasEFC: efcEnabled
+  } = options.efc;
+  const {
+    customAttributes = {}
+  } = options;
+
+  if (efcEnabled && runtimeResourceCleanupEnabled) {
+    return new _RuntimeResourceCleanup.default({ ...customAttributes,
+      chunkLoadingGlobal
+    });
+  }
+
+  return null;
+}