@ringcentral-integration/utils 0.0.1

package/src/utils/waitUntilTo.js

@@ -0,0 +1,99 @@
+"use strict";
+
+require("core-js/modules/es.object.to-string");
+require("core-js/modules/es.promise");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.waitUntilTo = void 0;
+require("regenerator-runtime/runtime");
+var _waitUntil = require("./waitUntil");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+/**
+ * like `waitUntil`, but polling check `fn` execute without throw error,
+ * and throw latest error when timeout.
+ *
+ * @returns `callback` result when callback execute completed.
+ */
+var waitUntilTo = function waitUntilTo(fn) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$interval = _ref.interval,
+    interval = _ref$interval === void 0 ? 100 : _ref$interval,
+    _ref$timeout = _ref.timeout,
+    timeout = _ref$timeout === void 0 ? 5000 : _ref$timeout;
+  var rejector;
+  var waitUntilPromise;
+
+  // eslint-disable-next-line no-async-promise-executor
+  var promise = new Promise( /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(resolve, reject) {
+      var lastError, callback;
+      return regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              rejector = reject;
+              callback = /*#__PURE__*/function () {
+                var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+                  var result;
+                  return regeneratorRuntime.wrap(function _callee$(_context) {
+                    while (1) {
+                      switch (_context.prev = _context.next) {
+                        case 0:
+                          _context.prev = 0;
+                          _context.next = 3;
+                          return fn();
+                        case 3:
+                          result = _context.sent;
+                          resolve(result);
+                          return _context.abrupt("return", true);
+                        case 8:
+                          _context.prev = 8;
+                          _context.t0 = _context["catch"](0);
+                          lastError = _context.t0;
+                          return _context.abrupt("return", false);
+                        case 12:
+                        case "end":
+                          return _context.stop();
+                      }
+                    }
+                  }, _callee, null, [[0, 8]]);
+                }));
+                return function callback() {
+                  return _ref3.apply(this, arguments);
+                };
+              }();
+              waitUntilPromise = (0, _waitUntil.waitUntil)(callback, {
+                interval: interval,
+                timeout: timeout
+              });
+              _context2.prev = 3;
+              _context2.next = 6;
+              return waitUntilPromise;
+            case 6:
+              _context2.next = 11;
+              break;
+            case 8:
+              _context2.prev = 8;
+              _context2.t0 = _context2["catch"](3);
+              reject(lastError);
+            case 11:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, null, [[3, 8]]);
+    }));
+    return function (_x, _x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }());
+  promise.cancel = function () {
+    rejector(new Error('Async waitUntilTo has been cancelled'));
+    waitUntilPromise.cancel();
+  };
+  return promise;
+};
+exports.waitUntilTo = waitUntilTo;
+//# sourceMappingURL=waitUntilTo.js.map

package/src/utils/waitUntilTo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"waitUntilTo.js","names":["_waitUntil","require","asyncGeneratorStep","gen","resolve","reject","_next","_throw","key","arg","info","value","error","done","Promise","then","_asyncToGenerator","fn","self","args","arguments","apply","err","undefined","waitUntilTo","_ref","length","_ref$interval","interval","_ref$timeout","timeout","rejector","waitUntilPromise","promise","_ref2","regeneratorRuntime","mark","_callee2","lastError","callback","wrap","_callee2$","_context2","prev","next","_ref3","_callee","result","_callee$","_context","sent","abrupt","t0","stop","waitUntil","_x","_x2","cancel","Error","exports"],"sources":["src/utils/waitUntilTo.ts"],"sourcesContent":["import type { WaitUntilOption } from './waitUntil';\nimport { waitUntil } from './waitUntil';\n\nexport interface WaitUntilToPromise<T> extends Promise<T> {\n  /** cancel wailUntilTo timer */\n  cancel: () => void;\n}\n\n/**\n * like `waitUntil`, but polling check `fn` execute without throw error,\n * and throw latest error when timeout.\n *\n * @returns `callback` result when callback execute completed.\n */\nexport const waitUntilTo = <T = any>(\n  fn: () => T,\n  { interval = 100, timeout = 5000 }: WaitUntilOption = {},\n): WaitUntilToPromise<T> => {\n  let rejector: (reason?: any) => void;\n  let waitUntilPromise: ReturnType<typeof waitUntil>;\n\n  // eslint-disable-next-line no-async-promise-executor\n  const promise = new Promise<T>(async (resolve, reject) => {\n    let lastError: any;\n    rejector = reject;\n\n    const callback = async () => {\n      try {\n        const result = await fn();\n\n        resolve(result);\n\n        return true;\n      } catch (e) {\n        lastError = e;\n        return false;\n      }\n    };\n\n    waitUntilPromise = waitUntil(callback, { interval, timeout });\n\n    try {\n      await waitUntilPromise;\n    } catch (e) {\n      reject(lastError);\n    }\n  }) as WaitUntilToPromise<T>;\n\n  promise.cancel = () => {\n    rejector(new Error('Async waitUntilTo has been cancelled'));\n    waitUntilPromise.cancel();\n  };\n\n  return promise;\n};\n"],"mappings":"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"}

