vdi-ngify-http
Version:
vdi plugin for ngify-http
1,620 lines • 61.4 kB
JavaScript
import { createIdentifier, Many, Optional } from "@wendellhu/redi";
import { of, concatMap, switchMap, from, map, catchError, throwError, Observable as Observable$1, filter } from "rxjs";
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2)
if (Object.prototype.hasOwnProperty.call(b2, p))
d2[p] = b2[p];
};
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign2(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function(resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() {
if (t[0] & 1)
throw t[1];
return t[1];
}, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
return this;
}), g;
function verb(n) {
return function(v) {
return step([n, v]);
};
}
function step(op) {
if (f)
throw new TypeError("Generator is already executing.");
while (_)
try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2])
_.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [6, e];
y = 0;
} finally {
f = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m)
return m.call(o);
if (o && typeof o.length === "number")
return {
next: function() {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
} catch (error) {
e = { error };
} finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
} finally {
if (e)
throw e.error;
}
}
return ar;
}
function __spreadArray(to, from2, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from2.length, ar; i < l; i++) {
if (ar || !(i in from2)) {
if (!ar)
ar = Array.prototype.slice.call(from2, 0, i);
ar[i] = from2[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from2));
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
return this;
}, i;
function verb(n) {
if (g[n])
i[n] = function(v) {
return new Promise(function(a, b) {
q.push([n, v, a, b]) > 1 || resume(n, v);
});
};
}
function resume(n, v) {
try {
step(g[n](v));
} catch (e) {
settle(q[0][3], e);
}
}
function step(r) {
r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
}
function fulfill(value) {
resume("next", value);
}
function reject(value) {
resume("throw", value);
}
function settle(f, v) {
if (f(v), q.shift(), q.length)
resume(q[0][0], q[0][1]);
}
}
function __asyncValues(o) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
return this;
}, i);
function verb(n) {
i[n] = o[n] && function(v) {
return new Promise(function(resolve, reject) {
v = o[n](v), settle(resolve, reject, v.done, v.value);
});
};
}
function settle(resolve, reject, d, v) {
Promise.resolve(v).then(function(v2) {
resolve({ value: v2, done: d });
}, reject);
}
}
function isFunction(value) {
return typeof value === "function";
}
function createErrorClass(createImpl) {
var _super = function(instance) {
Error.call(instance);
instance.stack = new Error().stack;
};
var ctorFunc = createImpl(_super);
ctorFunc.prototype = Object.create(Error.prototype);
ctorFunc.prototype.constructor = ctorFunc;
return ctorFunc;
}
var UnsubscriptionError = createErrorClass(function(_super) {
return function UnsubscriptionErrorImpl(errors) {
_super(this);
this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
return i + 1 + ") " + err.toString();
}).join("\n ") : "";
this.name = "UnsubscriptionError";
this.errors = errors;
};
});
function arrRemove(arr, item) {
if (arr) {
var index = arr.indexOf(item);
0 <= index && arr.splice(index, 1);
}
}
var Subscription = function() {
function Subscription2(initialTeardown) {
this.initialTeardown = initialTeardown;
this.closed = false;
this._parentage = null;
this._finalizers = null;
}
Subscription2.prototype.unsubscribe = function() {
var e_1, _a, e_2, _b;
var errors;
if (!this.closed) {
this.closed = true;
var _parentage = this._parentage;
if (_parentage) {
this._parentage = null;
if (Array.isArray(_parentage)) {
try {
for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
var parent_1 = _parentage_1_1.value;
parent_1.remove(this);
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return))
_a.call(_parentage_1);
} finally {
if (e_1)
throw e_1.error;
}
}
} else {
_parentage.remove(this);
}
}
var initialFinalizer = this.initialTeardown;
if (isFunction(initialFinalizer)) {
try {
initialFinalizer();
} catch (e) {
errors = e instanceof UnsubscriptionError ? e.errors : [e];
}
}
var _finalizers = this._finalizers;
if (_finalizers) {
this._finalizers = null;
try {
for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
var finalizer = _finalizers_1_1.value;
try {
execFinalizer(finalizer);
} catch (err) {
errors = errors !== null && errors !== void 0 ? errors : [];
if (err instanceof UnsubscriptionError) {
errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
} else {
errors.push(err);
}
}
}
} catch (e_2_1) {
e_2 = { error: e_2_1 };
} finally {
try {
if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return))
_b.call(_finalizers_1);
} finally {
if (e_2)
throw e_2.error;
}
}
}
if (errors) {
throw new UnsubscriptionError(errors);
}
}
};
Subscription2.prototype.add = function(teardown) {
var _a;
if (teardown && teardown !== this) {
if (this.closed) {
execFinalizer(teardown);
} else {
if (teardown instanceof Subscription2) {
if (teardown.closed || teardown._hasParent(this)) {
return;
}
teardown._addParent(this);
}
(this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
}
}
};
Subscription2.prototype._hasParent = function(parent) {
var _parentage = this._parentage;
return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
};
Subscription2.prototype._addParent = function(parent) {
var _parentage = this._parentage;
this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
};
Subscription2.prototype._removeParent = function(parent) {
var _parentage = this._parentage;
if (_parentage === parent) {
this._parentage = null;
} else if (Array.isArray(_parentage)) {
arrRemove(_parentage, parent);
}
};
Subscription2.prototype.remove = function(teardown) {
var _finalizers = this._finalizers;
_finalizers && arrRemove(_finalizers, teardown);
if (teardown instanceof Subscription2) {
teardown._removeParent(this);
}
};
Subscription2.EMPTY = function() {
var empty = new Subscription2();
empty.closed = true;
return empty;
}();
return Subscription2;
}();
Subscription.EMPTY;
function isSubscription(value) {
return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
}
function execFinalizer(finalizer) {
if (isFunction(finalizer)) {
finalizer();
} else {
finalizer.unsubscribe();
}
}
var config$1 = {
onUnhandledError: null,
onStoppedNotification: null,
Promise: void 0,
useDeprecatedSynchronousErrorHandling: false,
useDeprecatedNextContext: false
};
var timeoutProvider = {
setTimeout: function(handler, timeout) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
var delegate = timeoutProvider.delegate;
if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)));
}
return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
},
clearTimeout: function(handle) {
var delegate = timeoutProvider.delegate;
return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
},
delegate: void 0
};
function reportUnhandledError(err) {
timeoutProvider.setTimeout(function() {
{
throw err;
}
});
}
function noop() {
}
function errorContext(cb) {
{
cb();
}
}
var Subscriber = function(_super) {
__extends(Subscriber2, _super);
function Subscriber2(destination) {
var _this = _super.call(this) || this;
_this.isStopped = false;
if (destination) {
_this.destination = destination;
if (isSubscription(destination)) {
destination.add(_this);
}
} else {
_this.destination = EMPTY_OBSERVER;
}
return _this;
}
Subscriber2.create = function(next, error, complete) {
return new SafeSubscriber(next, error, complete);
};
Subscriber2.prototype.next = function(value) {
if (this.isStopped)
;
else {
this._next(value);
}
};
Subscriber2.prototype.error = function(err) {
if (this.isStopped)
;
else {
this.isStopped = true;
this._error(err);
}
};
Subscriber2.prototype.complete = function() {
if (this.isStopped)
;
else {
this.isStopped = true;
this._complete();
}
};
Subscriber2.prototype.unsubscribe = function() {
if (!this.closed) {
this.isStopped = true;
_super.prototype.unsubscribe.call(this);
this.destination = null;
}
};
Subscriber2.prototype._next = function(value) {
this.destination.next(value);
};
Subscriber2.prototype._error = function(err) {
try {
this.destination.error(err);
} finally {
this.unsubscribe();
}
};
Subscriber2.prototype._complete = function() {
try {
this.destination.complete();
} finally {
this.unsubscribe();
}
};
return Subscriber2;
}(Subscription);
var _bind = Function.prototype.bind;
function bind(fn, thisArg) {
return _bind.call(fn, thisArg);
}
var ConsumerObserver = function() {
function ConsumerObserver2(partialObserver) {
this.partialObserver = partialObserver;
}
ConsumerObserver2.prototype.next = function(value) {
var partialObserver = this.partialObserver;
if (partialObserver.next) {
try {
partialObserver.next(value);
} catch (error) {
handleUnhandledError(error);
}
}
};
ConsumerObserver2.prototype.error = function(err) {
var partialObserver = this.partialObserver;
if (partialObserver.error) {
try {
partialObserver.error(err);
} catch (error) {
handleUnhandledError(error);
}
} else {
handleUnhandledError(err);
}
};
ConsumerObserver2.prototype.complete = function() {
var partialObserver = this.partialObserver;
if (partialObserver.complete) {
try {
partialObserver.complete();
} catch (error) {
handleUnhandledError(error);
}
}
};
return ConsumerObserver2;
}();
var SafeSubscriber = function(_super) {
__extends(SafeSubscriber2, _super);
function SafeSubscriber2(observerOrNext, error, complete) {
var _this = _super.call(this) || this;
var partialObserver;
if (isFunction(observerOrNext) || !observerOrNext) {
partialObserver = {
next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
error: error !== null && error !== void 0 ? error : void 0,
complete: complete !== null && complete !== void 0 ? complete : void 0
};
} else {
var context_1;
if (_this && config$1.useDeprecatedNextContext) {
context_1 = Object.create(observerOrNext);
context_1.unsubscribe = function() {
return _this.unsubscribe();
};
partialObserver = {
next: observerOrNext.next && bind(observerOrNext.next, context_1),
error: observerOrNext.error && bind(observerOrNext.error, context_1),
complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
};
} else {
partialObserver = observerOrNext;
}
}
_this.destination = new ConsumerObserver(partialObserver);
return _this;
}
return SafeSubscriber2;
}(Subscriber);
function handleUnhandledError(error) {
{
reportUnhandledError(error);
}
}
function defaultErrorHandler(err) {
throw err;
}
var EMPTY_OBSERVER = {
closed: true,
next: noop,
error: defaultErrorHandler,
complete: noop
};
function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
}
var OperatorSubscriber = function(_super) {
__extends(OperatorSubscriber2, _super);
function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
var _this = _super.call(this, destination) || this;
_this.onFinalize = onFinalize;
_this.shouldUnsubscribe = shouldUnsubscribe;
_this._next = onNext ? function(value) {
try {
onNext(value);
} catch (err) {
destination.error(err);
}
} : _super.prototype._next;
_this._error = onError ? function(err) {
try {
onError(err);
} catch (err2) {
destination.error(err2);
} finally {
this.unsubscribe();
}
} : _super.prototype._error;
_this._complete = onComplete ? function() {
try {
onComplete();
} catch (err) {
destination.error(err);
} finally {
this.unsubscribe();
}
} : _super.prototype._complete;
return _this;
}
OperatorSubscriber2.prototype.unsubscribe = function() {
var _a;
if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
var closed_1 = this.closed;
_super.prototype.unsubscribe.call(this);
!closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
}
};
return OperatorSubscriber2;
}(Subscriber);
var observable = function() {
return typeof Symbol === "function" && Symbol.observable || "@@observable";
}();
function identity(x) {
return x;
}
function pipeFromArray(fns) {
if (fns.length === 0) {
return identity;
}
if (fns.length === 1) {
return fns[0];
}
return function piped(input) {
return fns.reduce(function(prev, fn) {
return fn(prev);
}, input);
};
}
var Observable = function() {
function Observable2(subscribe) {
if (subscribe) {
this._subscribe = subscribe;
}
}
Observable2.prototype.lift = function(operator) {
var observable2 = new Observable2();
observable2.source = this;
observable2.operator = operator;
return observable2;
};
Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
var _this = this;
var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
errorContext(function() {
var _a = _this, operator = _a.operator, source = _a.source;
subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
});
return subscriber;
};
Observable2.prototype._trySubscribe = function(sink) {
try {
return this._subscribe(sink);
} catch (err) {
sink.error(err);
}
};
Observable2.prototype.forEach = function(next, promiseCtor) {
var _this = this;
promiseCtor = getPromiseCtor(promiseCtor);
return new promiseCtor(function(resolve, reject) {
var subscriber = new SafeSubscriber({
next: function(value) {
try {
next(value);
} catch (err) {
reject(err);
subscriber.unsubscribe();
}
},
error: reject,
complete: resolve
});
_this.subscribe(subscriber);
});
};
Observable2.prototype._subscribe = function(subscriber) {
var _a;
return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
};
Observable2.prototype[observable] = function() {
return this;
};
Observable2.prototype.pipe = function() {
var operations = [];
for (var _i = 0; _i < arguments.length; _i++) {
operations[_i] = arguments[_i];
}
return pipeFromArray(operations)(this);
};
Observable2.prototype.toPromise = function(promiseCtor) {
var _this = this;
promiseCtor = getPromiseCtor(promiseCtor);
return new promiseCtor(function(resolve, reject) {
var value;
_this.subscribe(function(x) {
return value = x;
}, function(err) {
return reject(err);
}, function() {
return resolve(value);
});
});
};
Observable2.create = function(subscribe) {
return new Observable2(subscribe);
};
return Observable2;
}();
function getPromiseCtor(promiseCtor) {
var _a;
return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config$1.Promise) !== null && _a !== void 0 ? _a : Promise;
}
function isObserver(value) {
return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
}
function isSubscriber(value) {
return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
}
var isArrayLike = function(x) {
return x && typeof x.length === "number" && typeof x !== "function";
};
function isPromise(value) {
return isFunction(value === null || value === void 0 ? void 0 : value.then);
}
function isInteropObservable(input) {
return isFunction(input[observable]);
}
function isAsyncIterable(obj) {
return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
}
function createInvalidObservableTypeError(input) {
return new TypeError("You provided " + (input !== null && typeof input === "object" ? "an invalid object" : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
}
function getSymbolIterator() {
if (typeof Symbol !== "function" || !Symbol.iterator) {
return "@@iterator";
}
return Symbol.iterator;
}
var iterator = getSymbolIterator();
function isIterable(input) {
return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
}
function readableStreamLikeToAsyncGenerator(readableStream) {
return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
var reader, _a, value, done;
return __generator(this, function(_b) {
switch (_b.label) {
case 0:
reader = readableStream.getReader();
_b.label = 1;
case 1:
_b.trys.push([1, , 9, 10]);
_b.label = 2;
case 2:
return [4, __await(reader.read())];
case 3:
_a = _b.sent(), value = _a.value, done = _a.done;
if (!done)
return [3, 5];
return [4, __await(void 0)];
case 4:
return [2, _b.sent()];
case 5:
return [4, __await(value)];
case 6:
return [4, _b.sent()];
case 7:
_b.sent();
return [3, 2];
case 8:
return [3, 10];
case 9:
reader.releaseLock();
return [7];
case 10:
return [2];
}
});
});
}
function isReadableStreamLike(obj) {
return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
}
function innerFrom(input) {
if (input instanceof Observable) {
return input;
}
if (input != null) {
if (isInteropObservable(input)) {
return fromInteropObservable(input);
}
if (isArrayLike(input)) {
return fromArrayLike(input);
}
if (isPromise(input)) {
return fromPromise(input);
}
if (isAsyncIterable(input)) {
return fromAsyncIterable(input);
}
if (isIterable(input)) {
return fromIterable(input);
}
if (isReadableStreamLike(input)) {
return fromReadableStreamLike(input);
}
}
throw createInvalidObservableTypeError(input);
}
function fromInteropObservable(obj) {
return new Observable(function(subscriber) {
var obs = obj[observable]();
if (isFunction(obs.subscribe)) {
return obs.subscribe(subscriber);
}
throw new TypeError("Provided object does not correctly implement Symbol.observable");
});
}
function fromArrayLike(array) {
return new Observable(function(subscriber) {
for (var i = 0; i < array.length && !subscriber.closed; i++) {
subscriber.next(array[i]);
}
subscriber.complete();
});
}
function fromPromise(promise) {
return new Observable(function(subscriber) {
promise.then(function(value) {
if (!subscriber.closed) {
subscriber.next(value);
subscriber.complete();
}
}, function(err) {
return subscriber.error(err);
}).then(null, reportUnhandledError);
});
}
function fromIterable(iterable) {
return new Observable(function(subscriber) {
var e_1, _a;
try {
for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
var value = iterable_1_1.value;
subscriber.next(value);
if (subscriber.closed) {
return;
}
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return))
_a.call(iterable_1);
} finally {
if (e_1)
throw e_1.error;
}
}
subscriber.complete();
});
}
function fromAsyncIterable(asyncIterable) {
return new Observable(function(subscriber) {
process(asyncIterable, subscriber).catch(function(err) {
return subscriber.error(err);
});
});
}
function fromReadableStreamLike(readableStream) {
return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
}
function process(asyncIterable, subscriber) {
var asyncIterable_1, asyncIterable_1_1;
var e_2, _a;
return __awaiter(this, void 0, void 0, function() {
var value, e_2_1;
return __generator(this, function(_b) {
switch (_b.label) {
case 0:
_b.trys.push([0, 5, 6, 11]);
asyncIterable_1 = __asyncValues(asyncIterable);
_b.label = 1;
case 1:
return [4, asyncIterable_1.next()];
case 2:
if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done))
return [3, 4];
value = asyncIterable_1_1.value;
subscriber.next(value);
if (subscriber.closed) {
return [2];
}
_b.label = 3;
case 3:
return [3, 1];
case 4:
return [3, 11];
case 5:
e_2_1 = _b.sent();
e_2 = { error: e_2_1 };
return [3, 11];
case 6:
_b.trys.push([6, , 9, 10]);
if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return)))
return [3, 8];
return [4, _a.call(asyncIterable_1)];
case 7:
_b.sent();
_b.label = 8;
case 8:
return [3, 10];
case 9:
if (e_2)
throw e_2.error;
return [7];
case 10:
return [7];
case 11:
subscriber.complete();
return [2];
}
});
});
}
function fromFetch(input, initWithSelector) {
if (initWithSelector === void 0) {
initWithSelector = {};
}
var selector = initWithSelector.selector, init = __rest(initWithSelector, ["selector"]);
return new Observable(function(subscriber) {
var controller = new AbortController();
var signal = controller.signal;
var abortable = true;
var outerSignal = init.signal;
if (outerSignal) {
if (outerSignal.aborted) {
controller.abort();
} else {
var outerSignalHandler_1 = function() {
if (!signal.aborted) {
controller.abort();
}
};
outerSignal.addEventListener("abort", outerSignalHandler_1);
subscriber.add(function() {
return outerSignal.removeEventListener("abort", outerSignalHandler_1);
});
}
}
var perSubscriberInit = __assign(__assign({}, init), { signal });
var handleError = function(err) {
abortable = false;
subscriber.error(err);
};
fetch(input, perSubscriberInit).then(function(response) {
if (selector) {
innerFrom(selector(response)).subscribe(createOperatorSubscriber(subscriber, void 0, function() {
abortable = false;
subscriber.complete();
}, handleError));
} else {
abortable = false;
subscriber.next(response);
subscriber.complete();
}
}).catch(handleError);
return function() {
if (abortable) {
controller.abort();
}
};
});
}
class HttpContextToken {
constructor(defaultValue) {
this.defaultValue = defaultValue;
}
}
class HttpContext {
constructor() {
this.map = /* @__PURE__ */ new Map();
}
set(token, value) {
this.map.set(token, value !== null && value !== void 0 ? value : token.defaultValue());
return this;
}
get(token) {
if (!this.map.has(token)) {
this.map.set(token, token.defaultValue());
}
return this.map.get(token);
}
delete(token) {
this.map.delete(token);
return this;
}
has(token) {
return this.map.has(token);
}
keys() {
return this.map.keys();
}
forEach(fn) {
this.map.forEach((value, token) => fn(token, value));
}
}
class HttpHeaders {
constructor(headers) {
this.headers = /* @__PURE__ */ new Map();
this.normalizedNames = /* @__PURE__ */ new Map();
if (typeof headers === "string") {
headers.split("\n").forEach((line) => {
if (line.includes(":")) {
const [name, value] = line.split(/:\s/, 2);
const key = name.toLowerCase();
const base = this.headers.get(key) || [];
base.push(value);
this.headers.set(key, base);
this.setNormalizedName(key, name);
}
});
} else if (headers) {
Object.keys(headers).forEach((name) => {
const key = name.toLowerCase();
const value = headers[name];
this.headers.set(key, Array.isArray(value) ? value : [value]);
this.setNormalizedName(key, name);
});
}
}
append(name, value) {
const clone = this.clone();
const key = name.toLowerCase();
const base = clone.headers.get(key) || [];
base.push(...Array.isArray(value) ? value : [value]);
clone.headers.set(key, base);
clone.setNormalizedName(key, name);
return clone;
}
set(name, value) {
const clone = this.clone();
const key = name.toLowerCase();
clone.headers.set(key, Array.isArray(value) ? value : [value]);
clone.setNormalizedName(key, name);
return clone;
}
delete(name) {
const clone = this.clone();
const key = name.toLowerCase();
clone.headers.delete(key);
clone.normalizedNames.delete(key);
return clone;
}
get(name) {
const values = this.headers.get(name.toLowerCase());
return (values === null || values === void 0 ? void 0 : values[0]) || null;
}
getAll(name) {
return this.headers.get(name.toLowerCase()) || null;
}
has(name) {
return this.headers.has(name.toLowerCase());
}
forEach(fn) {
this.headers.forEach((value, name) => fn(this.normalizedNames.get(name), value));
}
keys() {
return Array.from(this.normalizedNames.values());
}
clone() {
const clone = new HttpHeaders();
this.headers.forEach((value, name) => {
clone.headers.set(name, [...value]);
clone.normalizedNames.set(name, this.normalizedNames.get(name));
});
return clone;
}
setNormalizedName(lowercase, normalized) {
this.normalizedNames.has(lowercase) || this.normalizedNames.set(lowercase, normalized);
}
}
var HttpEventType;
(function(HttpEventType2) {
HttpEventType2[HttpEventType2["Sent"] = 0] = "Sent";
HttpEventType2[HttpEventType2["UploadProgress"] = 1] = "UploadProgress";
HttpEventType2[HttpEventType2["ResponseHeader"] = 2] = "ResponseHeader";
HttpEventType2[HttpEventType2["DownloadProgress"] = 3] = "DownloadProgress";
HttpEventType2[HttpEventType2["Response"] = 4] = "Response";
HttpEventType2[HttpEventType2["User"] = 5] = "User";
})(HttpEventType || (HttpEventType = {}));
class HttpResponseBase {
constructor(options, defaultStatus = 200, defaultStatusText = "OK") {
this.url = options.url || null;
this.status = options.status !== void 0 ? options.status : defaultStatus;
this.statusText = options.statusText || defaultStatusText;
this.headers = options.headers || new HttpHeaders();
this.ok = this.status >= 200 && this.status < 300;
}
}
class HttpHeaderResponse extends HttpResponseBase {
constructor(options = {}) {
super(options);
this.type = HttpEventType.ResponseHeader;
}
clone(update = {}) {
return new HttpHeaderResponse({
url: update.url || this.url || void 0,
status: update.status !== void 0 ? update.status : this.status,
statusText: update.statusText || this.statusText,
headers: update.headers || this.headers
});
}
}
class HttpResponse extends HttpResponseBase {
constructor(options = {}) {
super(options);
this.type = HttpEventType.Response;
this.body = options.body !== void 0 ? options.body : null;
}
clone(update = {}) {
return new HttpResponse({
url: update.url || this.url || void 0,
body: update.body !== void 0 ? update.body : this.body,
status: update.status || this.status,
statusText: update.statusText || this.statusText,
headers: update.headers || this.headers
});
}
}
class HttpErrorResponse extends HttpResponseBase {
constructor(options) {
super(options, 0, "Unknown Error");
this.name = "HttpErrorResponse";
this.ok = false;
if (this.status >= 200 && this.status < 300) {
this.message = `Http failure during parsing for ${options.url || "(unknown url)"}`;
} else {
this.message = `Http failure response for ${options.url || "(unknown url)"}: ${options.status} ${options.statusText}`;
}
this.error = options.error || null;
}
}
const FETCH_TOKEN = new HttpContextToken(() => ({}));
class HttpFetchBackend {
handle(request) {
if (request.reportProgress) {
throw Error("Fetch API does not currently support report progress");
}
let url;
let status;
let statusText;
let headers;
return of({ type: HttpEventType.Sent }).pipe(concatMap(() => fromFetch(request.urlWithParams, Object.assign({ selector: void 0, method: request.method, headers: request.headers.keys().reduce((headers2, name) => (headers2[name] = request.headers.getAll(name).join(","), headers2), {}), body: request.serializeBody() }, request.context.get(FETCH_TOKEN)))), switchMap((response) => {
url = response.url;
status = response.status;
statusText = response.statusText;
headers = new HttpHeaders();
response.headers.forEach((value, key) => headers.set(key, value));
switch (request.responseType) {
case "arraybuffer":
return from(response.arrayBuffer());
case "blob":
return from(response.blob());
case "json":
return from(response.json());
case "text":
return from(response.text());
}
}), map((body) => new HttpResponse({
body,
headers,
status,
statusText,
url
})), catchError((error) => {
if (error instanceof HttpErrorResponse) {
return throwError(() => error);
}
return throwError(() => new HttpErrorResponse({
url,
error,
status,
statusText,
headers
}));
}));
}
}
const WX_UPLOAD_FILE_TOKEN = new HttpContextToken(() => ({}));
const WX_DOWNLOAD_FILE_TOKEN = new HttpContextToken(() => ({}));
const WX_REQUSET_TOKEN = new HttpContextToken(() => ({}));
class HttpWxBackend {
handle(request) {
if (request.method === "POST" && request.context.has(WX_UPLOAD_FILE_TOKEN)) {
return this.upload(request);
}
if (request.method === "GET" && request.context.has(WX_DOWNLOAD_FILE_TOKEN)) {
return this.download(request);
}
return this.request(request);
}
upload(request) {
return new Observable$1((observer) => {
const onHeadersReceived = ({ header }) => {
observer.next(new HttpHeaderResponse({
url: request.url,
headers: new HttpHeaders(header)
}));
};
const onUpProgressUpdate = ({ totalBytesSent, totalBytesExpectedToSend }) => {
observer.next({
type: HttpEventType.UploadProgress,
loaded: totalBytesSent,
total: totalBytesExpectedToSend
});
};
const { filePath, fileName, timeout } = request.context.get(WX_UPLOAD_FILE_TOKEN);
const task = wx.uploadFile({
url: request.urlWithParams,
filePath,
name: fileName,
header: this.buildHeaders(request),
formData: request.body,
timeout,
success: ({ data, statusCode: status, errMsg: statusText }) => {
let ok = status >= 200 && status < 300;
let body = null;
if (request.responseType === "json" && typeof data === "string" && data !== "") {
try {
body = JSON.parse(data);
} catch (error) {
if (ok) {
ok = false;
body = { error, text: body };
}
}
}
if (ok) {
observer.next(new HttpResponse({
url: request.url,
body,
status,
statusText
}));
observer.complete();
} else {
observer.error(new HttpErrorResponse({
url: request.url,
error: body,
status,
statusText
}));
}
},
fail: ({ errMsg }) => {
observer.error(new HttpErrorResponse({
url: request.url,
statusText: errMsg
}));
}
});
observer.next({ type: HttpEventType.Sent });
if (request.reportProgress) {
task.onHeadersReceived(onHeadersReceived);
task.onProgressUpdate(onUpProgressUpdate);
}
return () => {
if (request.reportProgress) {
task.offHeadersReceived(onHeadersReceived);
task.offProgressUpdate(onUpProgressUpdate);
}
task.abort();
};
});
}
download(request) {
return new Observable$1((observer) => {
const onHeadersReceived = ({ header }) => {
observer.next(new HttpHeaderResponse({
url: request.url,
headers: new HttpHeaders(header)
}));
};
const onDownProgressUpdate = ({ totalBytesWritten, totalBytesExpectedToWrite }) => {
observer.next({
type: HttpEventType.DownloadProgress,
loaded: totalBytesWritten,
total: totalBytesExpectedToWrite
});
};
const { filePath, timeout } = request.context.get(WX_DOWNLOAD_FILE_TOKEN);
const task = wx.downloadFile({
url: request.urlWithParams,
filePath,
header: this.buildHeaders(request),
timeout,
success: ({ statusCode: status, errMsg: statusText }) => {
const ok = status >= 200 && status < 300;
if (ok) {
observer.next(new HttpResponse({
url: request.url,
status,
statusText
}));
observer.complete();
} else {
observer.error(new HttpErrorResponse({
url: request.url,
status,
statusText
}));
}
},
fail: ({ errMsg }) => {
observer.error(new HttpErrorResponse({
url: request.url,
statusText: errMsg
}));
}
});
observer.next({ type: HttpEventType.Sent });
if (request.reportProgress) {
task.onHeadersReceived(onHeadersReceived);
task.onProgressUpdate(onDownProgressUpdate);
}
return () => {
if (request.reportProgress) {
task.offHeadersReceived(onHeadersReceived);
task.offProgressUpdate(onDownProgressUpdate);
}
task.abort();
};
});
}
request(request) {
return new Observable$1((observer) => {
if (request.method === "PATCH") {
throw Error("WeChat MiniProgram does not support http method as " + request.method);
}
const onHeadersReceived = ({ header }) => {
observer.next(new HttpHeaderResponse({
url: request.url,
headers: new HttpHeaders(header)
}));
};
const task = wx.request(Object.assign({ url: request.urlWithParams, method: request.method, data: request.body, header: this.buildHeaders(request), responseType: request.responseType === "arraybuffer" ? request.responseType : "text", dataType: request.responseType === "json" ? request.responseType : "\u5176\u4ED6", success: ({ data, header, statusCode: status, errMsg: statusText }) => {
const ok = status >= 200 && status < 300;
const headers = new HttpHeaders(header);
if (ok) {
observer.next(new HttpResponse({
url: request.url,
body: data,
status,
statusText,
headers
}));
observer.complete();
} else {
observer.error(new HttpErrorResponse({
url: request.url,
error: data,
status,
statusText,
headers
}));
}
}, fail: ({ errMsg }) => {
observer.error(new HttpErrorResponse({
url: request.url,
statusText: errMsg
}));
} }, request.context.get(WX_REQUSET_TOKEN)));
observer.next({ type: HttpEventType.Sent });
if (request.reportProgress) {
task.onHeadersReceived(onHeadersReceived);
}
return () => {
if (request.reportProgress) {
task.offHeadersReceived(onHeadersReceived);
}
task.abort();
};
});
}
buildHeaders(request) {
return request.headers.keys().reduce((headers, name) => (headers[name] = request.headers.getAll(name).join(","), headers), {});
}
}
const XSSI_PREFIX = /^\)\]\}',?\n/;
function getResponseUrl(xhr) {
if ("responseURL" in xhr && xhr.responseURL) {
return xhr.responseURL;
}
if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
return xhr.getResponseHeader("X-Request-URL");
}
return null;
}
class HttpXhrBackend {
constructor(factory) {
this.factory = factory || (() => new XMLHttpRequest());
}
handle(req) {
return new Observable$1((observer) => {
const xhr = this.factory();
xhr.open(req.method, req.urlWithParams);
if (req.withCredentials) {
xhr.withCredentials = true;
}
req.headers.forEach((name, values) => xhr.setRequestHeader(name, values.join(",")));
if (!req.headers.has("Accept")) {
xhr.setRequestHeader("Accept", "application/json, text/plain, */*");
}
if (!req.headers.has("Content-Type")) {
const detectedType = req.detectContentTypeHeader();
if (detectedType !== null) {
xhr.setRequestHeader("Content-Type", detectedType);
}
}
if (req.responseType) {
const responseType = req.responseType.toLowerCase();
xhr.responseType = responseType !== "json" ? responseType : "text";
}
const reqBody = req.serializeBody();
let headerResponse = null;
const partialFromXhr = () => {
if (headerResponse !== null) {
return headerResponse;
}
const status = xhr.status;
const statusText = xhr.statusText || "OK";
const headers = new HttpHeaders(xhr.getAllResponseHeaders());
const url = getResponseUrl(xhr) || req.url;
headerResponse = new HttpHeaderResponse({ headers, status, statusText, url });
return headerResponse;
};
const onLoad = () => {
let { headers, status, statusText, url } = partialFromXhr();
let body = null;
if (status !== 204) {
body = typeof xhr.response === "undefined" ? xhr.responseText : xhr.response;
}
if (status === 0) {
status = !!body ? 200 : 0;
}
let ok = status >= 200 && status < 300;
if (req.responseType === "json" && typeof body === "string") {
const originalBody = body;
body = body.replace(XSSI_PREFIX, "");
try {
body = body !== "" ? JSON.parse(body) : null;
} catch (error) {
body = originalBody;
if (ok) {
ok = false;
body = { error, text: body };
}
}
}
if (ok) {
observer.next(new HttpResponse({
body,
headers,
status,
statusText,
url: url || void 0
}));
observer.complete();
} else {
observer.error(new HttpErrorResponse({
error: body,
headers,
status,
statusText,
url: url || void 0
}));
}
};
const onError = (error) => {
const { url } = partialFromXhr();
const res = new HttpErrorResponse({
error,
status: xhr.status || 0,
statusText: xhr.statusText || "Unknown Error",
url: url || void 0
});
observer.error(res);
};
let sentHeaders = false;
const onDownProgress = (event) => {
if (!sentHeaders) {
observer.next(partialFromXhr());
sentHeaders = true;
}
let progressEvent = {
type: HttpEventType.DownloadProgress,
loaded: event.loaded
};
if (event.lengthComputable) {
progressEvent.total = event.total;
}
if (req.responseType === "text" && !!xhr.responseText) {
progressEvent.partialText = xhr.responseText;
}
observer.next(progressEvent);
};
const onUpProgress = (event) => {
let progress = {
type: HttpEventType.UploadProgress,
loaded: event.loaded
};
if (event.lengthComputable) {
progress.total = event.total;
}
observer.next(progress);
};
xhr.addEventListener("load", onLoad);
xhr.addEventListener("error", onError);
xhr.addEventListener("timeout", onError);
xhr.addEventListener("abort", onError);
if (req.reportProgress) {
xhr.addEventListener("progress", onDownProgress);
if (reqBody !== null && xhr.upload) {
xhr.upload.addEventListener("progress", onUpProgress);
}
}
xhr.send(reqBody);
observer.next({ type: HttpEventType.Sent });
return () => {
xhr.removeEventListener("error", onError);
xhr.removeEventListener("abort", onError);
xhr.removeEventListener("load", onLoad);
xhr.removeEventListener("timeout", onError);
if (req.reportProgress) {
xhr.removeEventListener("progress", onDownProgress);
if (reqBody !== null && xhr.upload) {
xhr.upload.removeEventListener("progress", onUpProgress);
}
}
if (xhr.readyState !== xhr.DONE) {
xhr.abort();
}
};
});
}
}
const config = {};
const setupConfig = (cfg) => Object.assign(config, cfg);
class HttpInterceptorHandler {
constructor(interceptor, next) {
this.interceptor = interceptor;
this.next = next;
}
handle(request) {
return this.interceptor.intercept(request, this.next);
}
}
const STANDARD_ENCODING_REGEX = /%(\d[a-f0-9])/gi;
const STANDARD_ENCODING_REPLACEMENTS = {
"40": "@",
"3A": ":",
"24": "$",
"2C": ",",
"3B": ";",
"3D": "=",
"3F": "?",
"2F": "/"
};
const standardEncoding = (value) => encode