@zohodesk/client_build_tool 0.0.1

package/lib/shared/bundler/webpack/loaderConfigs/babelLoaderConfig.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.babelLoaderConfig = babelLoaderConfig;
+
+var _babelWebConfig = require("../../../babel/babelWebConfig");
+
+function babelLoaderConfig(options) {
+  const babelConfig = (0, _babelWebConfig.babelWebConfig)(options);
+  return {
+    loader: 'babel-loader',
+    options: { ...babelConfig,
+      cacheDirectory: true
+    }
+  };
+}

package/lib/shared/bundler/webpack/loaderConfigs/checkIsPatternsMatchFilename.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkIsPatternsMatchFilename = checkIsPatternsMatchFilename;
+exports.modifyAsExclude = modifyAsExclude;
+
+var _ignore = _interopRequireDefault(require("ignore"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/** 
+  @param {Array<String>} patterns: 
+  // include src folder, include deskapp folder, exclude node modules
+  [
+    "src",
+    "deskapp",
+    "!node_modules"
+  ]
+  @param {String} filename : 
+  filename : 'D:/MyWork/..../desk_client_app/supportapp/src/components/Avatar/Avatar.module.css,
+
+  @return {Boolean} : true or false
+*/
+function checkIsPatternsMatchFilename(patterns, filename) {
+  if (!filename) {
+    return false;
+  }
+
+  if (typeof patterns === 'undefined') {
+    return true;
+  }
+
+  if (typeof patterns === 'function') {
+    return patterns(filename);
+  }
+
+  if (typeof patterns === 'string') {
+    // eslint-disable-next-line no-param-reassign
+    patterns = [patterns];
+  }
+
+  if (Array.isArray(patterns)) {
+    return patterns.length ? (0, _ignore.default)({
+      allowRelativePaths: true
+    }).add(patterns).ignores(filename) : true;
+  } // eslint-disable-next-line no-throw-literal
+
+
+  throw `UnKnown pattern Error ${JSON.stringify(patterns)}`;
+}
+
+function modifyAsExclude(patterns) {
+  return patterns.map(pattern => pattern[0] === '!' ? pattern.slice(1) : `!${pattern}`);
+}

package/lib/shared/bundler/webpack/loaderConfigs/configHtmlTemplateLoader.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configHtmlTemplateLoader = configHtmlTemplateLoader;
+
+function configHtmlTemplateLoader(options) {
+  return {
+    test: /\.tmpl$/,
+    use: [{
+      loader: 'html-loader',
+      options: {
+        minimize: true
+      }
+    }]
+  };
+}

package/lib/shared/bundler/webpack/loaderConfigs/configPostCssLoader.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configPostCssLoader = configPostCssLoader;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _filterPluginsAllowedForSpecficFile = require("../../../postcss/filterPluginsAllowedForSpecficFile");
+
+var _getAllowedPostCssPlugins = require("../../../postcss/getAllowedPostCssPlugins");
+
+var _constants = require("../../../constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// import EmptyPlugin from '../custom_postcss_plugins/EmptyPlugin';
+function configPostCssLoader(options) {
+  const pluginsOptions = options.css.plugins;
+  const enabledPlugins = (0, _filterPluginsAllowedForSpecficFile.getEnabledPlugins)(pluginsOptions);
+  const getAllowedPostCssPlugins = (0, _getAllowedPostCssPlugins.postcssPluginGetter)(options);
+
+  function configPostCssPlugins(params) {
+    const filename = _path.default.relative(_constants.appPath, params.resourcePath);
+
+    const allowedPostCssPlugins = getAllowedPostCssPlugins(filename);
+    return allowedPostCssPlugins;
+  }
+
+  return enabledPlugins.length && {
+    loader: 'postcss-loader',
+    options: {
+      postcssOptions: configPostCssPlugins
+    }
+  };
+}

package/lib/shared/bundler/webpack/loaderConfigs/configWebWorkerLoader.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configWebWorkerLoader = configWebWorkerLoader;
+
+var _nameTemplates = require("../common/nameTemplates");
+
+function configWebWorkerLoader(options) {
+  return {
+    test: /\.worker.js$/,
+    use: {
+      loader: require.resolve('../loaders/workerLoader.js'),
+      options: {
+        esModule: true,
+        filename: (0, _nameTemplates.nameTemplates)('workerjs', options)
+      }
+    }
+  };
+}

package/lib/shared/bundler/webpack/loaderConfigs/configsAssetsLoaders.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configAudioLoader = configAudioLoader;
+exports.configFontLoader = configFontLoader;
+exports.configImageLoader = configImageLoader;
+exports.configSVGLoader = configSVGLoader;
+exports.configVideoLoader = configVideoLoader;
+
+var _nameTemplates = require("../common/nameTemplates");
+
+// function getLoaderOptionQueryString(params) {
+const ImageExtRegex = /\.jpe?g$|\.gif$|\.png|\.webp$/;
+const FontExtRegex = /\.woff2|\.woff$|\.ttf$|\.eot$/;
+const SVGExtRegex = /\.svg$/;
+const AudioExtRegex = /\.ogg$/;
+const VideoExtRegex = /\.mp4|\.webm$/;
+
+function createAssetLoader({
+  test,
+  nameTemplate,
+  limit
+}) {
+  const conf = {
+    test,
+    type: 'asset'
+  };
+
+  if (limit) {
+    conf.parser = {
+      dataUrlCondition: {
+        maxSize: limit // 4 * 1024 // 4kb
+
+      }
+    };
+  } else {
+    conf.type = 'asset/resource';
+  }
+
+  if (nameTemplate) {
+    conf.generator = {
+      filename: nameTemplate
+    };
+  }
+
+  return conf;
+}
+/**
+ * @typedef {Object} LoaderConfig
+ * @property {Number} enableChunkHash
+ */
+
+/**
+ * @param {LoaderConfig} options
+ * @returns
+ */
+
+
+function configImageLoader(options) {
+  return createAssetLoader({
+    test: ImageExtRegex,
+    nameTemplate: (0, _nameTemplates.nameTemplates)('image', options),
+    limit: 1000
+  });
+}
+
+function configFontLoader(options) {
+  return createAssetLoader({
+    test: FontExtRegex,
+    nameTemplate: (0, _nameTemplates.nameTemplates)('font', options),
+    limit: 1000
+  });
+}
+
+function configSVGLoader(options) {
+  return createAssetLoader({
+    test: SVGExtRegex,
+    nameTemplate: (0, _nameTemplates.nameTemplates)('svg', options),
+    limit: 1000
+  });
+}
+
+function configAudioLoader(options) {
+  return createAssetLoader({
+    test: AudioExtRegex,
+    nameTemplate: (0, _nameTemplates.nameTemplates)('audio', options)
+  });
+}
+
+function configVideoLoader(options) {
+  return createAssetLoader({
+    test: VideoExtRegex,
+    nameTemplate: (0, _nameTemplates.nameTemplates)('video', options)
+  });
+}
+/*
+export function createNameTemplate(enableChunkHash) {
+  const ext = `${enableChunkHash ? ".[hash:20]" : ""}.[ext]`;
+  return `[name]${ext}`;
+}
+
+export function createImageAndFontsAndSVGLoaders(enableChunkHash) {
+  const nameTemplate = createNameTemplate(enableChunkHash);
+  return [
+    configImageLoader(nameTemplate),
+    configFontLoader(nameTemplate),
+    configSVGLoader(nameTemplate),
+    configAudioLoader(nameTemplate)
+  ];
+}
+*/
+
+/*
+export function createLoaderOptionObject(
+  loaderName,
+  nameTemplate,
+  fallback,
+  limit = 1000
+) {
+  return {
+    loader: loaderName,
+    options: {
+      limit,
+      name: nameTemplate,
+      fallback
+    }
+  };
+}
+
+function configLoaderObject(filter, loaderAndOptions) {
+  return {
+    test: filter,
+    use: loaderAndOptions
+  };
+}
+*/

package/lib/shared/bundler/webpack/loaderConfigs/cssClassNameGenerate.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getHash = getHash;
+
+var _crypto = require("crypto");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _checkIsPatternsMatchFilename = require("./checkIsPatternsMatchFilename");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getHash(str, length) {
+  return (0, _crypto.createHash)('md5').update(str).digest('hex').slice(0, length);
+}
+
+const defaultSelectorBlob = '[prefix]-[filename]-[local]';
+
+function getSuitableBlob(customizations = [], filename) {
+  const custom = customizations.find(({
+    enable,
+    patterns
+  }) => enable && (0, _checkIsPatternsMatchFilename.checkIsPatternsMatchFilename)(patterns, filename));
+  return custom && custom.blob || defaultSelectorBlob;
+}
+
+var _default = options => {
+  const {
+    classNameOptions
+  } = options.css;
+  const {
+    classNamePrefix,
+    customizations
+  } = classNameOptions;
+  return (context, localIdentName, localName) => {
+    // NOTE:  in build machine we use date as folder path.
+    // So every time we create new build there is path will alway different
+    // So, in order to minimize that problem we try in relative path;
+    // console.log('context.resourcePath', context.resourcePath, context);
+    // let contextResourcePath = context.resourcePath;
+    const {
+      rootContext,
+      resourcePath
+    } = context;
+
+    const relativePath = _path.default.relative(rootContext, resourcePath);
+
+    const fileNameWithoutExt = _path.default.parse(relativePath).name;
+
+    const cleanFileName = fileNameWithoutExt.replace(/-/g, '_').toLowerCase();
+    const suitableBlob = getSuitableBlob(customizations, resourcePath);
+    return suitableBlob.replaceAll('[local]', localName).replaceAll('[prefix]', classNamePrefix).replaceAll('[filename]', cleanFileName).replaceAll('[hash]', getHash(`${relativePath}-${localName}`, 10));
+  };
+};
+
+exports.default = _default;

package/lib/shared/bundler/webpack/loaderConfigs/getCssLoaderOptions.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCssLoaderOptions = getCssLoaderOptions;
+
+var _cssClassNameGenerate = _interopRequireDefault(require("./cssClassNameGenerate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getCssLoaderOptions(options) {
+  const cssLoaderOptions = {
+    importLoaders: 1,
+    modules: {
+      getLocalIdent: (0, _cssClassNameGenerate.default)(options)
+    },
+    sourceMap: true
+  };
+  return cssLoaderOptions;
+}

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,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.optimizationConfig = optimizationConfig;
+
+var _nameTemplates = require("./common/nameTemplates");
+
+var _hashUtils = require("./custom_plugins/I18nSplitPlugin/utils/hashUtils");
+
+var _configCSSMinifierPlugin = require("./pluginConfigs/configCSSMinifierPlugin");
+
+var _splitChunksConfig = require("./splitChunksConfig");
+
+function optimizationConfig(options) {
+  const {
+    changeRuntimeChunkChar
+  } = options;
+  const {
+    chunkSplitEnable
+  } = options.i18nChunkSplit;
+  const i18nChunkFilename = (0, _nameTemplates.nameTemplates)('i18nchunkjs', 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;
+  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
+    '...', (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,28 @@
+"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");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function outputConfig(options) {
+  const {
+    output,
+    publicPath
+  } = options;
+  return {
+    filename: (0, _nameTemplates.nameTemplates)('js', options),
+    chunkFilename: (0, _nameTemplates.nameTemplates)('chunkjs', options),
+    publicPath,
+    // clean: true,
+    path: _path.default.resolve(_constants.appPath, output)
+  };
+}

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: true,
+    openAnalyzer: false,
+    statsOptions: {
+      source: false,
+      normal: true,
+      chunks: false,
+      chunkGroups: false,
+      module: false,
+      assets: true,
+      assetsSort: 'name'
+    }
+  };
+}

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

@@ -0,0 +1,24 @@
+"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) {
+  if ((0, _modeUtils.isNotProduction)(options)) {
+    return null;
+  } // return null;
+  // return new UglifyCSSPlugin();
+
+
+  return 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
+  });
+}