@medipass/utils 11.84.8 → 11.84.9-chore-add-manual-pify.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medipass/utils",
-  "version": "11.84.8",
+  "version": "11.84.9-chore-add-manual-pify.0",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -47,5 +47,5 @@
     "rimraf": "^2.6.2",
     "typescript": "4.8.4"
   },
-  "gitHead": "efa4f79b05115a1173f22f7e3a24613de1b850be"
+  "gitHead": "b440b9a5835390ed72aea0208ff2d845ae92e8a7"
 }

package/pify/index.d.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/pify/index.d.ts

@@ -0,0 +1 @@
+export default function pify(input: any, options: any): any;

package/pify/index.js

@@ -0,0 +1,139 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var processFunction = function processFunction(function_, options, proxy, unwrapped) {
+  return function () {
+    var _this = this;
+
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+
+    var P = options.promiseModule;
+    return new P(function (resolve, reject) {
+      if (options.multiArgs) {
+        arguments_.push(function () {
+          for (var _len2 = arguments.length, result = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            result[_key2] = arguments[_key2];
+          }
+
+          if (options.errorFirst) {
+            if (result[0]) {
+              reject(result);
+            } else {
+              result.shift();
+              resolve(result);
+            }
+          } else {
+            resolve(result);
+          }
+        });
+      } else if (options.errorFirst) {
+        arguments_.push(function (error, result) {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(result);
+          }
+        });
+      } else {
+        arguments_.push(resolve);
+      }
+
+      var self = _this === proxy ? unwrapped : _this;
+      Reflect.apply(function_, self, arguments_);
+    });
+  };
+};
+
+var filterCache = new WeakMap();
+function pify(input, options) {
+  options = _objectSpread({
+    exclude: [/.+(?:Sync|Stream)$/],
+    errorFirst: true,
+    promiseModule: Promise
+  }, options);
+  var objectType = typeof input;
+
+  if (!(input !== null && (objectType === 'object' || objectType === 'function'))) {
+    throw new TypeError("Expected `input` to be a `Function` or `Object`, got `" + (input === null ? 'null' : objectType) + "`");
+  }
+
+  var filter = function filter(target, key) {
+    var cached = filterCache.get(target);
+
+    if (!cached) {
+      cached = {};
+      filterCache.set(target, cached);
+    }
+
+    if (key in cached) {
+      return cached[key];
+    }
+
+    var match = function match(pattern) {
+      return typeof pattern === 'string' || typeof key === 'symbol' ? key === pattern : pattern.test(key);
+    };
+
+    var descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+    var writableOrConfigurableOwn = descriptor === undefined || descriptor.writable || descriptor.configurable;
+    var included = options.include ? options.include.some(function (element) {
+      return match(element);
+    }) : !options.exclude.some(function (element) {
+      return match(element);
+    });
+    var shouldFilter = included && writableOrConfigurableOwn;
+    cached[key] = shouldFilter;
+    return shouldFilter;
+  };
+
+  var cache = new WeakMap();
+  var proxy = new Proxy(input, {
+    apply: function apply(target, thisArg, args) {
+      var cached = cache.get(target);
+
+      if (cached) {
+        return Reflect.apply(cached, thisArg, args);
+      }
+
+      var pified = options.excludeMain ? target : processFunction(target, options, proxy, target);
+      cache.set(target, pified);
+      return Reflect.apply(pified, thisArg, args);
+    },
+    get: function get(target, key) {
+      var property = target[key];
+
+      if (!filter(target, key) || property === Function.prototype[key]) {
+        return property;
+      }
+
+      var cached = cache.get(property);
+
+      if (cached) {
+        return cached;
+      }
+
+      if (typeof property === 'function') {
+        var pified = processFunction(property, options, proxy, target);
+        cache.set(property, pified);
+        return pified;
+      }
+
+      return property;
+    }
+  });
+  return proxy;
+}
+
+exports["default"] = pify;