package/src/webpackPlugins/NoChunkChecker/NoChunkChecker.js

@@ -0,0 +1,56 @@
+"use strict";
+
+require("core-js/modules/es.symbol");
+require("core-js/modules/es.symbol.description");
+require("core-js/modules/es.symbol.to-primitive");
+require("core-js/modules/es.array.concat");
+require("core-js/modules/es.array.for-each");
+require("core-js/modules/es.date.to-primitive");
+require("core-js/modules/es.function.name");
+require("core-js/modules/es.number.constructor");
+require("core-js/modules/es.object.to-string");
+require("core-js/modules/web.dom-collections.for-each");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NoChunkChecker = void 0;
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var NoChunkChecker = /*#__PURE__*/function () {
+  function NoChunkChecker() {
+    var _this$_options$files;
+    var _options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, NoChunkChecker);
+    this._options = _options;
+    this._files = void 0;
+    this._files = (_this$_options$files = this._options.files) !== null && _this$_options$files !== void 0 ? _this$_options$files : [];
+  }
+  _createClass(NoChunkChecker, [{
+    key: "apply",
+    value: function apply(compiler) {
+      var _this = this;
+      compiler.hooks.shouldEmit.tap('NoChunkChecker', function (compilation) {
+        var shouldEmit = true;
+        compilation.chunks.forEach(function (chunk) {
+          _this._files.forEach(function (file) {
+            if (chunk.name !== file && (typeof chunk.runtime === 'string' && chunk.runtime === file || _typeof(chunk.runtime) === 'object' && chunk.runtime.has(file))) {
+              shouldEmit = false;
+              console.error("NoChunkChecker: entry: '".concat(file, "' found to load chunk: '").concat(chunk.name, "'"));
+            }
+          });
+        });
+        if (!shouldEmit) {
+          throw new Error('Bad chunks found!!!');
+        }
+        return shouldEmit;
+      });
+    }
+  }]);
+  return NoChunkChecker;
+}();
+exports.NoChunkChecker = NoChunkChecker;
+//# sourceMappingURL=NoChunkChecker.js.map

