@zohodesk/react-cli 0.0.1-beta.16 → 0.0.1-beta.162

package/lib/loaders/fileLoader.js

@@ -1,62 +1,64 @@
-'use strict';
+"use strict";
 
-var _path = require('path');
+var _path = _interopRequireDefault(require("path"));
 
-var _path2 = _interopRequireDefault(_path);
+var _loaderUtils = _interopRequireDefault(require("loader-utils"));
 
-var _loaderUtils = require('loader-utils');
-
-var _loaderUtils2 = _interopRequireDefault(_loaderUtils);
+var _common = require("../common");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 module.exports = function (content) {
+  let {
+    userRequest
+  } = this._module.issuer;
   this.cacheable && this.cacheable();
+
   if (!this.emitFile) {
     throw new Error('emitFile is required from module system');
   }
 
-  var options = _loaderUtils2.default.getOptions(this) || {};
-  var query = this.resourceQuery ? _loaderUtils2.default.parseQuery(this.resourceQuery) : {};
-
-  // let configKey = query.config || 'fileLoader';
+  let options = _loaderUtils.default.getOptions(this) || {};
+  let query = this.resourceQuery ? _loaderUtils.default.parseQuery(this.resourceQuery) : {}; // let configKey = query.config || 'fileLoader';
 
-  var config = {
-    publicPath: false,
+  let config = {
+    // publicPath: false,
     useRelativePath: false,
-    name: '[hash].[ext]',
-    publicPathStrigify: true
-  };
+    name: '[hash].[ext]' // publicPathStrigify: true
 
-  // options takes precedence over config
-  Object.keys(options).forEach(function (attr) {
+  }; // options takes precedence over config
+
+  Object.keys(options).forEach(attr => {
     config[attr] = options[attr];
-  });
+  }); // query takes precedence over config and options
 
-  // query takes precedence over config and options
-  Object.keys(query).forEach(function (attr) {
+  Object.keys(query).forEach(attr => {
     config[attr] = query[attr];
   });
+  let context = config.context || options.context;
 
-  var context = config.context || options.context;
-  var url = _loaderUtils2.default.interpolateName(this, config.name, {
+  let url = _loaderUtils.default.interpolateName(this, config.name, {
     context: context,
     content: content,
     regExp: config.regExp
   });
 
-  var outputPath = '';
+  let outputPath = '';
+  let filePath = this.resourcePath;
 
-  var filePath = this.resourcePath;
   if (config.useRelativePath) {
-    var issuerContext = this._module && this._module.issuer && this._module.issuer.context || context;
-    var relativeUrl = issuerContext && _path2.default.relative(issuerContext, filePath).split(_path2.default.sep).join('/');
-    var relativePath = relativeUrl && _path2.default.dirname(relativeUrl) + '/';
+    let issuerContext = this._module && this._module.issuer && this._module.issuer.context || context;
+
+    let relativeUrl = issuerContext && _path.default.relative(issuerContext, filePath).split(_path.default.sep).join('/');
+
+    let relativePath = relativeUrl && `${_path.default.dirname(relativeUrl)}/`;
+
     if (~relativePath.indexOf('../')) {
-      outputPath = _path2.default.posix.join(outputPath, relativePath, url);
+      outputPath = _path.default.posix.join(outputPath, relativePath, url);
     } else {
       outputPath = relativePath + url;
     }
+
     url = relativePath + url;
   } else if (config.outputPath) {
     // support functions as outputPath to generate them dynamically
@@ -66,21 +68,28 @@ module.exports = function (content) {
     outputPath = url;
   }
 
-  var publicPath = '__webpack_public_path__ + ' + JSON.stringify(url);
-  if (config.publicPath !== false) {
-    // support functions as publicPath to generate them dynamically
-    if (config.publicPathStringify) {
-      publicPath = JSON.Stringify(typeof config.publicPath === 'function' ? config.publicPath(url) : config.publicPath + url);
-    } else {
-      publicPath = typeof config.publicPath === 'function' ? config.publicPath(url) : config.publicPath + url;
-    }
-  }
+  let requestFromJS = /\.js$/.test(userRequest);
+  let publicPath = requestFromJS ? (0, _common.getPublicPathConfig)(url) : `__webpack_public_path__ + ${JSON.stringify(url)}`; // if (config.publicPath !== false) {
+  //   // support functions as publicPath to generate them dynamically
+  //   if (config.publicPathStringify) {
+  //     publicPath = JSON.Stringify(
+  //       typeof config.publicPath === 'function'
+  //         ? config.publicPath(url)
+  //         : config.publicPath + url
+  //     );
+  //   } else {
+  //     publicPath =
+  //       typeof config.publicPath === 'function'
+  //         ? config.publicPath(url)
+  //         : config.publicPath + url;
+  //   }
+  // }
 
   if (query.emitFile === undefined || query.emitFile) {
     this.emitFile(outputPath, content);
   }
 
-  return 'module.exports = ' + publicPath + ';';
+  return `module.exports = ${publicPath};`;
 };
 
 module.exports.raw = true;

package/lib/loaders/scriptInstrumentLoader.js

@@ -1,18 +1,16 @@
-'use strict';
+"use strict";
 
-var _esprima = require('esprima');
+var esprima = _interopRequireWildcard(require("esprima"));
 
-var esprima = _interopRequireWildcard(_esprima);
-
-var _escodegen = require('escodegen');
-
-var _escodegen2 = _interopRequireDefault(_escodegen);
+var _escodegen = _interopRequireDefault(require("escodegen"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-var start = {
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+let start = {
   type: 'ExpressionStatement',
   expression: {
     type: 'CallExpression',
@@ -56,22 +54,28 @@ var start = {
   }
 };
 
-var scriptInstrumentLoader = function scriptInstrumentLoader(source) {
-  var parsed = esprima.parseModule(source, { jsx: true });
-  for (var i in parsed.body) {
+let scriptInstrumentLoader = function (source) {
+  let parsed = esprima.parseModule(source, {
+    jsx: true
+  });
+
+  for (let i in parsed.body) {
     if (parsed.body[i].type === 'FunctionDeclaration' || parsed.body[i].type === 'ExportDefaultDeclaration' || parsed.body[i].type === 'ExportNamedDeclaration') {
-      var ParsedTemp = void 0;
+      let ParsedTemp;
+
       if (parsed.body[i].type === 'FunctionDeclaration') {
         ParsedTemp = parsed.body[i];
       } else {
         ParsedTemp = parsed.body[i].declaration;
       }
+
       if (ParsedTemp) {
         if (ParsedTemp.id) {
-          var funcname = ParsedTemp.id.name;
+          let funcname = ParsedTemp.id.name;
+
           if (funcname !== 'mapStateToProps') {
             if (!funcname.includes('_')) {
-              var startFunc = JSON.parse(JSON.stringify(start));
+              let startFunc = JSON.parse(JSON.stringify(start));
               startFunc.expression.arguments[0].value = this.resourcePath;
               startFunc.expression.arguments[0].raw = this.resourcePath;
               startFunc.expression.arguments[1].value = funcname;
@@ -84,8 +88,7 @@ var scriptInstrumentLoader = function scriptInstrumentLoader(source) {
     }
   }
 
-  return _escodegen2.default.generate(parsed);
-  // function removeDuplicates(arr) {
+  return _escodegen.default.generate(parsed); // function removeDuplicates(arr) {
   //   let uniqueArray = [];
   //   for (let i = 0; i < arr.length; i++) {
   //     if (uniqueArray.indexOf(arr[i]) == -1) {
@@ -97,9 +100,7 @@ var scriptInstrumentLoader = function scriptInstrumentLoader(source) {
   // funcArray = removeDuplicates(funcArray);
 };
 
-module.exports = scriptInstrumentLoader;
-
-// let start = {
+module.exports = scriptInstrumentLoader; // let start = {
 //   type: 'ExpressionStatement',
 //   expression: {
 //     type: 'CallExpression',

package/lib/loaders/selectorMappingLoader.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var _path = _interopRequireDefault(require("path"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _utils = require("../utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+let options = (0, _utils.getOptions)();
+const {
+  cssSelectorZipPath
+} = options.impactService;
+
+const zipname = _path.default.parse(cssSelectorZipPath).name; // console.log({ cssSelectorZipPath, zipname });
+// TODO:NOTE: need to check about .. path related files creation 
+// for now  no css files have given  form react-cli need to make sure about it.  
+
+
+let zippath = _path.default.join(process.cwd(), cssSelectorZipPath);
+
+if (_fs.default.existsSync(_path.default.join(process.cwd(), cssSelectorZipPath))) {
+  _fs.default.rmSync(zippath);
+
+  console.log('zip file deleted', zippath); // fs.rmSync(zippath, {force:true})
+  // console.log('created folder ==> ', dpath);
+} // const minicssComment =
+//   '// extracted by mini-css-extract-plugin\n';
+
+
+const startStr = '// extracted by mini-css-extract-plugin\n' + 'module.exports = ';
+
+module.exports = function (source) {
+  const {
+    rootContext,
+    resourcePath
+  } = this;
+
+  const relativePath = _path.default.relative(rootContext, resourcePath);
+
+  let fpath = _path.default.join(rootContext, zipname, relativePath);
+
+  let originalpath = _path.default.join(rootContext, relativePath);
+
+  if (relativePath.startsWith('..')) {
+    throw `unexpected path ${relativePath}`;
+  }
+
+  let dpath = fpath.slice(0, fpath.lastIndexOf(_path.default.sep));
+
+  if (!_fs.default.existsSync(originalpath)) {
+    throw `originalpath not exixt ${originalpath}`;
+  }
+
+  if (!_fs.default.existsSync(dpath)) {
+    _fs.default.mkdirSync(dpath, {
+      recursive: true
+    });
+  }
+
+  let jsonStr = '{}';
+
+  if (source.startsWith(startStr)) {
+    // source will  be  like 
+    // `// extracted by mini-css-extract-plugin\nmodule.exports = {"app":"zd-app"};`
+    jsonStr = source.slice(startStr.length, -1);
+  }
+
+  _fs.default.writeFileSync(`${fpath}_map`, jsonStr);
+
+  _fs.default.writeFileSync(fpath, _fs.default.readFileSync(originalpath));
+
+  return source;
+};

package/lib/loaders/workerLoader.js

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loader;
+exports.pitch = pitch;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _loaderUtils = require("loader-utils");
+
+var _schemaUtils = _interopRequireDefault(require("schema-utils"));
+
+var _SingleEntryPlugin = _interopRequireDefault(require("webpack/lib/SingleEntryPlugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* import WebWorkerTemplatePlugin from 'webpack/lib/webworker/WebWorkerTemplatePlugin';
+import ExternalsPlugin from 'webpack/lib/ExternalsPlugin'; */
+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 = (0, _loaderUtils.getOptions)(this);
+  (0, _schemaUtils.default)(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/middlewares/HMRMiddleware.js

@@ -1,35 +1,43 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = HMRMiddleware;
+
 function pathMatch(url, path) {
   if (url === path) {
     return true;
   }
-  var q = url.indexOf('?');
+
+  let q = url.indexOf('?');
+
   if (q === -1) {
     return false;
   }
+
   return url.substring(0, q) === path;
 }
 
 function createEventStream(heartbeat) {
-  var clientId = 0;
-  var clients = {};
+  let clientId = 0;
+  let clients = {};
+
   function everyClient(fn) {
-    Object.keys(clients).forEach(function (id) {
+    Object.keys(clients).forEach(id => {
       fn(clients[id]);
     });
   }
-  setInterval(function () {
-    everyClient(function (client) {
-      client.write('data: ' + JSON.stringify({ type: 'heartbeat' }) + '\n\n');
+
+  setInterval(() => {
+    everyClient(client => {
+      client.write(`data: ${JSON.stringify({
+        type: 'heartbeat'
+      })}\n\n`);
     });
   }, heartbeat).unref();
   return {
-    handler: function handler(req, res) {
+    handler: function (req, res) {
       req.socket.setKeepAlive(true);
       res.writeHead(200, {
         'Access-Control-Allow-Origin': '*',
@@ -38,15 +46,15 @@ function createEventStream(heartbeat) {
         Connection: 'keep-alive'
       });
       res.write('\n');
-      var id = clientId++;
+      let id = clientId++;
       clients[id] = res;
-      req.on('close', function () {
+      req.on('close', () => {
         delete clients[id];
       });
     },
-    publish: function publish(payload) {
-      everyClient(function (client) {
-        client.write('data: ' + JSON.stringify(payload) + '\n\n');
+    publish: function (payload) {
+      everyClient(client => {
+        client.write(`data: ${JSON.stringify(payload)}\n\n`);
       });
     }
   };
@@ -56,25 +64,26 @@ function extractBundles(stats) {
   // Stats has modules, single bundle
   if (stats.modules) {
     return [stats];
-  }
+  } // Stats has children, multiple bundles
+
 
-  // Stats has children, multiple bundles
   if (stats.children && stats.children.length) {
     return stats.children;
-  }
+  } // Not sure, assume single
+
 
-  // Not sure, assume single
   return [stats];
 }
 
 function publishStats(action, statsResult, eventStream, log) {
   // For multi-compiler, stats will be an object with a 'children' array of stats
-  var bundles = extractBundles(statsResult.toJson({ errorDetails: false }));
-  bundles.forEach(function (stats) {
+  let bundles = extractBundles(statsResult.toJson({
+    errorDetails: false
+  }));
+  bundles.forEach(stats => {
     if (log) {
-      log('webpack built ' + (stats.name ? stats.name + ' ' : '') + stats.hash + ' in ' + stats.time + 'ms');
-    }
-    // if (
+      log(`webpack built ${stats.name ? `${stats.name} ` : ''}${stats.hash} in ${stats.time}ms`);
+    } // if (
     //   //  !force &&
     //   action !== 'sync' &&
     //   stats &&
@@ -86,6 +95,8 @@ function publishStats(action, statsResult, eventStream, log) {
     //     type: 'still-ok'
     //   });
     // }
+
+
     eventStream.publish({
       type: 'hash',
       data: stats.hash
@@ -109,47 +120,54 @@ function publishStats(action, statsResult, eventStream, log) {
   });
 }
 
-function HMRMiddleware(compiler) {
-  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-  opts.log =
-  // eslint-disable-next-line no-console
+function HMRMiddleware(compiler, opts = {}) {
+  opts.log = // eslint-disable-next-line no-console
   typeof opts.log === 'undefined' ? console.log.bind(console) : opts.log;
   opts.path = opts.path || '/__webpack_hmr';
   opts.heartbeat = opts.heartbeat || 10 * 1000;
+  let eventStream = createEventStream(opts.heartbeat);
+  let latestStats = null;
+  let loggedInfo = false;
+  compiler.hooks.beforeCompile.tap('HMRMiddleware', (c, callback) => {
+    if (opts.log && !loggedInfo) {
+      opts.log('webpack compilation starts...');
+      loggedInfo = true;
+    }
 
-  var eventStream = createEventStream(opts.heartbeat);
-  var latestStats = null;
-
-  compiler.plugin('compile', function () {
+    callback && callback();
+  });
+  compiler.hooks.compile.tap('HMRMiddleware', () => {
     latestStats = null;
+
     if (opts.log) {
       opts.log('webpack building...');
     }
-    eventStream.publish({ type: 'building' });
+
+    eventStream.publish({
+      type: 'building'
+    });
   });
-  compiler.plugin('done', function (statsResult) {
+  compiler.hooks.done.tap('HMRMiddleware', statsResult => {
     // Keep hold of latest stats so they can be propagated to new clients
     latestStats = statsResult;
-
     publishStats('built', latestStats, eventStream, opts.log);
   });
-  var middleware = function middleware(req, res, next) {
+
+  let middleware = function (req, res, next) {
     if (!pathMatch(req.url, opts.path)) {
       return next();
     }
-    eventStream.handler(req, res);
-    // if (latestStats) {
+
+    eventStream.handler(req, res); // if (latestStats) {
     //   // Explicitly not passing in `log` fn as we don't want to log again on
     //   // the server
     //   //  publishStats('sync', latestStats, eventStream);
     // }
   };
+
   middleware.publish = eventStream.publish;
   return middleware;
-}
-
-// function buildModuleMap(modules) {
+} // function buildModuleMap(modules) {
 // 	let map = {};
 // 	modules.forEach(function(module) {
 // 		map[module.id] = module.name;

package/lib/middlewares/SSTMiddleware.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("../utils");
+
+function SSTMiddleware(compiler, callback) {
+  compiler.hooks.done.tap('SSTMiddleware', stats => {
+    (0, _utils.log)('Compilation finished!');
+    callback(stats.compilation.assets['js/moduleStats.js'].source());
+  });
+  return (res, req, next) => {
+    next();
+  };
+}
+
+var _default = SSTMiddleware;
+exports.default = _default;