@zohodesk/client_build_tool 0.0.1-0.exp.0.0.3

package/lib/shared/bundler/webpack/loaders/i18nIdReplaceLoader.js

@@ -0,0 +1,201 @@
+"use strict";
+
+const fs = require('fs');
+
+const path = require('path');
+
+const parser = require('@babel/parser');
+
+const generator = require('@babel/generator').default;
+
+const {
+  walk
+} = require('estree-walker');
+
+const {
+  getOptions
+} = require('loader-utils');
+
+let collectAndCategorizeUsedI18nKeys, generateShortHash;
+
+try {
+  collectAndCategorizeUsedI18nKeys = require('../custom_plugins/I18nSplitPlugin/utils/collectAstKeys').collectAndCategorizeUsedI18nKeys;
+  generateShortHash = require('../common/hashUtils').generateShortHash;
+} catch (e) {
+  collectAndCategorizeUsedI18nKeys = () => ({
+    literalKeys: new Set(),
+    commentKeys: new Set()
+  });
+
+  generateShortHash = key => key;
+}
+
+const LOADER_PREFIX = '[i18nIdReplaceLoader]';
+let numericIdMapDataCache = null;
+let mapLoadAttemptedForPath = {};
+
+function loadNumericIdMap(loaderContext, mapPath) {
+  if (!mapPath) {
+    loaderContext.emitWarning(new Error(`${LOADER_PREFIX} Numeric map path not provided in loader options.`));
+    return null;
+  }
+
+  if (numericIdMapDataCache && mapLoadAttemptedForPath[mapPath]) {
+    return numericIdMapDataCache;
+  }
+
+  mapLoadAttemptedForPath[mapPath] = true;
+
+  try {
+    if (fs.existsSync(mapPath)) {
+      const fileContent = fs.readFileSync(mapPath, 'utf-8');
+      const parsedData = JSON.parse(fileContent);
+
+      if (parsedData && parsedData.originalKeyToNumericId && typeof parsedData.originalKeyToNumericId === 'object') {
+        numericIdMapDataCache = parsedData.originalKeyToNumericId;
+      } else {
+        loaderContext.emitError(new Error(`${LOADER_PREFIX} Pre-generated map file (${mapPath}) is invalid or does not contain 'originalKeyToNumericId'.`));
+        numericIdMapDataCache = null;
+      }
+    } else {
+      loaderContext.emitError(new Error(`${LOADER_PREFIX} Pre-generated i18n numeric map file NOT FOUND at: ${mapPath}.`));
+      numericIdMapDataCache = null;
+    }
+  } catch (err) {
+    loaderContext.emitError(new Error(`${LOADER_PREFIX} Error loading or parsing pre-generated i18n map from ${mapPath}: ${err.message}`));
+    numericIdMapDataCache = null;
+  }
+
+  return numericIdMapDataCache;
+}
+
+module.exports = function i18nIdReplaceLoader(source, map, meta) {
+  const resourcePath = this.resourcePath;
+  this.cacheable && this.cacheable();
+  const options = getOptions(this) || {};
+  const callback = this.async();
+  const loaderContext = this;
+
+  if (!options.allI18nData || typeof options.allI18nData !== 'object' || Object.keys(options.allI18nData).length === 0) {
+    this.emitWarning(new Error(`${LOADER_PREFIX} [${resourcePath}] 'allI18nData' option is missing or empty. No replacements will be made.`));
+    return callback(null, source, map);
+  }
+
+  let useNumericIndexing = options.useNumericIndexing !== undefined ? options.useNumericIndexing : true;
+  let localOriginalKeyToNumericIdMap = null;
+
+  if (useNumericIndexing) {
+    localOriginalKeyToNumericIdMap = loadNumericIdMap(this, options.numericMapPath);
+  }
+
+  const fallbackToHash = options.fallbackToHash !== undefined ? options.fallbackToHash : true;
+
+  try {
+    const parserOptions = {
+      sourceType: 'module',
+      plugins: ['jsx', 'typescript', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator'],
+      attachComment: true,
+      sourceFilename: resourcePath
+    };
+    const astFile = parser.parse(source, parserOptions);
+    const astProgram = astFile.program;
+    const comments = astFile.comments || [];
+    const {
+      literalKeys,
+      commentKeys
+    } = collectAndCategorizeUsedI18nKeys(astProgram, comments, options.allI18nData, options.isDebug);
+
+    if (this._module) {
+      if (!this._module.buildInfo) {
+        this._module.buildInfo = {};
+      }
+
+      if (literalKeys.size > 0) {
+        this._module.buildInfo.loaderIdentifiedLiteralI18nKeys = Array.from(literalKeys);
+      }
+
+      if (commentKeys.size > 0) {
+        this._module.buildInfo.loaderIdentifiedCommentI18nKeys = Array.from(commentKeys);
+      }
+    }
+
+    const keysToReplaceInLiterals = literalKeys;
+
+    if (keysToReplaceInLiterals.size === 0) {
+      return callback(null, source, map);
+    }
+
+    let replacementMade = false;
+    walk(astProgram, {
+      enter: function (node, parent, prop, index) {
+        const walkerControl = this;
+
+        if ((node.type === 'Literal' || node.type === 'StringLiteral') && typeof node.value === 'string') {
+          const originalValue = node.value;
+
+          if (keysToReplaceInLiterals.has(originalValue)) {
+            let replaced = false;
+
+            if (useNumericIndexing && localOriginalKeyToNumericIdMap) {
+              const numericId = localOriginalKeyToNumericIdMap[originalValue];
+
+              if (numericId !== undefined) {
+                const numericLiteralNode = {
+                  type: 'NumericLiteral',
+                  value: numericId
+                };
+                let replacementNode = numericLiteralNode;
+
+                if (parent && parent.type === 'JSXAttribute' && parent.value === node) {
+                  replacementNode = {
+                    type: 'JSXExpressionContainer',
+                    expression: numericLiteralNode
+                  };
+                }
+
+                walkerControl.replace(replacementNode);
+                replacementMade = true;
+                replaced = true;
+              }
+            }
+
+            if (!replaced && fallbackToHash) {
+              try {
+                const hashValue = generateShortHash(originalValue);
+                const hashedStringLiteralNode = {
+                  type: 'StringLiteral',
+                  value: hashValue
+                };
+                walkerControl.replace(hashedStringLiteralNode);
+                replacementMade = true;
+              } catch (hashError) {
+                loaderContext.emitError(new Error(`${LOADER_PREFIX} [${resourcePath}] Error hashing key "${originalValue}": ${hashError.message}`));
+              }
+            }
+          }
+        }
+      }
+    });
+
+    if (replacementMade) {
+      const generateOptions = {
+        sourceMaps: options.sourceMaps,
+        sourceFileName: resourcePath,
+        retainLines: false,
+        comments: true
+      };
+      const output = generator(astFile, generateOptions, source);
+      callback(null, output.code, options.sourceMaps && output.map ? output.map : map);
+    } else {
+      callback(null, source, map);
+    }
+  } catch (err) {
+    const detailedError = new Error(`${LOADER_PREFIX} [${resourcePath}] AST Processing Error: ${err.message} (Stack: ${err.stack})`);
+
+    if (err.loc) {
+      detailedError.message += ` at line ${err.loc.line}, column ${err.loc.column}`;
+    }
+
+    callback(detailedError);
+  }
+};

package/lib/shared/bundler/webpack/loaders/miniCssFallBackLoader.js

@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = function miniCssFallBackLoader(source) {
+  const replacedStr = source.replace('export default ', 'module.exports = '); //   console.log('src/loaders/docsLoader.js', replacedStr);
+
+  return replacedStr;
+};

package/lib/shared/bundler/webpack/loaders/workerLoader.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loader;
+exports.pitch = pitch;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _SingleEntryPlugin = _interopRequireDefault(require("webpack/lib/SingleEntryPlugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// import { getOptions } from 'loader-utils';
+// import validateOptions from 'schema-utils';
+const schema = {
+  'type': 'object',
+  'properties': {
+    'publicPath': {
+      'anyOf': [{
+        'type': 'string'
+      }, {
+        'instanceof': 'Function'
+      }]
+    },
+    'filename': {
+      'anyOf': [{
+        'type': 'string',
+        'minLength': 1
+      }, {
+        'instanceof': 'Function'
+      }]
+    },
+    'chunkFilename': {
+      'type': 'string',
+      'minLength': 1
+    },
+    'esModule': {
+      'type': 'boolean'
+    }
+  },
+  'additionalProperties': false
+}; // eslint-disable-next-line
+
+function loader() {}
+
+function getDefaultFilename(filename) {
+  if (typeof filename === 'function') {
+    return filename;
+  }
+
+  return filename.replace(/\.([a-z]+)(\?.+)?$/i, '.worker.$1$2');
+}
+
+function getDefaultChunkFilename(chunkFilename) {
+  return chunkFilename.replace(/\.([a-z]+)(\?.+)?$/i, '.worker.$1$2');
+}
+
+function pitch(request) {
+  this.cacheable(false);
+  const options = this.getOptions(); // console.log(this.getOptions());
+  // validateOptions(schema, options, {
+  //   name: 'Worker Loader',
+  //   baseDataPath: 'options'
+  // });
+
+  const workerContext = {};
+  const compilerOptions = this._compiler.options || {};
+  const filename = options.filename ? options.filename : getDefaultFilename(compilerOptions.output.filename);
+  const chunkFilename = options.chunkFilename ? options.chunkFilename : getDefaultChunkFilename(compilerOptions.output.chunkFilename);
+  const publicPath = options.publicPath ? options.publicPath : compilerOptions.output.publicPath;
+  workerContext.options = {
+    filename,
+    chunkFilename,
+    publicPath,
+    globalObject: 'self'
+  };
+  workerContext.compiler = this._compilation.createChildCompiler(`worker-loader ${request}`, workerContext.options);
+  /* 
+  new WebWorkerTemplatePlugin().apply(workerContext.compiler);
+  
+  if (compilerOptions.externals) {
+    new ExternalsPlugin(
+      getExternalsType(compilerOptions),
+      compilerOptions.externals
+    ).apply(workerContext.compiler);
+  } */
+
+  new _SingleEntryPlugin.default(this.context, `!!${request}`, _path.default.parse(this.resourcePath).name).apply(workerContext.compiler);
+  workerContext.request = request;
+  const cb = this.async();
+  workerContext.compiler.runAsChild((errorArg, entries, compilation) => {
+    let error = errorArg;
+
+    if (!error && compilation.errors && compilation.errors.length) {
+      // eslint-disable-next-line
+      error = compilation.errors[0];
+    }
+
+    const entry = entries && entries[0] && entries[0].files.values().next().value;
+
+    if (!error && !entry) {
+      error = Error(`WorkerPlugin: no entry for ${request}`);
+    }
+
+    if (error) {
+      return cb(error);
+    }
+
+    function workerCode() {
+      let blob;
+
+      try {
+        blob = new Blob([`importScripts('${this.workerUrl}');`], {
+          'type': 'application/javascript'
+        });
+      } catch (e1) {
+        throw new Error(e1);
+      }
+
+      let url = window.URL || window.webkitURL;
+      let blobUrl = url.createObjectURL(blob);
+      let worker = new Worker(blobUrl);
+      return worker;
+    }
+
+    return cb(null, `${options.esModule ? 'export default' : 'module.exports ='} {\n
+			workerUrl: __webpack_public_path__ + ${JSON.stringify(entry)}, \n
+			getInstance: ${workerCode} \n
+		}`);
+  });
+}

package/lib/shared/bundler/webpack/optimizationConfig.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.optimizationConfig = optimizationConfig;
+
+var _terserWebpackPlugin = _interopRequireDefault(require("terser-webpack-plugin"));
+
+var _nameTemplates = require("./common/nameTemplates");
+
+var _hashUtils = require("./custom_plugins/I18nSplitPlugin/utils/hashUtils");
+
+var _configCSSMinifierPlugin = require("./pluginConfigs/configCSSMinifierPlugin");
+
+var _splitChunksConfig = require("./splitChunksConfig");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function optimizationConfig(options) {
+  const {
+    changeRuntimeChunkChar
+  } = options;
+  const {
+    chunkSplitEnable
+  } = options.i18nChunkSplit;
+  const i18nChunkFilename = (0, _nameTemplates.nameTemplates)('i18njs', options);
+  const chunkFilenameHasContentHash = (0, _hashUtils.hasContentHash)(i18nChunkFilename);
+  /**
+   * NOTE: we only need multiple runtime files when we use contentHash
+   * other wise we don't need multiple runtime files based locale
+   * that's why  we added chunkSplitEnable && chunkFilenameHasContentHash logic
+   */
+
+  const suffix = // chunkSplitEnable ? '_[locale]' : '';
+  chunkSplitEnable && chunkFilenameHasContentHash ? '_[locale]' : '';
+  const char = changeRuntimeChunkChar;
+  const excludeList = options.optimization.jsExcludePath;
+  return {
+    splitChunks: (0, _splitChunksConfig.splitChunksConfig)(options),
+    minimizer: [// For webpack@5 you can use the `...` syntax to extend existing minimizers (i.e. `terser-webpack-plugin`), uncomment the next line
+    // '...',
+    excludeList !== '' ? new _terserWebpackPlugin.default({
+      exclude: excludeList,
+      extractComments: false // Do not extract comments to .LICENSE.txt files
+
+    }) : new _terserWebpackPlugin.default({
+      extractComments: false // Do not extract comments to .LICENSE.txt files
+
+    }), (0, _configCSSMinifierPlugin.configCSSMinifierPlugin)(options)].filter(Boolean),
+    moduleIds: 'named',
+    runtimeChunk: {
+      name: entrypoint => `runtime${char}${entrypoint.name}${suffix}`
+    }
+  };
+}

package/lib/shared/bundler/webpack/outputConfig.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.outputConfig = outputConfig;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _constants = require("../../constants");
+
+var _nameTemplates = require("./common/nameTemplates");
+
+var _modeUtils = require("./common/modeUtils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function outputConfig(options) {
+  const {
+    output,
+    publicPath,
+    htmlTemplate
+  } = options;
+  const outputO = {
+    filename: (0, _nameTemplates.nameTemplates)('js', options),
+    chunkFilename: (0, _nameTemplates.nameTemplates)('chunkjs', options),
+    chunkLoadingGlobal: (0, _modeUtils.getGlobalCacheStorageName)(options),
+    publicPath,
+    // clean: true,
+    path: _path.default.resolve(_constants.appPath, output)
+  };
+
+  if (htmlTemplate.crossorigin) {
+    outputO.crossOriginLoading = 'anonymous';
+  }
+
+  return outputO;
+}

package/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/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/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/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/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/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;
+}