@feathersjs/client
Version:
A module that consolidates Feathers client modules for REST (jQuery, Request, Superagent) and Websocket (Socket.io, Primus) connections
1,266 lines (1,147 loc) • 102 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["feathers"] = factory();
else
root["feathers"] = factory();
})(this, function() {
return /******/ (function() { // webpackBootstrap
/******/ "use strict";
/******/ var __webpack_modules__ = ({
/***/ "../../node_modules/@feathersjs/hooks/script/base.js":
/*!***********************************************************!*\
!*** ../../node_modules/@feathersjs/hooks/script/base.js ***!
\***********************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.setMiddleware = exports.getMiddleware = exports.setManager = exports.getManager = exports.convertOptions = exports.HookManager = exports.BaseHookContext = exports.HOOKS = void 0;
var utils_js_1 = __webpack_require__(/*! ./utils.js */ "../../node_modules/@feathersjs/hooks/script/utils.js");
exports.HOOKS = Symbol.for('@feathersjs/hooks');
/**
* The base hook context.
*/
var BaseHookContext = /*#__PURE__*/function () {
function BaseHookContext() {
var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
_classCallCheck(this, BaseHookContext);
Object.defineProperty(this, "self", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.assign(this, data);
}
return _createClass(BaseHookContext, [{
key: "toJSON",
value: function toJSON() {
var _this = this;
var keys = Object.keys(this);
var proto = Object.getPrototypeOf(this);
while (proto) {
keys.push.apply(keys, _toConsumableArray(Object.keys(proto)));
proto = Object.getPrototypeOf(proto);
}
return keys.reduce(function (result, key) {
result[key] = _this[key];
return result;
}, {});
}
}]);
}();
exports.BaseHookContext = BaseHookContext;
var HookManager = /*#__PURE__*/function () {
function HookManager() {
_classCallCheck(this, HookManager);
Object.defineProperty(this, "_parent", {
enumerable: true,
configurable: true,
writable: true,
value: null
});
Object.defineProperty(this, "_params", {
enumerable: true,
configurable: true,
writable: true,
value: null
});
Object.defineProperty(this, "_middleware", {
enumerable: true,
configurable: true,
writable: true,
value: null
});
Object.defineProperty(this, "_props", {
enumerable: true,
configurable: true,
writable: true,
value: null
});
Object.defineProperty(this, "_defaults", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
}
return _createClass(HookManager, [{
key: "parent",
value: function parent(_parent) {
this._parent = _parent;
return this;
}
}, {
key: "middleware",
value: function middleware(_middleware) {
this._middleware = _middleware !== null && _middleware !== void 0 && _middleware.length ? _middleware : null;
return this;
}
}, {
key: "getMiddleware",
value: function getMiddleware() {
var _this$_parent;
var previous = (_this$_parent = this._parent) === null || _this$_parent === void 0 ? void 0 : _this$_parent.getMiddleware();
if (previous && this._middleware) {
return previous.concat(this._middleware);
}
return previous || this._middleware;
}
}, {
key: "collectMiddleware",
value: function collectMiddleware(self, _args) {
var otherMiddleware = getMiddleware(self);
var middleware = this.getMiddleware();
if (otherMiddleware && middleware) {
return otherMiddleware.concat(middleware);
}
return otherMiddleware || middleware || [];
}
}, {
key: "props",
value: function props(_props) {
if (!this._props) {
this._props = {};
}
(0, utils_js_1.copyProperties)(this._props, _props);
return this;
}
}, {
key: "getProps",
value: function getProps() {
var _this$_parent2;
var previous = (_this$_parent2 = this._parent) === null || _this$_parent2 === void 0 ? void 0 : _this$_parent2.getProps();
if (previous && this._props) {
return (0, utils_js_1.copyProperties)({}, previous, this._props);
}
return previous || this._props || null;
}
}, {
key: "params",
value: function params() {
for (var _len = arguments.length, _params = new Array(_len), _key = 0; _key < _len; _key++) {
_params[_key] = arguments[_key];
}
this._params = _params;
return this;
}
}, {
key: "getParams",
value: function getParams() {
var _this$_parent3;
var previous = (_this$_parent3 = this._parent) === null || _this$_parent3 === void 0 ? void 0 : _this$_parent3.getParams();
if (previous && this._params) {
return previous.concat(this._params);
}
return previous || this._params;
}
}, {
key: "defaults",
value: function defaults(_defaults) {
this._defaults = _defaults;
return this;
}
}, {
key: "getDefaults",
value: function getDefaults(self, args, context) {
var _this$_parent4;
var defaults = typeof this._defaults === 'function' ? this._defaults(self, args, context) : null;
var previous = (_this$_parent4 = this._parent) === null || _this$_parent4 === void 0 ? void 0 : _this$_parent4.getDefaults(self, args, context);
if (previous && defaults) {
return Object.assign({}, previous, defaults);
}
return previous || defaults;
}
}, {
key: "getContextClass",
value: function getContextClass() {
var Base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : BaseHookContext;
var ContextClass = /*#__PURE__*/function (_Base) {
function ContextClass(data) {
_classCallCheck(this, ContextClass);
return _callSuper(this, ContextClass, [data]);
}
_inherits(ContextClass, _Base);
return _createClass(ContextClass);
}(Base);
var params = this.getParams();
var props = this.getProps();
if (params) {
params.forEach(function (name, index) {
if ((props === null || props === void 0 ? void 0 : props[name]) !== undefined) {
throw new Error("Hooks can not have a property and param named '".concat(name, "'. Use .defaults instead."));
}
Object.defineProperty(ContextClass.prototype, name, {
enumerable: true,
get: function get() {
return this === null || this === void 0 ? void 0 : this.arguments[index];
},
set: function set(value) {
this.arguments[index] = value;
}
});
});
}
if (props) {
(0, utils_js_1.copyProperties)(ContextClass.prototype, props);
}
return ContextClass;
}
}, {
key: "initializeContext",
value: function initializeContext(self, args, context) {
var ctx = this._parent ? this._parent.initializeContext(self, args, context) : context;
var defaults = this.getDefaults(self, args, ctx);
if (self) {
ctx.self = self;
}
ctx.arguments = args;
if (defaults) {
for (var _i = 0, _Object$keys = Object.keys(defaults); _i < _Object$keys.length; _i++) {
var name = _Object$keys[_i];
if (ctx[name] === undefined) {
ctx[name] = defaults[name];
}
}
}
return ctx;
}
}]);
}();
exports.HookManager = HookManager;
function convertOptions() {
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
if (!options) {
return new HookManager();
}
return Array.isArray(options) ? new HookManager().middleware(options) : options;
}
exports.convertOptions = convertOptions;
function getManager(target) {
return target && target[exports.HOOKS] || null;
}
exports.getManager = getManager;
function setManager(target, manager) {
var parent = getManager(target);
target[exports.HOOKS] = manager.parent(parent);
return target;
}
exports.setManager = setManager;
function getMiddleware(target) {
var manager = getManager(target);
return manager ? manager.getMiddleware() : null;
}
exports.getMiddleware = getMiddleware;
function setMiddleware(target, middleware) {
var manager = new HookManager().middleware(middleware);
return setManager(target, manager);
}
exports.setMiddleware = setMiddleware;
/***/ }),
/***/ "../../node_modules/@feathersjs/hooks/script/compose.js":
/*!**************************************************************!*\
!*** ../../node_modules/@feathersjs/hooks/script/compose.js ***!
\**************************************************************/
/***/ (function(__unused_webpack_module, exports) {
function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.compose = void 0;
function compose(middleware) {
if (!Array.isArray(middleware)) {
throw new TypeError('Middleware stack must be an array!');
}
var _iterator = _createForOfIteratorHelper(middleware),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var fn = _step.value;
if (typeof fn !== 'function') {
throw new TypeError('Middleware must be composed of functions!');
}
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
return function (context, next) {
// last called middleware #
var index = -1;
return dispatch.call(this, 0);
function dispatch(i) {
if (i <= index) {
return Promise.reject(new Error('next() called multiple times'));
}
index = i;
var fn = middleware[i];
if (i === middleware.length) {
fn = next;
}
if (!fn) {
return Promise.resolve();
}
try {
return Promise.resolve(fn.call(this, context, dispatch.bind(this, i + 1)));
} catch (err) {
return Promise.reject(err);
}
}
};
}
exports.compose = compose;
/***/ }),
/***/ "../../node_modules/@feathersjs/hooks/script/hooks.js":
/*!************************************************************!*\
!*** ../../node_modules/@feathersjs/hooks/script/hooks.js ***!
\************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.legacyDecorator = exports.hookDecorator = exports.objectHooks = exports.functionHooks = exports.getOriginal = void 0;
var compose_js_1 = __webpack_require__(/*! ./compose.js */ "../../node_modules/@feathersjs/hooks/script/compose.js");
var base_js_1 = __webpack_require__(/*! ./base.js */ "../../node_modules/@feathersjs/hooks/script/base.js");
var utils_js_1 = __webpack_require__(/*! ./utils.js */ "../../node_modules/@feathersjs/hooks/script/utils.js");
function getOriginal(fn) {
return typeof fn.original === 'function' ? getOriginal(fn.original) : fn;
}
exports.getOriginal = getOriginal;
function functionHooks(fn, managerOrMiddleware) {
if (typeof fn !== 'function') {
throw new Error('Can not apply hooks to non-function');
}
var manager = (0, base_js_1.convertOptions)(managerOrMiddleware);
var _wrapper = function wrapper() {
var _this = this;
var Context = _wrapper.Context,
original = _wrapper.original;
// If we got passed an existing HookContext instance, we want to return it as well
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var returnContext = args[args.length - 1] instanceof Context;
// Use existing context or default
var base = returnContext ? args.pop() : new Context();
// Initialize the context
var context = manager.initializeContext(this, args, base);
// Assemble the hook chain
var hookChain = [
// Return `ctx.result` or the context
function (ctx, next) {
return next().then(function () {
return returnContext ? ctx : ctx.result;
});
}];
// Create the hook chain by calling the `collectMiddleware function
var mw = manager.collectMiddleware(this, args);
if (mw) {
Array.prototype.push.apply(hookChain, mw);
}
// Runs the actual original method if `ctx.result` is not already set
hookChain.push(function (ctx, next) {
if (!Object.prototype.hasOwnProperty.call(context, 'result')) {
return Promise.resolve(original.apply(_this, ctx.arguments)).then(function (result) {
ctx.result = result;
return next();
});
}
return next();
});
return (0, compose_js_1.compose)(hookChain).call(this, context);
};
(0, utils_js_1.copyFnProperties)(_wrapper, fn);
(0, utils_js_1.copyProperties)(_wrapper, fn);
(0, base_js_1.setManager)(_wrapper, manager);
return Object.assign(_wrapper, {
original: getOriginal(fn),
Context: manager.getContextClass(),
createContext: function createContext() {
var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
return new _wrapper.Context(data);
}
});
}
exports.functionHooks = functionHooks;
function objectHooks(obj, hooks) {
if (Array.isArray(hooks)) {
return (0, base_js_1.setMiddleware)(obj, hooks);
}
for (var _i = 0, _Object$keys = Object.keys(hooks); _i < _Object$keys.length; _i++) {
var method = _Object$keys[_i];
var target = typeof obj[method] === 'function' ? obj : obj.prototype;
var fn = target && target[method];
if (typeof fn !== 'function') {
throw new Error("Can not apply hooks. '".concat(method, "' is not a function"));
}
var manager = (0, base_js_1.convertOptions)(hooks[method]);
target[method] = functionHooks(fn, manager.props({
method: method
}));
}
return obj;
}
exports.objectHooks = objectHooks;
var hookDecorator = function hookDecorator(managerOrMiddleware) {
return function (target, context) {
var manager = (0, base_js_1.convertOptions)(managerOrMiddleware);
if (context.kind === 'class') {
(0, base_js_1.setManager)(target.prototype, manager);
return target;
} else if (context.kind === 'method') {
var method = String(context.name);
return functionHooks(target, manager.props({
method: method
}));
}
throw new Error('Can not apply hooks.');
};
};
exports.hookDecorator = hookDecorator;
var legacyDecorator = function legacyDecorator(managerOrMiddleware) {
var wrapper = function wrapper(_target, method, descriptor) {
var manager = (0, base_js_1.convertOptions)(managerOrMiddleware);
if (!descriptor) {
(0, base_js_1.setManager)(_target.prototype, manager);
return _target;
}
var fn = descriptor.value;
if (typeof fn !== 'function') {
throw new Error("Can not apply hooks. '".concat(method, "' is not a function"));
}
descriptor.value = functionHooks(fn, manager.props({
method: method
}));
return descriptor;
};
return wrapper;
};
exports.legacyDecorator = legacyDecorator;
/***/ }),
/***/ "../../node_modules/@feathersjs/hooks/script/index.js":
/*!************************************************************!*\
!*** ../../node_modules/@feathersjs/hooks/script/index.js ***!
\************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = {
enumerable: true,
get: function get() {
return m[k];
}
};
}
Object.defineProperty(o, k2, desc);
} : function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
var __exportStar = this && this.__exportStar || function (m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.hooks = exports.middleware = void 0;
var base_js_1 = __webpack_require__(/*! ./base.js */ "../../node_modules/@feathersjs/hooks/script/base.js");
var hooks_js_1 = __webpack_require__(/*! ./hooks.js */ "../../node_modules/@feathersjs/hooks/script/hooks.js");
__exportStar(__webpack_require__(/*! ./hooks.js */ "../../node_modules/@feathersjs/hooks/script/hooks.js"), exports);
__exportStar(__webpack_require__(/*! ./compose.js */ "../../node_modules/@feathersjs/hooks/script/compose.js"), exports);
__exportStar(__webpack_require__(/*! ./base.js */ "../../node_modules/@feathersjs/hooks/script/base.js"), exports);
__exportStar(__webpack_require__(/*! ./regular.js */ "../../node_modules/@feathersjs/hooks/script/regular.js"), exports);
/**
* Initializes a hook settings object with the given middleware.
* @param mw The list of middleware
* @param options Middleware options (params, default, props)
*/
function middleware(mw, options) {
var manager = new base_js_1.HookManager().middleware(mw);
if (options) {
if (options.params) {
manager.params.apply(manager, _toConsumableArray(options.params));
}
if (options.defaults) {
manager.defaults(options.defaults);
}
if (options.props) {
manager.props(options.props);
}
}
return manager;
}
exports.middleware = middleware;
// Fallthrough to actual implementation
function hooks() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var target = args[0],
_hooks = args[1];
if (typeof target === 'function' && (_hooks instanceof base_js_1.HookManager || Array.isArray(_hooks) || args.length === 1)) {
return (0, hooks_js_1.functionHooks)(target, _hooks);
}
if (args.length === 2) {
return (0, hooks_js_1.objectHooks)(target, _hooks);
}
return (0, hooks_js_1.hookDecorator)(target);
}
exports.hooks = hooks;
/***/ }),
/***/ "../../node_modules/@feathersjs/hooks/script/regular.js":
/*!**************************************************************!*\
!*** ../../node_modules/@feathersjs/hooks/script/regular.js ***!
\**************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.collect = exports.fromErrorHook = exports.fromAfterHook = exports.fromBeforeHook = exports.runHooks = exports.runHook = void 0;
var compose_js_1 = __webpack_require__(/*! ./compose.js */ "../../node_modules/@feathersjs/hooks/script/compose.js");
var runHook = function runHook(hook, context, type) {
var typeBefore = context.type;
if (type) context.type = type;
return Promise.resolve(hook.call(context.self, context)).then(function (res) {
if (type) context.type = typeBefore;
if (res && res !== context) {
Object.assign(context, res);
}
});
};
exports.runHook = runHook;
var runHooks = function runHooks(hooks) {
return function (context) {
return hooks.reduce(function (promise, hook) {
return promise.then(function () {
return (0, exports.runHook)(hook, context);
});
}, Promise.resolve(context));
};
};
exports.runHooks = runHooks;
function fromBeforeHook(hook) {
return function (context, next) {
return (0, exports.runHook)(hook, context, 'before').then(next);
};
}
exports.fromBeforeHook = fromBeforeHook;
function fromAfterHook(hook) {
return function (context, next) {
return next().then(function () {
return (0, exports.runHook)(hook, context, 'after');
});
};
}
exports.fromAfterHook = fromAfterHook;
function fromErrorHook(hook) {
return function (context, next) {
return next().catch(function (error) {
if (context.error !== error || context.result !== undefined) {
context.original = _objectSpread({}, context);
context.error = error;
delete context.result;
}
return (0, exports.runHook)(hook, context, 'error').then(function () {
if (context.result === undefined && context.error !== undefined) {
throw context.error;
}
}).catch(function (error) {
context.error = error;
throw context.error;
});
});
};
}
exports.fromErrorHook = fromErrorHook;
function collect(_ref) {
var _ref$before = _ref.before,
before = _ref$before === void 0 ? [] : _ref$before,
_ref$after = _ref.after,
after = _ref$after === void 0 ? [] : _ref$after,
_ref$error = _ref.error,
error = _ref$error === void 0 ? [] : _ref$error;
var beforeHooks = before.map(fromBeforeHook);
var afterHooks = _toConsumableArray(after).reverse().map(fromAfterHook);
var errorHooks = error.length ? [fromErrorHook((0, exports.runHooks)(error))] : [];
return (0, compose_js_1.compose)([].concat(errorHooks, _toConsumableArray(beforeHooks), _toConsumableArray(afterHooks)));
}
exports.collect = collect;
/***/ }),
/***/ "../../node_modules/@feathersjs/hooks/script/utils.js":
/*!************************************************************!*\
!*** ../../node_modules/@feathersjs/hooks/script/utils.js ***!
\************************************************************/
/***/ (function(__unused_webpack_module, exports) {
function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.copyFnProperties = exports.copyProperties = void 0;
function copyProperties(target) {
for (var _len = arguments.length, originals = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
originals[_key - 1] = arguments[_key];
}
for (var _i = 0, _originals = originals; _i < _originals.length; _i++) {
var original = _originals[_i];
var originalProps = Object.keys(original).concat(Object.getOwnPropertySymbols(original));
var _iterator = _createForOfIteratorHelper(originalProps),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var prop = _step.value;
var propDescriptor = Object.getOwnPropertyDescriptor(original, prop);
if (propDescriptor && !Object.prototype.hasOwnProperty.call(target, prop)) {
Object.defineProperty(target, prop, propDescriptor);
}
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
}
return target;
}
exports.copyProperties = copyProperties;
function copyFnProperties(target, original) {
var internalProps = ['name', 'length'];
try {
for (var _i2 = 0, _internalProps = internalProps; _i2 < _internalProps.length; _i2++) {
var prop = _internalProps[_i2];
var value = original[prop];
Object.defineProperty(target, prop, {
value: value
});
}
} catch (_e) {
// Avoid IE error
}
return target;
}
exports.copyFnProperties = copyFnProperties;
/***/ }),
/***/ "../../node_modules/events/events.js":
/*!*******************************************!*\
!*** ../../node_modules/events/events.js ***!
\*******************************************/
/***/ (function(module) {
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var R = typeof Reflect === 'object' ? Reflect : null
var ReflectApply = R && typeof R.apply === 'function'
? R.apply
: function ReflectApply(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
}
var ReflectOwnKeys
if (R && typeof R.ownKeys === 'function') {
ReflectOwnKeys = R.ownKeys
} else if (Object.getOwnPropertySymbols) {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target)
.concat(Object.getOwnPropertySymbols(target));
};
} else {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target);
};
}
function ProcessEmitWarning(warning) {
if (console && console.warn) console.warn(warning);
}
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
return value !== value;
}
function EventEmitter() {
EventEmitter.init.call(this);
}
module.exports = EventEmitter;
module.exports.once = once;
// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._eventsCount = 0;
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== 'function') {
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
}
}
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
}
defaultMaxListeners = arg;
}
});
EventEmitter.init = function() {
if (this._events === undefined ||
this._events === Object.getPrototypeOf(this)._events) {
this._events = Object.create(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || undefined;
};
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
}
this._maxListeners = n;
return this;
};
function _getMaxListeners(that) {
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
return _getMaxListeners(this);
};
EventEmitter.prototype.emit = function emit(type) {
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = (type === 'error');
var events = this._events;
if (events !== undefined)
doError = (doError && events.error === undefined);
else if (!doError)
return false;
// If there is no 'error' event listener then throw.
if (doError) {
var er;
if (args.length > 0)
er = args[0];
if (er instanceof Error) {
// Note: The comments on the `throw` lines are intentional, they show
// up in Node's output if this results in an unhandled exception.
throw er; // Unhandled 'error' event
}
// At least give some kind of context to the user
var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
err.context = er;
throw err; // Unhandled 'error' event
}
var handler = events[type];
if (handler === undefined)
return false;
if (typeof handler === 'function') {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
ReflectApply(listeners[i], this, args);
}
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
checkListener(listener);
events = target._events;
if (events === undefined) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} else {
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener !== undefined) {
target.emit('newListener', type,
listener.listener ? listener.listener : listener);
// Re-assign `events` because a newListener handler could have caused the
// this._events to be assigned to a new object
events = target._events;
}
existing = events[type];
}
if (existing === undefined) {
// Optimize the case of one listener. Don't need the extra array object.
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
// Adding the second element, need to change to array.
existing = events[type] =
prepend ? [listener, existing] : [existing, listener];
// If we've already got an array, just append.
} else if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
// Check for listener leak
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
// No error code for this since it is a Warning
// eslint-disable-next-line no-restricted-syntax
var w = new Error('Possible EventEmitter memory leak detected. ' +
existing.length + ' ' + String(type) + ' listeners ' +
'added. Use emitter.setMaxListeners() to ' +
'increase limit');
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.prependListener =
function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0)
return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter.prototype.once = function once(type, listener) {
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener =
function prependOnceListener(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
var list, events, position, i, originalListener;
checkListener(listener);
events = this._events;
if (events === undefined)
return this;
list = events[type];
if (list === undefined)
return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else {
delete events[type];
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
}
} else if (typeof list !== 'function') {
position = -1;
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
}
if (position < 0)
return this;
if (position === 0)
list.shift();
else {
spliceOne(list, position);
}
if (list.length === 1)
events[type] = list[0];
if (events.removeListener !== undefined)
this.emit('removeListener', type, originalListener || listener);
}
return this;
};
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.removeAllListeners =
function removeAllListeners(type) {
var listeners, events, i;
events = this._events;
if (events === undefined)
return this;
// not listening for removeListener, no need to emit
if (events.removeListener === undefined) {
if (arguments.length === 0) {
this._events = Object.create(null);
this._eventsCount = 0;
} else if (events[type] !== undefined) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else
delete events[type];
}
return this;
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
var keys = Object.keys(events);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = Object.create(null);
this._eventsCount = 0;
return this;
}
listeners = events[type];
if (typeof listeners === 'function') {
this.removeListener(type, listeners);
} else if (listeners !== undefined) {
// LIFO order
for (i = listeners.length - 1; i >= 0; i--) {
this.removeListener(type, listeners[i]);
}
}
return this;
};
function _listeners(target, type, unwrap) {
var events = target._events;
if (events === undefined)
return [];
var evlistener = events[type];
if (evlistener === undefined)
return [];
if (typeof evlistener === 'function')
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ?
unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}
EventEmitter.prototype.listeners = function listeners(type) {
return _listeners(this, type, true);
};
EventEmitter.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
};
EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};
EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
if (events !== undefined) {
var evlistener = events[type];
if (typeof evlistener === 'function') {
return 1;
} else if (evlistener !== undefined) {
return evlistener.length;
}
}
return 0;
}
EventEmitter.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
};
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
}
function spliceOne(list, index) {
for (; index + 1 < list.length; index++)
list[index] = list[index + 1];
list.pop();
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
function once(emitter, name) {
return new Promise(function (resolve, reject) {
function errorListener(err) {
emitter.removeListener(name, resolver);
reject(err);
}
function resolver() {
if (typeof emitter.removeListener === 'function') {
emitter.removeListener('error', errorListener);
}
resolve([].slice.call(arguments));
};
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== 'error') {
addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
}
});
}
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === 'function') {
eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
}
}
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === 'function') {
if (flags.once) {
emitter.once(name, listener);
} else {
emitter.on(name, listener);
}
} else if (typeof emitter.addEventListener === 'function') {
// EventTarget does not have `error` event semantics like Node
// EventEmitters, we do not listen for `error` events here.
emitter.addEventListener(name, function wrapListener(arg) {
// IE does not have builtin `{ once: true }` support so we
// have to do it manually.
if (flags.once) {
emitter.removeEventListener(name, wrapListener);
}
listener(arg);
});
} else {
throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
}
}
/***/ }),
/***/ "../commons/lib/debug.js":
/*!*******************************!*\
!*** ../commons/lib/debug.js ***!
\*******************************/
/***/ (function(__unused_webpack_module, exports) {
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.noopDebug = noopDebug;
exports.setDebug = setDebug;
exports.createDebug = createDebug;
var debuggers = {};
function noopDebug() {
return function () {};
}
var defaultInitializer = noopDebug;
function setDebug(debug) {
defaultInitializer = debug;
Object.keys(debuggers).forEach(function (name) {
debuggers[name] = debug(name);
});
}
function createDebug(name) {
if (!debuggers[name]) {
debuggers[name] = defaultInitializer(name);
}
return function () {
return debuggers[name].apply(debuggers, arguments);
};
}
/***/ }),
/***/ "../commons/lib/index.js":
/*!******************************