xstream
Version:
An extremely intuitive, small, and fast functional reactive stream library for JavaScript
1,559 lines (1,452 loc) • 41.6 kB
JavaScript
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.xstream = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.NO_IL = exports.NO = exports.MemoryStream = exports.Stream = void 0;
var ponyfill_1 = require("symbol-observable/ponyfill");
var globalthis_1 = require("globalthis");
var $$observable = ponyfill_1.default(globalthis_1.getPolyfill());
var NO = {};
exports.NO = NO;
function noop() { }
function cp(a) {
var l = a.length;
var b = Array(l);
for (var i = 0; i < l; ++i)
b[i] = a[i];
return b;
}
function and(f1, f2) {
return function andFn(t) {
return f1(t) && f2(t);
};
}
function _try(c, t, u) {
try {
return c.f(t);
}
catch (e) {
u._e(e);
return NO;
}
}
var NO_IL = {
_n: noop,
_e: noop,
_c: noop,
};
exports.NO_IL = NO_IL;
function internalizeProducer(producer) {
producer._start = function _start(il) {
il.next = il._n;
il.error = il._e;
il.complete = il._c;
this.start(il);
};
producer._stop = producer.stop;
}
var StreamSub = (function () {
function StreamSub(_stream, _listener) {
this._stream = _stream;
this._listener = _listener;
}
StreamSub.prototype.unsubscribe = function () {
this._stream._remove(this._listener);
};
return StreamSub;
}());
var Observer = (function () {
function Observer(_listener) {
this._listener = _listener;
}
Observer.prototype.next = function (value) {
this._listener._n(value);
};
Observer.prototype.error = function (err) {
this._listener._e(err);
};
Observer.prototype.complete = function () {
this._listener._c();
};
return Observer;
}());
var FromObservable = (function () {
function FromObservable(observable) {
this.type = 'fromObservable';
this.ins = observable;
this.active = false;
}
FromObservable.prototype._start = function (out) {
this.out = out;
this.active = true;
this._sub = this.ins.subscribe(new Observer(out));
if (!this.active)
this._sub.unsubscribe();
};
FromObservable.prototype._stop = function () {
if (this._sub)
this._sub.unsubscribe();
this.active = false;
};
return FromObservable;
}());
var Merge = (function () {
function Merge(insArr) {
this.type = 'merge';
this.insArr = insArr;
this.out = NO;
this.ac = 0;
}
Merge.prototype._start = function (out) {
this.out = out;
var s = this.insArr;
var L = s.length;
this.ac = L;
for (var i = 0; i < L; i++)
s[i]._add(this);
};
Merge.prototype._stop = function () {
var s = this.insArr;
var L = s.length;
for (var i = 0; i < L; i++)
s[i]._remove(this);
this.out = NO;
};
Merge.prototype._n = function (t) {
var u = this.out;
if (u === NO)
return;
u._n(t);
};
Merge.prototype._e = function (err) {
var u = this.out;
if (u === NO)
return;
u._e(err);
};
Merge.prototype._c = function () {
if (--this.ac <= 0) {
var u = this.out;
if (u === NO)
return;
u._c();
}
};
return Merge;
}());
var CombineListener = (function () {
function CombineListener(i, out, p) {
this.i = i;
this.out = out;
this.p = p;
p.ils.push(this);
}
CombineListener.prototype._n = function (t) {
var p = this.p, out = this.out;
if (out === NO)
return;
if (p.up(t, this.i)) {
var b = cp(p.vals);
out._n(b);
}
};
CombineListener.prototype._e = function (err) {
var out = this.out;
if (out === NO)
return;
out._e(err);
};
CombineListener.prototype._c = function () {
var p = this.p;
if (p.out === NO)
return;
if (--p.Nc === 0)
p.out._c();
};
return CombineListener;
}());
var Combine = (function () {
function Combine(insArr) {
this.type = 'combine';
this.insArr = insArr;
this.out = NO;
this.ils = [];
this.Nc = this.Nn = 0;
this.vals = [];
}
Combine.prototype.up = function (t, i) {
var v = this.vals[i];
var Nn = !this.Nn ? 0 : v === NO ? --this.Nn : this.Nn;
this.vals[i] = t;
return Nn === 0;
};
Combine.prototype._start = function (out) {
this.out = out;
var s = this.insArr;
var n = this.Nc = this.Nn = s.length;
var vals = this.vals = new Array(n);
if (n === 0) {
out._n([]);
out._c();
}
else {
for (var i = 0; i < n; i++) {
vals[i] = NO;
s[i]._add(new CombineListener(i, out, this));
}
}
};
Combine.prototype._stop = function () {
var s = this.insArr;
var n = s.length;
var ils = this.ils;
for (var i = 0; i < n; i++)
s[i]._remove(ils[i]);
this.out = NO;
this.ils = [];
this.vals = [];
};
return Combine;
}());
var FromArray = (function () {
function FromArray(a) {
this.type = 'fromArray';
this.a = a;
}
FromArray.prototype._start = function (out) {
var a = this.a;
for (var i = 0, n = a.length; i < n; i++)
out._n(a[i]);
out._c();
};
FromArray.prototype._stop = function () {
};
return FromArray;
}());
var FromPromise = (function () {
function FromPromise(p) {
this.type = 'fromPromise';
this.on = false;
this.p = p;
}
FromPromise.prototype._start = function (out) {
var prod = this;
this.on = true;
this.p.then(function (v) {
if (prod.on) {
out._n(v);
out._c();
}
}, function (e) {
out._e(e);
}).then(noop, function (err) {
setTimeout(function () { throw err; });
});
};
FromPromise.prototype._stop = function () {
this.on = false;
};
return FromPromise;
}());
var Periodic = (function () {
function Periodic(period) {
this.type = 'periodic';
this.period = period;
this.intervalID = -1;
this.i = 0;
}
Periodic.prototype._start = function (out) {
var self = this;
function intervalHandler() { out._n(self.i++); }
this.intervalID = setInterval(intervalHandler, this.period);
};
Periodic.prototype._stop = function () {
if (this.intervalID !== -1)
clearInterval(this.intervalID);
this.intervalID = -1;
this.i = 0;
};
return Periodic;
}());
var Debug = (function () {
function Debug(ins, arg) {
this.type = 'debug';
this.ins = ins;
this.out = NO;
this.s = noop;
this.l = '';
if (typeof arg === 'string')
this.l = arg;
else if (typeof arg === 'function')
this.s = arg;
}
Debug.prototype._start = function (out) {
this.out = out;
this.ins._add(this);
};
Debug.prototype._stop = function () {
this.ins._remove(this);
this.out = NO;
};
Debug.prototype._n = function (t) {
var u = this.out;
if (u === NO)
return;
var s = this.s, l = this.l;
if (s !== noop) {
try {
s(t);
}
catch (e) {
u._e(e);
}
}
else if (l)
console.log(l + ':', t);
else
console.log(t);
u._n(t);
};
Debug.prototype._e = function (err) {
var u = this.out;
if (u === NO)
return;
u._e(err);
};
Debug.prototype._c = function () {
var u = this.out;
if (u === NO)
return;
u._c();
};
return Debug;
}());
var Drop = (function () {
function Drop(max, ins) {
this.type = 'drop';
this.ins = ins;
this.out = NO;
this.max = max;
this.dropped = 0;
}
Drop.prototype._start = function (out) {
this.out = out;
this.dropped = 0;
this.ins._add(this);
};
Drop.prototype._stop = function () {
this.ins._remove(this);
this.out = NO;
};
Drop.prototype._n = function (t) {
var u = this.out;
if (u === NO)
return;
if (this.dropped++ >= this.max)
u._n(t);
};
Drop.prototype._e = function (err) {
var u = this.out;
if (u === NO)
return;
u._e(err);
};
Drop.prototype._c = function () {
var u = this.out;
if (u === NO)
return;
u._c();
};
return Drop;
}());
var EndWhenListener = (function () {
function EndWhenListener(out, op) {
this.out = out;
this.op = op;
}
EndWhenListener.prototype._n = function () {
this.op.end();
};
EndWhenListener.prototype._e = function (err) {
this.out._e(err);
};
EndWhenListener.prototype._c = function () {
this.op.end();
};
return EndWhenListener;
}());
var EndWhen = (function () {
function EndWhen(o, ins) {
this.type = 'endWhen';
this.ins = ins;
this.out = NO;
this.o = o;
this.oil = NO_IL;
}
EndWhen.prototype._start = function (out) {
this.out = out;
this.o._add(this.oil = new EndWhenListener(out, this));
this.ins._add(this);
};
EndWhen.prototype._stop = function () {
this.ins._remove(this);
this.o._remove(this.oil);
this.out = NO;
this.oil = NO_IL;
};
EndWhen.prototype.end = function () {
var u = this.out;
if (u === NO)
return;
u._c();
};
EndWhen.prototype._n = function (t) {
var u = this.out;
if (u === NO)
return;
u._n(t);
};
EndWhen.prototype._e = function (err) {
var u = this.out;
if (u === NO)
return;
u._e(err);
};
EndWhen.prototype._c = function () {
this.end();
};
return EndWhen;
}());
var Filter = (function () {
function Filter(passes, ins) {
this.type = 'filter';
this.ins = ins;
this.out = NO;
this.f = passes;
}
Filter.prototype._start = function (out) {
this.out = out;
this.ins._add(this);
};
Filter.prototype._stop = function () {
this.ins._remove(this);
this.out = NO;
};
Filter.prototype._n = function (t) {
var u = this.out;
if (u === NO)
return;
var r = _try(this, t, u);
if (r === NO || !r)
return;
u._n(t);
};
Filter.prototype._e = function (err) {
var u = this.out;
if (u === NO)
return;
u._e(err);
};
Filter.prototype._c = function () {
var u = this.out;
if (u === NO)
return;
u._c();
};
return Filter;
}());
var FlattenListener = (function () {
function FlattenListener(out, op) {
this.out = out;
this.op = op;
}
FlattenListener.prototype._n = function (t) {
this.out._n(t);
};
FlattenListener.prototype._e = function (err) {
this.out._e(err);
};
FlattenListener.prototype._c = function () {
this.op.inner = NO;
this.op.less();
};
return FlattenListener;
}());
var Flatten = (function () {
function Flatten(ins) {
this.type = 'flatten';
this.ins = ins;
this.out = NO;
this.open = true;
this.inner = NO;
this.il = NO_IL;
}
Flatten.prototype._start = function (out) {
this.out = out;
this.open = true;
this.inner = NO;
this.il = NO_IL;
this.ins._add(this);
};
Flatten.prototype._stop = function () {
this.ins._remove(this);
if (this.inner !== NO)
this.inner._remove(this.il);
this.out = NO;
this.open = true;
this.inner = NO;
this.il = NO_IL;
};
Flatten.prototype.less = function () {
var u = this.out;
if (u === NO)
return;
if (!this.open && this.inner === NO)
u._c();
};
Flatten.prototype._n = function (s) {
var u = this.out;
if (u === NO)
return;
var _a = this, inner = _a.inner, il = _a.il;
if (inner !== NO && il !== NO_IL)
inner._remove(il);
(this.inner = s)._add(this.il = new FlattenListener(u, this));
};
Flatten.prototype._e = function (err) {
var u = this.out;
if (u === NO)
return;
u._e(err);
};
Flatten.prototype._c = function () {
this.open = false;
this.less();
};
return Flatten;
}());
var Fold = (function () {
function Fold(f, seed, ins) {
var _this = this;
this.type = 'fold';
this.ins = ins;
this.out = NO;
this.f = function (t) { return f(_this.acc, t); };
this.acc = this.seed = seed;
}
Fold.prototype._start = function (out) {
this.out = out;
this.acc = this.seed;
out._n(this.acc);
this.ins._add(this);
};
Fold.prototype._stop = function () {
this.ins._remove(this);
this.out = NO;
this.acc = this.seed;
};
Fold.prototype._n = function (t) {
var u = this.out;
if (u === NO)
return;
var r = _try(this, t, u);
if (r === NO)
return;
u._n(this.acc = r);
};
Fold.prototype._e = function (err) {
var u = this.out;
if (u === NO)
return;
u._e(err);
};
Fold.prototype._c = function () {
var u = this.out;
if (u === NO)
return;
u._c();
};
return Fold;
}());
var Last = (function () {
function Last(ins) {
this.type = 'last';
this.ins = ins;
this.out = NO;
this.has = false;
this.val = NO;
}
Last.prototype._start = function (out) {
this.out = out;
this.has = false;
this.ins._add(this);
};
Last.prototype._stop = function () {
this.ins._remove(this);
this.out = NO;
this.val = NO;
};
Last.prototype._n = function (t) {
this.has = true;
this.val = t;
};
Last.prototype._e = function (err) {
var u = this.out;
if (u === NO)
return;
u._e(err);
};
Last.prototype._c = function () {
var u = this.out;
if (u === NO)
return;
if (this.has) {
u._n(this.val);
u._c();
}
else
u._e(new Error('last() failed because input stream completed'));
};
return Last;
}());
var MapOp = (function () {
function MapOp(project, ins) {
this.type = 'map';
this.ins = ins;
this.out = NO;
this.f = project;
}
MapOp.prototype._start = function (out) {
this.out = out;
this.ins._add(this);
};
MapOp.prototype._stop = function () {
this.ins._remove(this);
this.out = NO;
};
MapOp.prototype._n = function (t) {
var u = this.out;
if (u === NO)
return;
var r = _try(this, t, u);
if (r === NO)
return;
u._n(r);
};
MapOp.prototype._e = function (err) {
var u = this.out;
if (u === NO)
return;
u._e(err);
};
MapOp.prototype._c = function () {
var u = this.out;
if (u === NO)
return;
u._c();
};
return MapOp;
}());
var Remember = (function () {
function Remember(ins) {
this.type = 'remember';
this.ins = ins;
this.out = NO;
}
Remember.prototype._start = function (out) {
this.out = out;
this.ins._add(out);
};
Remember.prototype._stop = function () {
this.ins._remove(this.out);
this.out = NO;
};
return Remember;
}());
var ReplaceError = (function () {
function ReplaceError(replacer, ins) {
this.type = 'replaceError';
this.ins = ins;
this.out = NO;
this.f = replacer;
}
ReplaceError.prototype._start = function (out) {
this.out = out;
this.ins._add(this);
};
ReplaceError.prototype._stop = function () {
this.ins._remove(this);
this.out = NO;
};
ReplaceError.prototype._n = function (t) {
var u = this.out;
if (u === NO)
return;
u._n(t);
};
ReplaceError.prototype._e = function (err) {
var u = this.out;
if (u === NO)
return;
try {
this.ins._remove(this);
(this.ins = this.f(err))._add(this);
}
catch (e) {
u._e(e);
}
};
ReplaceError.prototype._c = function () {
var u = this.out;
if (u === NO)
return;
u._c();
};
return ReplaceError;
}());
var StartWith = (function () {
function StartWith(ins, val) {
this.type = 'startWith';
this.ins = ins;
this.out = NO;
this.val = val;
}
StartWith.prototype._start = function (out) {
this.out = out;
this.out._n(this.val);
this.ins._add(out);
};
StartWith.prototype._stop = function () {
this.ins._remove(this.out);
this.out = NO;
};
return StartWith;
}());
var Take = (function () {
function Take(max, ins) {
this.type = 'take';
this.ins = ins;
this.out = NO;
this.max = max;
this.taken = 0;
}
Take.prototype._start = function (out) {
this.out = out;
this.taken = 0;
if (this.max <= 0)
out._c();
else
this.ins._add(this);
};
Take.prototype._stop = function () {
this.ins._remove(this);
this.out = NO;
};
Take.prototype._n = function (t) {
var u = this.out;
if (u === NO)
return;
var m = ++this.taken;
if (m < this.max)
u._n(t);
else if (m === this.max) {
u._n(t);
u._c();
}
};
Take.prototype._e = function (err) {
var u = this.out;
if (u === NO)
return;
u._e(err);
};
Take.prototype._c = function () {
var u = this.out;
if (u === NO)
return;
u._c();
};
return Take;
}());
var Stream = (function () {
function Stream(producer) {
this._prod = producer || NO;
this._ils = [];
this._stopID = NO;
this._dl = NO;
this._d = false;
this._target = null;
this._err = NO;
}
Stream.prototype._n = function (t) {
var a = this._ils;
var L = a.length;
if (this._d)
this._dl._n(t);
if (L == 1)
a[0]._n(t);
else if (L == 0)
return;
else {
var b = cp(a);
for (var i = 0; i < L; i++)
b[i]._n(t);
}
};
Stream.prototype._e = function (err) {
if (this._err !== NO)
return;
this._err = err;
var a = this._ils;
var L = a.length;
this._x();
if (this._d)
this._dl._e(err);
if (L == 1)
a[0]._e(err);
else if (L == 0)
return;
else {
var b = cp(a);
for (var i = 0; i < L; i++)
b[i]._e(err);
}
if (!this._d && L == 0)
throw this._err;
};
Stream.prototype._c = function () {
var a = this._ils;
var L = a.length;
this._x();
if (this._d)
this._dl._c();
if (L == 1)
a[0]._c();
else if (L == 0)
return;
else {
var b = cp(a);
for (var i = 0; i < L; i++)
b[i]._c();
}
};
Stream.prototype._x = function () {
if (this._ils.length === 0)
return;
if (this._prod !== NO)
this._prod._stop();
this._err = NO;
this._ils = [];
};
Stream.prototype._stopNow = function () {
this._prod._stop();
this._err = NO;
this._stopID = NO;
};
Stream.prototype._add = function (il) {
var ta = this._target;
if (ta)
return ta._add(il);
var a = this._ils;
a.push(il);
if (a.length > 1)
return;
if (this._stopID !== NO) {
clearTimeout(this._stopID);
this._stopID = NO;
}
else {
var p = this._prod;
if (p !== NO)
p._start(this);
}
};
Stream.prototype._remove = function (il) {
var _this = this;
var ta = this._target;
if (ta)
return ta._remove(il);
var a = this._ils;
var i = a.indexOf(il);
if (i > -1) {
a.splice(i, 1);
if (this._prod !== NO && a.length <= 0) {
this._err = NO;
this._stopID = setTimeout(function () { return _this._stopNow(); });
}
else if (a.length === 1) {
this._pruneCycles();
}
}
};
Stream.prototype._pruneCycles = function () {
if (this._hasNoSinks(this, []))
this._remove(this._ils[0]);
};
Stream.prototype._hasNoSinks = function (x, trace) {
if (trace.indexOf(x) !== -1)
return true;
else if (x.out === this)
return true;
else if (x.out && x.out !== NO)
return this._hasNoSinks(x.out, trace.concat(x));
else if (x._ils) {
for (var i = 0, N = x._ils.length; i < N; i++)
if (!this._hasNoSinks(x._ils[i], trace.concat(x)))
return false;
return true;
}
else
return false;
};
Stream.prototype.ctor = function () {
return this instanceof MemoryStream ? MemoryStream : Stream;
};
Stream.prototype.addListener = function (listener) {
listener._n = listener.next || noop;
listener._e = listener.error || noop;
listener._c = listener.complete || noop;
this._add(listener);
};
Stream.prototype.removeListener = function (listener) {
this._remove(listener);
};
Stream.prototype.subscribe = function (listener) {
this.addListener(listener);
return new StreamSub(this, listener);
};
Stream.prototype[$$observable] = function () {
return this;
};
Stream.create = function (producer) {
if (producer) {
if (typeof producer.start !== 'function'
|| typeof producer.stop !== 'function')
throw new Error('producer requires both start and stop functions');
internalizeProducer(producer);
}
return new Stream(producer);
};
Stream.createWithMemory = function (producer) {
if (producer)
internalizeProducer(producer);
return new MemoryStream(producer);
};
Stream.never = function () {
return new Stream({ _start: noop, _stop: noop });
};
Stream.empty = function () {
return new Stream({
_start: function (il) { il._c(); },
_stop: noop,
});
};
Stream.throw = function (error) {
return new Stream({
_start: function (il) { il._e(error); },
_stop: noop,
});
};
Stream.from = function (input) {
if (typeof input[$$observable] === 'function')
return Stream.fromObservable(input);
else if (typeof input.then === 'function')
return Stream.fromPromise(input);
else if (Array.isArray(input))
return Stream.fromArray(input);
throw new TypeError("Type of input to from() must be an Array, Promise, or Observable");
};
Stream.of = function () {
var items = [];
for (var _i = 0; _i < arguments.length; _i++) {
items[_i] = arguments[_i];
}
return Stream.fromArray(items);
};
Stream.fromArray = function (array) {
return new Stream(new FromArray(array));
};
Stream.fromPromise = function (promise) {
return new Stream(new FromPromise(promise));
};
Stream.fromObservable = function (obs) {
if (obs.endWhen !== undefined)
return obs;
var o = typeof obs[$$observable] === 'function' ? obs[$$observable]() : obs;
return new Stream(new FromObservable(o));
};
Stream.periodic = function (period) {
return new Stream(new Periodic(period));
};
Stream.prototype._map = function (project) {
return new (this.ctor())(new MapOp(project, this));
};
Stream.prototype.map = function (project) {
return this._map(project);
};
Stream.prototype.mapTo = function (projectedValue) {
var s = this.map(function () { return projectedValue; });
var op = s._prod;
op.type = 'mapTo';
return s;
};
Stream.prototype.filter = function (passes) {
var p = this._prod;
if (p instanceof Filter)
return new Stream(new Filter(and(p.f, passes), p.ins));
return new Stream(new Filter(passes, this));
};
Stream.prototype.take = function (amount) {
return new (this.ctor())(new Take(amount, this));
};
Stream.prototype.drop = function (amount) {
return new Stream(new Drop(amount, this));
};
Stream.prototype.last = function () {
return new Stream(new Last(this));
};
Stream.prototype.startWith = function (initial) {
return new MemoryStream(new StartWith(this, initial));
};
Stream.prototype.endWhen = function (other) {
return new (this.ctor())(new EndWhen(other, this));
};
Stream.prototype.fold = function (accumulate, seed) {
return new MemoryStream(new Fold(accumulate, seed, this));
};
Stream.prototype.replaceError = function (replace) {
return new (this.ctor())(new ReplaceError(replace, this));
};
Stream.prototype.flatten = function () {
return new Stream(new Flatten(this));
};
Stream.prototype.compose = function (operator) {
return operator(this);
};
Stream.prototype.remember = function () {
return new MemoryStream(new Remember(this));
};
Stream.prototype.debug = function (labelOrSpy) {
return new (this.ctor())(new Debug(this, labelOrSpy));
};
Stream.prototype.imitate = function (target) {
if (target instanceof MemoryStream)
throw new Error('A MemoryStream was given to imitate(), but it only ' +
'supports a Stream. Read more about this restriction here: ' +
'https://github.com/staltz/xstream#faq');
this._target = target;
for (var ils = this._ils, N = ils.length, i = 0; i < N; i++)
target._add(ils[i]);
this._ils = [];
};
Stream.prototype.shamefullySendNext = function (value) {
this._n(value);
};
Stream.prototype.shamefullySendError = function (error) {
this._e(error);
};
Stream.prototype.shamefullySendComplete = function () {
this._c();
};
Stream.prototype.setDebugListener = function (listener) {
if (!listener) {
this._d = false;
this._dl = NO;
}
else {
this._d = true;
listener._n = listener.next || noop;
listener._e = listener.error || noop;
listener._c = listener.complete || noop;
this._dl = listener;
}
};
Stream.merge = function merge() {
var streams = [];
for (var _i = 0; _i < arguments.length; _i++) {
streams[_i] = arguments[_i];
}
return new Stream(new Merge(streams));
};
Stream.combine = function combine() {
var streams = [];
for (var _i = 0; _i < arguments.length; _i++) {
streams[_i] = arguments[_i];
}
return new Stream(new Combine(streams));
};
return Stream;
}());
exports.Stream = Stream;
var MemoryStream = (function (_super) {
__extends(MemoryStream, _super);
function MemoryStream(producer) {
var _this = _super.call(this, producer) || this;
_this._has = false;
return _this;
}
MemoryStream.prototype._n = function (x) {
this._v = x;
this._has = true;
_super.prototype._n.call(this, x);
};
MemoryStream.prototype._add = function (il) {
var ta = this._target;
if (ta)
return ta._add(il);
var a = this._ils;
a.push(il);
if (a.length > 1) {
if (this._has)
il._n(this._v);
return;
}
if (this._stopID !== NO) {
if (this._has)
il._n(this._v);
clearTimeout(this._stopID);
this._stopID = NO;
}
else if (this._has)
il._n(this._v);
else {
var p = this._prod;
if (p !== NO)
p._start(this);
}
};
MemoryStream.prototype._stopNow = function () {
this._has = false;
_super.prototype._stopNow.call(this);
};
MemoryStream.prototype._x = function () {
this._has = false;
_super.prototype._x.call(this);
};
MemoryStream.prototype.map = function (project) {
return this._map(project);
};
MemoryStream.prototype.mapTo = function (projectedValue) {
return _super.prototype.mapTo.call(this, projectedValue);
};
MemoryStream.prototype.take = function (amount) {
return _super.prototype.take.call(this, amount);
};
MemoryStream.prototype.endWhen = function (other) {
return _super.prototype.endWhen.call(this, other);
};
MemoryStream.prototype.replaceError = function (replace) {
return _super.prototype.replaceError.call(this, replace);
};
MemoryStream.prototype.remember = function () {
return this;
};
MemoryStream.prototype.debug = function (labelOrSpy) {
return _super.prototype.debug.call(this, labelOrSpy);
};
return MemoryStream;
}(Stream));
exports.MemoryStream = MemoryStream;
var xs = Stream;
exports.default = xs;
},{"globalthis":4,"symbol-observable/ponyfill":11}],2:[function(require,module,exports){
'use strict';
var keys = require('object-keys');
var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
var toStr = Object.prototype.toString;
var concat = Array.prototype.concat;
var origDefineProperty = Object.defineProperty;
var isFunction = function (fn) {
return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
};
var arePropertyDescriptorsSupported = function () {
var obj = {};
try {
origDefineProperty(obj, 'x', { enumerable: false, value: obj });
for (var _ in obj) {
return false;
}
return obj.x === obj;
} catch (e) {
return false;
}
};
var supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();
var defineProperty = function (object, name, value, predicate) {
if (name in object && (!isFunction(predicate) || !predicate())) {
return;
}
if (supportsDescriptors) {
origDefineProperty(object, name, {
configurable: true,
enumerable: false,
value: value,
writable: true
});
} else {
object[name] = value;
}
};
var defineProperties = function (object, map) {
var predicates = arguments.length > 2 ? arguments[2] : {};
var props = keys(map);
if (hasSymbols) {
props = concat.call(props, Object.getOwnPropertySymbols(map));
}
for (var i = 0; i < props.length; i += 1) {
defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
}
};
defineProperties.supportsDescriptors = !!supportsDescriptors;
module.exports = defineProperties;
},{"object-keys":8}],3:[function(require,module,exports){
'use strict';
if (typeof self !== 'undefined') {
module.exports = self;
} else if (typeof window !== 'undefined') {
module.exports = window;
} else {
module.exports = Function('return this')();
}
},{}],4:[function(require,module,exports){
'use strict';
var defineProperties = require('define-properties');
var implementation = require('./implementation');
var getPolyfill = require('./polyfill');
var shim = require('./shim');
var polyfill = getPolyfill();
var getGlobal = function () { return polyfill; };
defineProperties(getGlobal, {
getPolyfill: getPolyfill,
implementation: implementation,
shim: shim
});
module.exports = getGlobal;
},{"./implementation":3,"./polyfill":5,"./shim":6,"define-properties":2}],5:[function(require,module,exports){
(function (global){
'use strict';
var implementation = require('./implementation');
module.exports = function getPolyfill() {
if (typeof global !== 'object' || !global || global.Math !== Math || global.Array !== Array) {
return implementation;
}
return global;
};
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"./implementation":3}],6:[function(require,module,exports){
'use strict';
var define = require('define-properties');
var getPolyfill = require('./polyfill');
module.exports = function shimGlobal() {
var polyfill = getPolyfill();
if (define.supportsDescriptors) {
var descriptor = Object.getOwnPropertyDescriptor(polyfill, 'globalThis');
if (!descriptor || (descriptor.configurable && (descriptor.enumerable || descriptor.writable || globalThis !== polyfill))) {
Object.defineProperty(polyfill, 'globalThis', {
configurable: true,
enumerable: false,
value: polyfill,
writable: false
});
}
} else if (typeof globalThis !== 'object' || globalThis !== polyfill) {
polyfill.globalThis = polyfill;
}
return polyfill;
};
},{"./polyfill":5,"define-properties":2}],7:[function(require,module,exports){
'use strict';
var keysShim;
if (!Object.keys) {
var has = Object.prototype.hasOwnProperty;
var toStr = Object.prototype.toString;
var isArgs = require('./isArguments');
var isEnumerable = Object.prototype.propertyIsEnumerable;
var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
var dontEnums = [
'toString',
'toLocaleString',
'valueOf',
'hasOwnProperty',
'isPrototypeOf',
'propertyIsEnumerable',
'constructor'
];
var equalsConstructorPrototype = function (o) {
var ctor = o.constructor;
return ctor && ctor.prototype === o;
};
var excludedKeys = {
$applicationCache: true,
$console: true,
$external: true,
$frame: true,
$frameElement: true,
$frames: true,
$innerHeight: true,
$innerWidth: true,
$onmozfullscreenchange: true,
$onmozfullscreenerror: true,
$outerHeight: true,
$outerWidth: true,
$pageXOffset: true,
$pageYOffset: true,
$parent: true,
$scrollLeft: true,
$scrollTop: true,
$scrollX: true,
$scrollY: true,
$self: true,
$webkitIndexedDB: true,
$webkitStorageInfo: true,
$window: true
};
var hasAutomationEqualityBug = (function () {
if (typeof window === 'undefined') { return false; }
for (var k in window) {
try {
if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
try {
equalsConstructorPrototype(window[k]);
} catch (e) {
return true;
}
}
} catch (e) {
return true;
}
}
return false;
}());
var equalsConstructorPrototypeIfNotBuggy = function (o) {
if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
return equalsConstructorPrototype(o);
}
try {
return equalsConstructorPrototype(o);
} catch (e) {
return false;
}
};
keysShim = function keys(object) {
var isObject = object !== null && typeof object === 'object';
var isFunction = toStr.call(object) === '[object Function]';
var isArguments = isArgs(object);
var isString = isObject && toStr.call(object) === '[object String]';
var theKeys = [];
if (!isObject && !isFunction && !isArguments) {
throw new TypeError('Object.keys called on a non-object');
}
var skipProto = hasProtoEnumBug && isFunction;
if (isString && object.length > 0 && !has.call(object, 0)) {
for (var i = 0; i < object.length; ++i) {
theKeys.push(String(i));
}
}
if (isArguments && object.length > 0) {
for (var j = 0; j < object.length; ++j) {
theKeys.push(String(j));
}
} else {
for (var name in object) {
if (!(skipProto && name === 'prototype') && has.call(object, name)) {
theKeys.push(String(name));
}
}
}
if (hasDontEnumBug) {
var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
for (var k = 0; k < dontEnums.length; ++k) {
if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
theKeys.push(dontEnums[k]);
}
}
}
return theKeys;
};
}
module.exports = keysShim;
},{"./isArguments":9}],8:[function(require,module,exports){
'use strict';
var slice = Array.prototype.slice;
var isArgs = require('./isArguments');
var origKeys = Object.keys;
var keysShim = origKeys ? function keys(o) { return origKeys(o); } : require('./implementation');
var originalKeys = Object.keys;
keysShim.shim = function shimObjectKeys() {
if (Object.keys) {
var keysWorksWithArguments = (function () {
var args = Object.keys(arguments);
return args && args.length === arguments.length;
}(1, 2));
if (!keysWorksWithArguments) {
Object.keys = function keys(object) {
if (isArgs(object)) {
return originalKeys(slice.call(object));
}
return originalKeys(object);
};
}
} else {
Object.keys = keysShim;
}
return Object.keys || keysShim;
};
module.exports = keysShim;
},{"./implementation":7,"./isArguments":9}],9:[function(require,module,exports){
'use strict';
var toStr = Object.prototype.toString;
module.exports = function isArguments(value) {
var str = toStr.call(value);
var isArgs = str === '[object Arguments]';
if (!isArgs) {
isArgs = str !== '[object Array]' &&
value !== null &&
typeof value === 'object' &&
typeof value.length === 'number' &&
value.length >= 0 &&
toStr.call(value.callee) === '[object Function]';
}
return isArgs;
};
},{}],10:[function(require,module,exports){
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports['default'] = symbolObservablePonyfill;
function symbolObservablePonyfill(root) {
var result;
var _Symbol = root.Symbol;
if (typeof _Symbol === 'function') {
if (_Symbol.observable) {
result = _Symbol.observable;
} else {
result = _Symbol['for']('https://github.com/benlesh/symbol-observable');
try {
_Symbol.observable = result;
} catch (err) {
}
}
} else {
result = '@@observable';
}
return result;
};
},{}],11:[function(require,module,exports){
module.exports = require('./lib/ponyfill');
},{"./lib/ponyfill":10}]},{},[1])(1)
});