@zohodesk/client_build_tool 0.0.1

package/lib/shared/bundler/webpack/custom_plugins/ServiceWorkerPlugin.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _fs = require("fs");
+
+var _LocaleChunkAssetsStore = require("./I18nSplitPlugin/LocaleChunkAssetsStore");
+
+var _emitAsset = require("./emitAsset");
+
+var _replaceCssDirTemplate = require("./RtlSplitPlugin/replaceCssDirTemplate");
+
+var _getInitialAssetsFuncTemplate = require("./getInitialAssetsFuncTemplate");
+
+const pluginName = 'ServiceWorkerPlugin';
+
+class ServiceWorkerPlugin {
+  constructor(options) {
+    this.templateFilePath = options.templateFilePath;
+    this.outputFilePath = options.outputFilePath;
+    this.publicPath = options.publicPath;
+    this.i18nFileNameTemplate = options.i18nFileNameTemplate;
+    this.chunkSplitEnable = options.chunkSplitEnable;
+    this.enableRTLSplit = options.enableRTLSplit;
+    this.entryPointName = options.entryPointName;
+    this.replaceText = options.replaceText; // this.publicPaths = options.publicPaths;
+  } // eslint-disable-next-line class-methods-use-this
+
+
+  isInitialChunk(chunk) {
+    if ('canBeInitial' in chunk) {
+      return chunk.canBeInitial();
+    }
+
+    return chunk.isInitial();
+  }
+
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      // Get store for cache
+      this.store = (0, _LocaleChunkAssetsStore.getLocaleChunkAssetsStore)(compilation);
+    });
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      compilation.hooks.processAssets.tap({
+        name: pluginName,
+        stage: compilation.PROCESS_ASSETS_STAGE_DERIVED
+      }, () => {
+        this.createServiceWorkerFile(compilation, compiler);
+      });
+    });
+  }
+
+  createServiceWorkerFile(compilation) {
+    const {
+      templateFilePath,
+      entryPointName,
+      outputFilePath,
+      chunkSplitEnable,
+      enableRTLSplit
+    } = this;
+    const templateContent = (0, _fs.readFileSync)(templateFilePath, 'utf-8');
+    let allChunkUrls = [];
+    const allI18nAssets = [];
+    const entryPoint = compilation.entrypoints.get(entryPointName);
+    const initialAssetsFuncTemplate = (0, _getInitialAssetsFuncTemplate.getInitialAssetsFuncTemplate)({
+      entryPoint,
+      compilation,
+      enableRTLSplit,
+      i18nStore: this.store,
+      chunkSplitEnable,
+      i18nFileNameTemplate: this.i18nFileNameTemplate,
+      functionName: 'getInitialAssets'
+    });
+    /**
+     * NOTE:
+     *  if chunkSplitEnable is false means,
+     *    serviceWorker will get i18n files path for html
+     */
+    // chunkSplitEnable &&
+
+    [...compilation.chunks].filter(c => !this.isInitialChunk(c)).forEach(chunk => {
+      allChunkUrls = [...allChunkUrls, ...chunk.files];
+    });
+    allChunkUrls = allChunkUrls.filter(fileName => !fileName.endsWith('.map'));
+
+    if (enableRTLSplit) {
+      allChunkUrls = (0, _replaceCssDirTemplate.replaceCssDirTemplateMapper)(allChunkUrls, _getInitialAssetsFuncTemplate.cssDirTemplate);
+    }
+
+    const mod = templateContent.replace(this.replaceText, `
+      ${initialAssetsFuncTemplate}
+
+      let initialAssetsObj = getInitialAssets({ lang: langLocale, dir: cssDir });
+
+      let initialAssets = initialAssetsObj.i18n.concat(
+        initialAssetsObj.css,
+        initialAssetsObj.js
+      );
+      self.assets = initialAssets;
+      
+      self.allChunks = ${JSON.stringify(allChunkUrls.concat(allI18nAssets))};`);
+    (0, _emitAsset.emitAsset)(compilation, outputFilePath, mod);
+  }
+
+}
+
+exports.default = ServiceWorkerPlugin;

package/lib/shared/bundler/webpack/custom_plugins/SourceMapPlugin/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SourceMapPlugin = void 0;
+
+var _webpack = require("webpack");
+
+/* eslint-disable class-methods-use-this */
+class SourceMapPlugin {
+  apply(compiler) {
+    const {
+      RawSource
+    } = compiler.webpack.sources;
+    compiler.hooks.thisCompilation.tap('splitSourceMap', compilation => {
+      compilation.hooks.processAssets.tap({
+        name: 'splitSourceMap',
+        stage: _webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+      }, assets => {
+        Object.keys(assets).forEach(assetName => {
+          const assetCode = assets[assetName].source();
+
+          if (/\.js$/.test(assetName) && !/\.i18n\.js$/.test(assetName) || /\.js\.map$/.test(assetName) && !/\.i18n\.js\.map$/.test(assetName)) {
+            compilation.renameAsset(assetName, `smap/${assetName}`);
+
+            if (!/\.map$/.test(assetName)) {
+              compilation.emitAsset(assetName, new RawSource(assetCode));
+            }
+          }
+        });
+      });
+    });
+  }
+
+}
+
+exports.SourceMapPlugin = SourceMapPlugin;

package/lib/shared/bundler/webpack/custom_plugins/TPHashMappingPlugin/addHashToFilePath.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addHashToFilePath = addHashToFilePath;
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function addHashToFilePath(filePath, hash) {
+  const pathObj = _path.default.parse(filePath);
+
+  const updatedFilePath = _path.default.format({
+    dir: pathObj.dir,
+    name: `${pathObj.name}.${hash}`,
+    ext: pathObj.ext
+  });
+
+  return updatedFilePath;
+}