package/src/webpackPlugins/NoChunkChecker/NoChunkChecker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoChunkChecker.js","names":["NoChunkChecker","_this$_options$files","_options","arguments","length","undefined","_classCallCheck","_files","files","_createClass","key","value","apply","compiler","_this","hooks","shouldEmit","tap","compilation","chunks","forEach","chunk","file","name","runtime","_typeof","has","console","error","concat","Error","exports"],"sources":["src/webpackPlugins/NoChunkChecker/NoChunkChecker.ts"],"sourcesContent":["import { Compiler } from 'webpack';\n\nexport class NoChunkChecker {\n  private _files: string[];\n\n  constructor(private _options: { files?: string[] } = {}) {\n    this._files = this._options.files ?? [];\n  }\n\n  apply(compiler: Compiler) {\n    compiler.hooks.shouldEmit.tap('NoChunkChecker', (compilation) => {\n      let shouldEmit = true;\n      compilation.chunks.forEach((chunk) => {\n        this._files.forEach((file) => {\n          if (\n            chunk.name !== file &&\n            ((typeof chunk.runtime === 'string' && chunk.runtime === file) ||\n              (typeof chunk.runtime === 'object' && chunk.runtime.has(file)))\n          ) {\n            shouldEmit = false;\n            console.error(\n              `NoChunkChecker: entry: '${file}' found to load chunk: '${chunk.name}'`,\n            );\n          }\n        });\n      });\n      if (!shouldEmit) {\n        throw new Error('Bad chunks found!!!');\n      }\n      return shouldEmit;\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;IAEaA,cAAc;EAGzB,SAAAA,eAAA,EAAyD;IAAA,IAAAC,oBAAA;IAAA,IAArCC,QAA8B,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;IAAAG,eAAA,OAAAN,cAAA;IAAA,KAAnCE,QAA8B,GAA9BA,QAA8B;IAAA,KAF1CK,MAAM;IAGZ,IAAI,CAACA,MAAM,IAAAN,oBAAA,GAAG,IAAI,CAACC,QAAQ,CAACM,KAAK,cAAAP,oBAAA,cAAAA,oBAAA,GAAI,EAAE;EACzC;EAACQ,YAAA,CAAAT,cAAA;IAAAU,GAAA;IAAAC,KAAA,WAAAC,MAEKC,QAAkB,EAAE;MAAA,IAAAC,KAAA;MACxBD,QAAQ,CAACE,KAAK,CAACC,UAAU,CAACC,GAAG,CAAC,gBAAgB,EAAE,UAACC,WAAW,EAAK;QAC/D,IAAIF,UAAU,GAAG,IAAI;QACrBE,WAAW,CAACC,MAAM,CAACC,OAAO,CAAC,UAACC,KAAK,EAAK;UACpCP,KAAI,CAACP,MAAM,CAACa,OAAO,CAAC,UAACE,IAAI,EAAK;YAC5B,IACED,KAAK,CAACE,IAAI,KAAKD,IAAI,KACjB,OAAOD,KAAK,CAACG,OAAO,KAAK,QAAQ,IAAIH,KAAK,CAACG,OAAO,KAAKF,IAAI,IAC1DG,OAAA,CAAOJ,KAAK,CAACG,OAAO,MAAK,QAAQ,IAAIH,KAAK,CAACG,OAAO,CAACE,GAAG,CAACJ,IAAI,CAAE,CAAC,EACjE;cACAN,UAAU,GAAG,KAAK;cAClBW,OAAO,CAACC,KAAK,4BAAAC,MAAA,CACgBP,IAAI,8BAAAO,MAAA,CAA2BR,KAAK,CAACE,IAAI,MACtE,CAAC;YACH;UACF,CAAC,CAAC;QACJ,CAAC,CAAC;QACF,IAAI,CAACP,UAAU,EAAE;UACf,MAAM,IAAIc,KAAK,CAAC,qBAAqB,CAAC;QACxC;QACA,OAAOd,UAAU;MACnB,CAAC,CAAC;IACJ;EAAC;EAAA,OAAAhB,cAAA;AAAA;AAAA+B,OAAA,CAAA/B,cAAA,GAAAA,cAAA"}

package/src/webpackPlugins/NoChunkChecker/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _NoChunkChecker = require("./NoChunkChecker");
+Object.keys(_NoChunkChecker).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _NoChunkChecker[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _NoChunkChecker[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

package/src/webpackPlugins/NoChunkChecker/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_NoChunkChecker","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get"],"sources":["src/webpackPlugins/NoChunkChecker/index.ts"],"sourcesContent":["export * from './NoChunkChecker';\n"],"mappings":";;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,eAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,eAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,IAAA;MAAA,OAAAT,eAAA,CAAAK,GAAA;IAAA;EAAA;AAAA"}