@zohodesk/client_build_tool 0.0.1-0.exp.0.0.3

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCSSLoaders = getCSSLoaders;
+
+var _miniCssExtractPlugin = _interopRequireDefault(require("mini-css-extract-plugin"));
+
+var _configPostCssLoader = require("./loaderConfigs/configPostCssLoader");
+
+var _getCssLoaderOptions = require("./loaderConfigs/getCssLoaderOptions");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getCSSLoaders(options) {
+  const cssLoaderOptions = (0, _getCssLoaderOptions.getCssLoaderOptions)(options);
+  return [{
+    loader: require.resolve('./loaders/miniCssFallBackLoader')
+  }, {
+    loader: _miniCssExtractPlugin.default.loader,
+    options: {
+      publicPath: '../'
+    }
+  }, {
+    loader: 'css-loader',
+    options: cssLoaderOptions
+  }, (0, _configPostCssLoader.configPostCssLoader)(options)].filter(Boolean);
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CSS_MODULE_TYPE = void 0;
+exports.getFilenameFromModule = getFilenameFromModule;
+const CSS_MODULE_TYPE = 'css/mini-extract';
+exports.CSS_MODULE_TYPE = CSS_MODULE_TYPE;
+
+function getFilenameFromModule(webpackModule) {
+  const {
+    userRequest
+  } = webpackModule;
+
+  if (webpackModule.type === CSS_MODULE_TYPE) {
+    const {
+      _identifier: identifier = ''
+    } = webpackModule;
+    return identifier.slice(identifier.lastIndexOf('!') + 1);
+  }
+
+  return userRequest;
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsLoaders = jsLoaders;
+
+var _babelLoaderConfig = require("./loaderConfigs/babelLoaderConfig");
+
+var {
+  i18nIdReplaceLoaderConfig
+} = require("./loaderConfigs/i18nIdReplaceLoaderConfig");
+
+function jsLoaders(options) {
+  const useLoaders = [(0, _babelLoaderConfig.babelLoaderConfig)(options)];
+
+  if (options.i18nIndexing && options.i18nIndexing.enable) {
+    const i18nLoader = i18nIdReplaceLoaderConfig(options);
+
+    if (i18nLoader) {
+      useLoaders.push(i18nLoader);
+    }
+  }
+
+  return [{
+    test: /\.js$/,
+    exclude: /node_modules/,
+    use: useLoaders
+  }];
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assetLoaders = assetLoaders;
+
+var _configsAssetsLoaders = require("./configsAssetsLoaders");
+
+function assetLoaders(options) {
+  return [(0, _configsAssetsLoaders.configImageLoader)(options), (0, _configsAssetsLoaders.configFontLoader)(options), (0, _configsAssetsLoaders.configSVGLoader)(options), (0, _configsAssetsLoaders.configAudioLoader)(options), (0, _configsAssetsLoaders.configVideoLoader)(options)];
+}

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,86 @@
+"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");
+
+const ImageExtRegex = /\.jpe?g$|\.gif$|\.png|\.webp$/;
+const FontExtRegex = /\.woff2|\.woff$|\.ttf$|\.eot$/;
+const SVGExtRegex = /\.svg$/;
+const AudioExtRegex = /\.ogg|\.mp3$/;
+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;
+}
+
+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)
+  });
+}

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

@@ -0,0 +1,65 @@
+"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;
+
+    let cleanFileName = fileNameWithoutExt.replace(/-/g, '_').toLowerCase();
+
+    if (cleanFileName.endsWith('.module')) {
+      cleanFileName = cleanFileName.slice(0, -7);
+    }
+
+    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/loaderConfigs/i18nIdReplaceLoaderConfig.js

@@ -0,0 +1,94 @@
+"use strict";
+
+const path = require('path');
+
+const fs = require('fs');
+
+let allI18nDataFromPropertiesCache = null;
+
+function loadJSResourcesOnce(options) {
+  if (allI18nDataFromPropertiesCache) {
+    return allI18nDataFromPropertiesCache;
+  }
+
+  let resourcePathToLoad = '';
+
+  if (options.i18nIndexing && options.i18nIndexing.enable && options.i18nIndexing.jsResourcePath) {
+    resourcePathToLoad = options.i18nIndexing.jsResourcePath;
+  } else if (options.i18nChunkSplit && options.i18nChunkSplit.jsResource) {
+    resourcePathToLoad = options.i18nChunkSplit.jsResource;
+  } else {
+    allI18nDataFromPropertiesCache = {};
+    return allI18nDataFromPropertiesCache;
+  }
+
+  const propertiesFilePath = path.resolve(process.cwd(), resourcePathToLoad);
+  const i18nData = {};
+
+  try {
+    const data = fs.readFileSync(propertiesFilePath, {
+      encoding: 'utf-8'
+    });
+    const lines = data.split(/\r?\n/);
+    lines.forEach(line => {
+      const trimmedLine = line.trim();
+
+      if (trimmedLine.startsWith('#') || trimmedLine.startsWith('!') || trimmedLine === '') {
+        return;
+      }
+
+      let separatorIndex = -1;
+
+      for (let i = 0; i < trimmedLine.length; i++) {
+        if ((trimmedLine[i] === '=' || trimmedLine[i] === ':') && (i === 0 || trimmedLine[i - 1] !== '\\')) {
+          separatorIndex = i;
+          break;
+        }
+      }
+
+      if (separatorIndex > 0) {
+        let key = trimmedLine.substring(0, separatorIndex).trim();
+        const value = trimmedLine.substring(separatorIndex + 1).trim();
+        key = key.replace(/\\ /g, ' ');
+
+        if (key) {
+          i18nData[key] = value;
+        }
+      }
+    });
+  } catch (err) {// Silent error handling
+  }
+
+  allI18nDataFromPropertiesCache = i18nData;
+  return allI18nDataFromPropertiesCache;
+}
+
+function i18nIdReplaceLoaderConfig(options) {
+  const allI18nData = loadJSResourcesOnce(options);
+
+  const i18nKeyReplaceLoaderPath = require.resolve('../loaders/i18nIdReplaceLoader.js');
+
+  const loaderOptions = {
+    allI18nData: allI18nData,
+    sourceMaps: !!options.devtool && options.devtool.includes('source-map'),
+    isDebug: options.mode === 'development'
+  };
+
+  if (options.i18nIndexing && options.i18nIndexing.enable) {
+    loaderOptions.useNumericIndexing = true;
+    loaderOptions.numericMapPath = options.i18nIndexing.numericMapPath;
+    loaderOptions.fallbackToHash = options.i18nIndexing.fallbackToHash !== undefined ? options.i18nIndexing.fallbackToHash : true;
+  } else {
+    loaderOptions.useNumericIndexing = false;
+    loaderOptions.fallbackToHash = true;
+  }
+
+  return {
+    loader: i18nKeyReplaceLoaderPath,
+    options: loaderOptions
+  };
+}
+
+module.exports = {
+  i18nIdReplaceLoaderConfig
+};