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

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

@@ -0,0 +1,114 @@
+"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");
+
+var _ServiceWorkerPluginUtils = require("./ServiceWorkerPluginUtils");
+
+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];
+      allI18nAssets.push((0, _ServiceWorkerPluginUtils.getI18nFileUrlPathTemplate)(compilation, chunk, this.i18nFileNameTemplate, '@locale@'));
+    });
+    allChunkUrls = allChunkUrls.filter(fileName => !fileName.endsWith('.map'));
+    allChunkUrls = allChunkUrls.map(fileName => fileName.replace('smap/', ''));
+
+    if (enableRTLSplit) {
+      allChunkUrls = (0, _replaceCssDirTemplate.replaceCssDirTemplateMapper)(allChunkUrls, _getInitialAssetsFuncTemplate.cssDirTemplate);
+    }
+
+    const mod = templateContent.replace(this.replaceText, `
+      ${initialAssetsFuncTemplate}
+
+      let initialAssetsObj = getInitialAssets();
+
+      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/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/ServiceWorkerPluginUtils.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getI18nFileUrlPathTemplate = getI18nFileUrlPathTemplate;
+
+function getI18nFileUrlPathTemplate(compilation, chunk, filenameTemplate, localeTemplate) {
+  const urlpath = compilation.getPath(filenameTemplate, {
+    chunk
+  });
+  return urlpath.replace('[locale]', localeTemplate);
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SourceMapPlugin = void 0;
+
+var _webpack = require("webpack");
+
+/* eslint-disable class-methods-use-this */
+function checkSmapFilePattern(assetName) {
+  return /\.js$/.test(assetName) && !/\.i18n\.js$/.test(assetName) || /\.js\.map$/.test(assetName) && !/\.i18n\.js\.map$/.test(assetName);
+}
+
+function skipRuntimeFiles(assetName) {
+  return !assetName.includes('[locale]');
+}
+
+const pluginName = 'SplitSourceMapPlugin'; // Purpose:
+
+/**
+ * we want build that can load files source map and without sourcemap at the same time,
+ * or can be mentioned as so single build need to support two different clients that one for fast load and one for debugging.
+ */
+
+class SourceMapPlugin {
+  apply(compiler) {
+    const {
+      RawSource
+    } = compiler.webpack.sources;
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      compilation.hooks.processAssets.tap({
+        name: pluginName,
+        stage: _webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+      }, assets => {
+        Object.keys(assets).forEach(assetName => {
+          const assetCode = assets[assetName].source();
+
+          if (checkSmapFilePattern(assetName) && skipRuntimeFiles(assetName)) {
+            compilation.renameAsset(assetName, `smap/${assetName}`);
+
+            if (!/\.map$/.test(assetName)) {
+              compilation.emitAsset(assetName, new RawSource(assetCode));
+            }
+          }
+        });
+      });
+      compilation.hooks.processAssets.tap({
+        name: pluginName,
+        stage: _webpack.Compilation.PROCESS_ASSETS_STAGE_DERIVED // additionalAssets: true
+
+      }, assets => {
+        Object.keys(assets).forEach(assetName => {
+          if (assetName.includes('runtime') && skipRuntimeFiles(assetName)) {
+            const runtimeAssetCode = assets[assetName].source();
+            const newAssetName = `smap/${assetName}`;
+            compilation.emitAsset(newAssetName, new RawSource(runtimeAssetCode));
+          }
+
+          ;
+        });
+      });
+    });
+  }
+
+}
+
+exports.SourceMapPlugin = SourceMapPlugin;

package/packages/client_build_tool/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/packages/client_build_tool/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/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/UglifyCSSPlugin/__test__/uglifyCss1.test.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _utilities = require("./utilities");
+
+describe('not remove default syntax space', () => {
+  it('original syntax', () => {
+    const inputvalues = `
+        p {
+            border: 1px solid green;
+        }`;
+    const expectedOutput = 'p{border:1px solid green}';
+    (0, _utilities.checkTestCases)((0, _utilities.minifyCss)(inputvalues), expectedOutput);
+  });
+  it('syntax with some extra spaces', () => {
+    const inputvalues = `
+        p {
+             border:   1px      solid    green;
+        }`;
+    const expectedOutput = 'p{border:1px solid green}';
+    (0, _utilities.checkTestCases)((0, _utilities.minifyCss)(inputvalues), expectedOutput);
+  });
+});
+test('gives margin to all sides', () => {
+  const inputvalues = `
+    p{
+       margin-top: 1px;
+       margin-left: 2px;
+       margin-bottom: 2px;
+       margin-right: 2px;
+    }`;
+  const expectedOutput = 'p{margin-top:1px;margin-left:2px;margin-bottom:2px;margin-right:2px}';
+  (0, _utilities.checkTestCases)((0, _utilities.minifyCss)(inputvalues), expectedOutput);
+});
+test('gives padding to all sides', () => {
+  const inputvalues = `
+    p{
+       padding-top: 1px;
+       padding-left: 2px;
+       padding-bottom: 2px;
+       padding-right: 2px;
+    }`;
+  const expectedOutput = 'p{padding-top:1px;padding-left:2px;padding-bottom:2px;padding-right:2px}';
+  (0, _utilities.checkTestCases)((0, _utilities.minifyCss)(inputvalues), expectedOutput);
+});
+test('removes 0 when decimal value is less than 1', () => {
+  const inputvalues = `
+    .foo {
+       padding: 10px;
+       border: 0.5px solid black;
+    }`;
+  const expectedOutput = '.foo{padding:10px;border:.5px solid black}';
+  (0, _utilities.checkTestCases)((0, _utilities.minifyCss)(inputvalues), expectedOutput);
+});
+test('minify the color values', () => {
+  const inputvalues = `
+    .foo {
+       background-color: rgb(255, 0, 0);
+       border: 2px solid rgb(0, 255, 0);
+    }`;
+  const expectedOutput = '.foo{background-color:red;border:2px solid #0f0}';
+  (0, _utilities.checkTestCases)((0, _utilities.minifyCss)(inputvalues), expectedOutput);
+});
+test('remove the comments', () => {
+  const inputvalues = `
+    /* to give margin */
+    .foo {
+        margin-top: 0px;
+        margin-right: 10px;
+        margin-bottom: 0px;
+        margin-left: 10px;
+    }`;
+  const expectedOutput = '.foo{margin-top:0;margin-right:10px;margin-bottom:0;margin-left:10px}';
+  (0, _utilities.checkTestCases)((0, _utilities.minifyCss)(inputvalues), expectedOutput);
+});

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/UglifyCSSPlugin/__test__/uglifycss.test.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _utilities = require("./utilities");
+
+test('remove white spaces', () => {
+  const inputvalues = `
+    .body{
+        color:'white'
+    }`;
+  const expectedOutput = '.body{color:\'white\'}';
+  (0, _utilities.checkTestCases)((0, _utilities.minifyCss)(inputvalues), expectedOutput);
+});
+test('remove extra line', () => {
+  const inputvalues = `
+.whole{
+    width: 100%;
+    height: 94%;
+    background-color: white;
+}
+
+.category{
+    color: #666970;
+    font-weight: bolder;
+    font-size: 2vh;
+    padding: 2%;
+    box-sizing: border-box;
+    border-bottom: 1px solid rgba(128, 128, 128, 0.223);
+}`;
+  const expectedOutput = '.whole{width:100%;height:94%;background-color:white}.category{color:#666970;font-weight:bolder;font-size:2vh;padding:2%;box-sizing:border-box;border-bottom:1px solid rgba(128,128,128,0.223)}';
+  (0, _utilities.checkTestCases)((0, _utilities.minifyCss)(inputvalues), expectedOutput);
+});
+test('different classes have same property', () => {
+  const inputvalues = `
+.firstElement{
+    color:red;
+}
+
+.secondElement {
+    color: red;
+}
+
+.ThirdElement {
+    color: red;
+}`;
+  const expectedOutput = '.firstElement{color:red}.secondElement{color:red}.ThirdElement{color:red}';
+  (0, _utilities.checkTestCases)((0, _utilities.minifyCss)(inputvalues), expectedOutput);
+});
+describe('checking properties with value 0', () => {
+  it('margin', () => {
+    (0, _utilities.checkZeroForUnits)('margin');
+  });
+  it('width', () => {
+    (0, _utilities.checkZeroForUnits)('width');
+  });
+  it('height', () => {
+    (0, _utilities.checkZeroForUnits)('height');
+  });
+  it('padding', () => {
+    (0, _utilities.checkZeroForUnits)('padding');
+  });
+  it('border', () => {
+    (0, _utilities.checkZeroForUnits)('border');
+  });
+});

package/packages/client_build_tool/lib/shared/bundler/webpack/custom_plugins/UglifyCSSPlugin/__test__/utilities.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkTestCases = checkTestCases;
+exports.checkZeroForUnits = checkZeroForUnits;
+exports.minifyCss = minifyCss;
+
+const uglifycss = require('uglifycss');
+
+function minifyCss(inputCss) {
+  const minifiedCSS = uglifycss.processString(inputCss);
+  return minifiedCSS;
+}
+
+function checkTestCases(inputvalues, expectedOutput) {
+  expect(inputvalues).toBe(expectedOutput);
+}
+
+function checkZeroForUnits(name) {
+  const inputvalues = `
+.firstElement{
+    ${name} :0vh;
+}`;
+  const expectedOutput = `.firstElement{${name}:0}`;
+  checkTestCases(minifyCss(inputvalues), expectedOutput);
+}

package/packages/client_build_tool/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/packages/client_build_tool/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;