@common.js/node-fetch 3.3.2

package/src/response.js

@@ -0,0 +1,382 @@
+/**
+ * Response.js
+ *
+ * Response class provides content decoding
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Response;
+    }
+});
+var _headersJs = /*#__PURE__*/ _interopRequireDefault(require("./headers.js"));
+var _bodyJs = /*#__PURE__*/ _interopRequireWildcard(require("./body.js"));
+var _isRedirectJs = require("./utils/is-redirect.js");
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+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, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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);
+}
+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;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+var INTERNALS = Symbol("Response internals");
+var Response = /*#__PURE__*/ function(Body) {
+    "use strict";
+    _inherits(Response, Body);
+    var _super = _createSuper(Response);
+    function Response() {
+        var body = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null, options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        _classCallCheck(this, Response);
+        var _this;
+        _this = _super.call(this, body, options);
+        // eslint-disable-next-line no-eq-null, eqeqeq, no-negated-condition
+        var status = options.status != null ? options.status : 200;
+        var headers = new _headersJs.default(options.headers);
+        if (body !== null && !headers.has("Content-Type")) {
+            var contentType = (0, _bodyJs.extractContentType)(body, _assertThisInitialized(_this));
+            if (contentType) {
+                headers.append("Content-Type", contentType);
+            }
+        }
+        _this[INTERNALS] = {
+            type: "default",
+            url: options.url,
+            status: status,
+            statusText: options.statusText || "",
+            headers: headers,
+            counter: options.counter,
+            highWaterMark: options.highWaterMark
+        };
+        return _this;
+    }
+    _createClass(Response, [
+        {
+            key: "type",
+            get: function get() {
+                return this[INTERNALS].type;
+            }
+        },
+        {
+            key: "url",
+            get: function get() {
+                return this[INTERNALS].url || "";
+            }
+        },
+        {
+            key: "status",
+            get: function get() {
+                return this[INTERNALS].status;
+            }
+        },
+        {
+            key: "ok",
+            get: /**
+	 * Convenience property representing if the request ended normally
+	 */ function get() {
+                return this[INTERNALS].status >= 200 && this[INTERNALS].status < 300;
+            }
+        },
+        {
+            key: "redirected",
+            get: function get() {
+                return this[INTERNALS].counter > 0;
+            }
+        },
+        {
+            key: "statusText",
+            get: function get() {
+                return this[INTERNALS].statusText;
+            }
+        },
+        {
+            key: "headers",
+            get: function get() {
+                return this[INTERNALS].headers;
+            }
+        },
+        {
+            key: "highWaterMark",
+            get: function get() {
+                return this[INTERNALS].highWaterMark;
+            }
+        },
+        {
+            /**
+	 * Clone this response
+	 *
+	 * @return  Response
+	 */ key: "clone",
+            value: function clone() {
+                return new Response((0, _bodyJs.clone)(this, this.highWaterMark), {
+                    type: this.type,
+                    url: this.url,
+                    status: this.status,
+                    statusText: this.statusText,
+                    headers: this.headers,
+                    ok: this.ok,
+                    redirected: this.redirected,
+                    size: this.size,
+                    highWaterMark: this.highWaterMark
+                });
+            }
+        },
+        {
+            key: Symbol.toStringTag,
+            get: function get() {
+                return "Response";
+            }
+        }
+    ], [
+        {
+            key: "redirect",
+            value: /**
+	 * @param {string} url    The URL that the new response is to originate from.
+	 * @param {number} status An optional status code for the response (e.g., 302.)
+	 * @returns {Response}    A Response object.
+	 */ function redirect(url) {
+                var status = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 302;
+                if (!(0, _isRedirectJs.isRedirect)(status)) {
+                    throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
+                }
+                return new Response(null, {
+                    headers: {
+                        location: new URL(url).toString()
+                    },
+                    status: status
+                });
+            }
+        },
+        {
+            key: "error",
+            value: function error() {
+                var response = new Response(null, {
+                    status: 0,
+                    statusText: ""
+                });
+                response[INTERNALS].type = "error";
+                return response;
+            }
+        },
+        {
+            key: "json",
+            value: function json() {
+                var data = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : undefined, init = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+                var body = JSON.stringify(data);
+                if (body === undefined) {
+                    throw new TypeError("data is not JSON serializable");
+                }
+                var headers = new _headersJs.default(init && init.headers);
+                if (!headers.has("content-type")) {
+                    headers.set("content-type", "application/json");
+                }
+                return new Response(body, _objectSpreadProps(_objectSpread({}, init), {
+                    headers: headers
+                }));
+            }
+        }
+    ]);
+    return Response;
+}(_bodyJs.default);
+Object.defineProperties(Response.prototype, {
+    type: {
+        enumerable: true
+    },
+    url: {
+        enumerable: true
+    },
+    status: {
+        enumerable: true
+    },
+    ok: {
+        enumerable: true
+    },
+    redirected: {
+        enumerable: true
+    },
+    statusText: {
+        enumerable: true
+    },
+    headers: {
+        enumerable: true
+    },
+    clone: {
+        enumerable: true
+    }
+});

package/src/utils/get-search.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getSearch", {
+    enumerable: true,
+    get: function() {
+        return getSearch;
+    }
+});
+var getSearch = function(parsedURL) {
+    if (parsedURL.search) {
+        return parsedURL.search;
+    }
+    var lastOffset = parsedURL.href.length - 1;
+    var hash = parsedURL.hash || (parsedURL.href[lastOffset] === "#" ? "#" : "");
+    return parsedURL.href[lastOffset - hash.length] === "?" ? "?" : "";
+};

package/src/utils/is-redirect.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isRedirect", {
+    enumerable: true,
+    get: function() {
+        return isRedirect;
+    }
+});
+var redirectStatus = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+var isRedirect = function(code) {
+    return redirectStatus.has(code);
+};

package/src/utils/is.js

@@ -0,0 +1,51 @@
+/**
+ * Is.js
+ *
+ * Object type checks.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isURLSearchParameters: function() {
+        return isURLSearchParameters;
+    },
+    isBlob: function() {
+        return isBlob;
+    },
+    isAbortSignal: function() {
+        return isAbortSignal;
+    },
+    isDomainOrSubdomain: function() {
+        return isDomainOrSubdomain;
+    },
+    isSameProtocol: function() {
+        return isSameProtocol;
+    }
+});
+var NAME = Symbol.toStringTag;
+var isURLSearchParameters = function(object) {
+    return typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && typeof object.sort === "function" && object[NAME] === "URLSearchParams";
+};
+var isBlob = function(object) {
+    return object && typeof object === "object" && typeof object.arrayBuffer === "function" && typeof object.type === "string" && typeof object.stream === "function" && typeof object.constructor === "function" && /^(Blob|File)$/.test(object[NAME]);
+};
+var isAbortSignal = function(object) {
+    return typeof object === "object" && (object[NAME] === "AbortSignal" || object[NAME] === "EventTarget");
+};
+var isDomainOrSubdomain = function(destination, original) {
+    var orig = new URL(original).hostname;
+    var dest = new URL(destination).hostname;
+    return orig === dest || orig.endsWith(".".concat(dest));
+};
+var isSameProtocol = function(destination, original) {
+    var orig = new URL(original).protocol;
+    var dest = new URL(destination).protocol;
+    return orig === dest;
+};