package/lib/shared/bundler/webpack/custom_plugins/TPHashMappingPlugin/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TPHashMappingPlugin = void 0;
+
+var _webpack = require("webpack");
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _addHashToFilePath = require("./addHashToFilePath");
+
+var _cssClassNameGenerate = require("../../loaderConfigs/cssClassNameGenerate");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class TPHashMappingPlugin {
+  constructor(options) {
+    this.fileMappings = options.fileMappings;
+    this.tpFolder = options.tpFolder;
+  }
+
+  apply(compiler) {
+    new _webpack.DefinePlugin(this.getFiles()).apply(compiler);
+  }
+
+  getFiles() {
+    const hashMapping = {};
+    this.fileMappings.forEach(fileInfo => {
+      const filePath = _path.default.join(this.tpFolder, fileInfo.filePath);
+
+      if (_fs.default.existsSync(filePath)) {
+        const fileContent = _fs.default.readFileSync(filePath, {
+          encoding: 'utf-8'
+        });
+
+        const generatedHash = (0, _cssClassNameGenerate.getHash)(fileContent, fileInfo.hashLength || 10);
+        const outputFilePath = (0, _addHashToFilePath.addHashToFilePath)(filePath, generatedHash);
+
+        _fs.default.writeFileSync(outputFilePath, fileContent);
+
+        hashMapping[fileInfo.key] = JSON.stringify(generatedHash);
+      } else {
+        throw new Error(`Third party file ${fileInfo.fileName} does not exist`);
+      }
+    });
+    return hashMapping;
+  }
+
+}
+
+exports.TPHashMappingPlugin = TPHashMappingPlugin;

package/lib/shared/bundler/webpack/custom_plugins/UglifyCSSPlugin/index.js.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _uglifycss = _interopRequireDefault(require("uglifycss"));
+
+var _webpack = require("webpack");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable class-methods-use-this */
+// import { RawSource } from 'webpack-sources';
+const pluginName = 'UglifyCSSPlugin'; // TODO: Check for css minimizer plugin
+
+class UglifyCSSPlugin {
+  apply(compiler) {
+    const {
+      RawSource
+    } = compiler.webpack.sources;
+    compiler.hooks.compilation.tap(pluginName, compilation => {
+      compilation.hooks.processAssets.tapAsync({
+        name: pluginName,
+        stage: _webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE
+      }, assets => {
+        Object.keys(assets).filter(filename => /\.css$/.test(filename)).forEach(filename => {
+          try {
+            let asset = assets[filename].source();
+
+            if (typeof asset !== 'string') {
+              asset = asset.toString();
+            }
+
+            const result = _uglifycss.default.processString(asset);
+
+            compilation.updateAsset(filename, new RawSource(result));
+          } catch (e) {
+            compilation.errors.push(e);
+          }
+        });
+      });
+    });
+  }
+
+}
+
+exports.default = UglifyCSSPlugin;

package/lib/shared/bundler/webpack/custom_plugins/VariableConversionCollector/ErrorHandler.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.errHandler = exports.ErrorHandler = void 0;
+
+class ErrorHandler {
+  constructor(allowedErrs) {
+    this.errors = [];
+    this.errorTable = [];
+    this.allowedErrs = allowedErrs;
+    Object.assign(this, {
+      DECLARATION_IGNORED: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n message : Declaration Ignored`),
+      DECIMAL_CHECK: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n unit : ${errObj.unitErrorVal} ,\n message : ${errObj.message}`),
+      DECIMAL_REJECT: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n unit : ${errObj.unitErrorVal} ,\n message : ${errObj.message}`),
+      UNIT_ERROR: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n unit : ${errObj.unitErrorVal} ,\n message : ${errObj.message}`),
+      RANGE_ERROR: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n message : ${errObj.message}\r`),
+      VARIABLE_PRESENT: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n message : ${errObj.message}`),
+      MULTIPLE_OCCURANCES: errObj => this.addError(` prop: ${errObj.decl.prop} ,\n value : ${errObj.decl.value} ,\n filename : ${errObj.filename} ,\n filepath : ${errObj.path} ,\n line : ${errObj.decl.source.start.line} ,\n message : ${errObj.message}`)
+    });
+  }
+
+  setAllowedErrs(allErrs) {
+    this.allowedErrs = allErrs;
+    ['DECLARATION_IGNORED', 'DECIMAL_CHECK', 'DECIMAL_REJECT', 'UNIT_ERROR', 'RANGE_ERROR', 'VARIABLE_PRESENT', 'MULTIPLE_OCCURANCES'].forEach(err => {
+      if (!this.allowedErrs[err]) {
+        this[err] = () => null;
+      }
+    });
+  }
+
+  addError(errstr) {
+    this.errors.push(`{\n${errstr}\n}\n`);
+  }
+
+  errorFunction(errObj) {
+    if (errObj.type && this.allowedErrs[errObj.type] && errObj.decl.prop && errObj.decl.value) {
+      this[errObj.type](errObj);
+    }
+  } // eslint-disable-next-line class-methods-use-this
+
+
+  printError(errObj) {
+    console.log('{');
+    Object.keys(errObj).sort().forEach(key => {
+      if (key !== 'decl') {
+        console.log(`${key} : ${errObj[key]}`);
+      } else {
+        console.log(`prop : ${errObj.decl.prop}`);
+        console.log(`value : ${errObj.decl.value}`);
+        console.log(`linenum : ${errObj.decl.source.start.line}`);
+      }
+    });
+    console.log('}\n');
+  }
+
+}
+
+exports.ErrorHandler = ErrorHandler;
+const errHandler = new ErrorHandler();
+exports.errHandler = errHandler;