zen-observable-ts - npm Package Compare versions

Comparing version 1.0.0 to 1.1.0

module.js

@@ -1,29 +0,576 @@
-import { Observable } from "zen-observable/esm.js";
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
-// When a non-native class constructor function attempts to subclass
-// Observable, compilers like Babel and TypeScript may compile the
-// super(subscriber) expression to Observable.call(this, subscriber) or
-// Observable.apply(this, arguments). Calling a native class constructor
-// in this way is forbidden by the ECMAScript specification, but we can
-// preserve backwards compatibility by overriding the Observable.call and
-// Observable.apply methods with an implementation that calls
-// Reflect.construct instead, when available.
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-Observable.call = function (instance, subscriber) {
-  // Since Observable.call is a static method, 'this' will typically be the
-  // Observable constructor function, though it could be a subclass of the
-  // Observable constructor, which is why we don't just hard-code it here.
-  return construct(this, instance, subscriber);
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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; }
+
+// === Symbol Support ===
+var hasSymbols = function () {
+  return typeof Symbol === 'function';
 };
 
-Observable.apply = function (instance, args) {
-  return construct(this, instance, args[0]);
+var hasSymbol = function (name) {
+  return hasSymbols() && Boolean(Symbol[name]);
 };
 
-function construct(Super, instance, subscriber) {
-  return typeof Reflect === 'object'
-    ? Reflect.construct(Super, [subscriber], instance.constructor)
-    : Function.prototype.call.call(Super, instance, subscriber) || instance;
+var getSymbol = function (name) {
+  return hasSymbol(name) ? Symbol[name] : '@@' + name;
+};
+
+if (hasSymbols() && !hasSymbol('observable')) {
+  Symbol.observable = Symbol('observable');
 }
 
-export { Observable }
+var SymbolIterator = getSymbol('iterator');
+var SymbolObservable = getSymbol('observable');
+var SymbolSpecies = getSymbol('species'); // === Abstract Operations ===
+
+function getMethod(obj, key) {
+  var value = obj[key];
+  if (value == null) return undefined;
+  if (typeof value !== 'function') throw new TypeError(value + ' is not a function');
+  return value;
+}
+
+function getSpecies(obj) {
+  var ctor = obj.constructor;
+
+  if (ctor !== undefined) {
+    ctor = ctor[SymbolSpecies];
+
+    if (ctor === null) {
+      ctor = undefined;
+    }
+  }
+
+  return ctor !== undefined ? ctor : Observable;
+}
+
+function isObservable(x) {
+  return x instanceof Observable; // SPEC: Brand check
+}
+
+function hostReportError(e) {
+  if (hostReportError.log) {
+    hostReportError.log(e);
+  } else {
+    setTimeout(function () {
+      throw e;
+    });
+  }
+}
+
+function enqueue(fn) {
+  Promise.resolve().then(function () {
+    try {
+      fn();
+    } catch (e) {
+      hostReportError(e);
+    }
+  });
+}
+
+function cleanupSubscription(subscription) {
+  var cleanup = subscription._cleanup;
+  if (cleanup === undefined) return;
+  subscription._cleanup = undefined;
+
+  if (!cleanup) {
+    return;
+  }
+
+  try {
+    if (typeof cleanup === 'function') {
+      cleanup();
+    } else {
+      var unsubscribe = getMethod(cleanup, 'unsubscribe');
+
+      if (unsubscribe) {
+        unsubscribe.call(cleanup);
+      }
+    }
+  } catch (e) {
+    hostReportError(e);
+  }
+}
+
+function closeSubscription(subscription) {
+  subscription._observer = undefined;
+  subscription._queue = undefined;
+  subscription._state = 'closed';
+}
+
+function flushSubscription(subscription) {
+  var queue = subscription._queue;
+
+  if (!queue) {
+    return;
+  }
+
+  subscription._queue = undefined;
+  subscription._state = 'ready';
+
+  for (var i = 0; i < queue.length; ++i) {
+    notifySubscription(subscription, queue[i].type, queue[i].value);
+    if (subscription._state === 'closed') break;
+  }
+}
+
+function notifySubscription(subscription, type, value) {
+  subscription._state = 'running';
+  var observer = subscription._observer;
+
+  try {
+    var m = getMethod(observer, type);
+
+    switch (type) {
+      case 'next':
+        if (m) m.call(observer, value);
+        break;
+
+      case 'error':
+        closeSubscription(subscription);
+        if (m) m.call(observer, value);else throw value;
+        break;
+
+      case 'complete':
+        closeSubscription(subscription);
+        if (m) m.call(observer);
+        break;
+    }
+  } catch (e) {
+    hostReportError(e);
+  }
+
+  if (subscription._state === 'closed') cleanupSubscription(subscription);else if (subscription._state === 'running') subscription._state = 'ready';
+}
+
+function onNotify(subscription, type, value) {
+  if (subscription._state === 'closed') return;
+
+  if (subscription._state === 'buffering') {
+    subscription._queue.push({
+      type: type,
+      value: value
+    });
+
+    return;
+  }
+
+  if (subscription._state !== 'ready') {
+    subscription._state = 'buffering';
+    subscription._queue = [{
+      type: type,
+      value: value
+    }];
+    enqueue(function () {
+      return flushSubscription(subscription);
+    });
+    return;
+  }
+
+  notifySubscription(subscription, type, value);
+}
+
+var Subscription = /*#__PURE__*/function () {
+  function Subscription(observer, subscriber) {
+    // ASSERT: observer is an object
+    // ASSERT: subscriber is callable
+    this._cleanup = undefined;
+    this._observer = observer;
+    this._queue = undefined;
+    this._state = 'initializing';
+    var subscriptionObserver = new SubscriptionObserver(this);
+
+    try {
+      this._cleanup = subscriber.call(undefined, subscriptionObserver);
+    } catch (e) {
+      subscriptionObserver.error(e);
+    }
+
+    if (this._state === 'initializing') this._state = 'ready';
+  }
+
+  var _proto = Subscription.prototype;
+
+  _proto.unsubscribe = function unsubscribe() {
+    if (this._state !== 'closed') {
+      closeSubscription(this);
+      cleanupSubscription(this);
+    }
+  };
+
+  _createClass(Subscription, [{
+    key: "closed",
+    get: function () {
+      return this._state === 'closed';
+    }
+  }]);
+
+  return Subscription;
+}();
+
+var SubscriptionObserver = /*#__PURE__*/function () {
+  function SubscriptionObserver(subscription) {
+    this._subscription = subscription;
+  }
+
+  var _proto2 = SubscriptionObserver.prototype;
+
+  _proto2.next = function next(value) {
+    onNotify(this._subscription, 'next', value);
+  };
+
+  _proto2.error = function error(value) {
+    onNotify(this._subscription, 'error', value);
+  };
+
+  _proto2.complete = function complete() {
+    onNotify(this._subscription, 'complete');
+  };
+
+  _createClass(SubscriptionObserver, [{
+    key: "closed",
+    get: function () {
+      return this._subscription._state === 'closed';
+    }
+  }]);
+
+  return SubscriptionObserver;
+}();
+
+var Observable = /*#__PURE__*/function () {
+  function Observable(subscriber) {
+    if (!(this instanceof Observable)) throw new TypeError('Observable cannot be called as a function');
+    if (typeof subscriber !== 'function') throw new TypeError('Observable initializer must be a function');
+    this._subscriber = subscriber;
+  }
+
+  var _proto3 = Observable.prototype;
+
+  _proto3.subscribe = function subscribe(observer) {
+    if (typeof observer !== 'object' || observer === null) {
+      observer = {
+        next: observer,
+        error: arguments[1],
+        complete: arguments[2]
+      };
+    }
+
+    return new Subscription(observer, this._subscriber);
+  };
+
+  _proto3.forEach = function forEach(fn) {
+    var _this = this;
+
+    return new Promise(function (resolve, reject) {
+      if (typeof fn !== 'function') {
+        reject(new TypeError(fn + ' is not a function'));
+        return;
+      }
+
+      function done() {
+        subscription.unsubscribe();
+        resolve();
+      }
+
+      var subscription = _this.subscribe({
+        next: function (value) {
+          try {
+            fn(value, done);
+          } catch (e) {
+            reject(e);
+            subscription.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+    });
+  };
+
+  _proto3.map = function map(fn) {
+    var _this2 = this;
+
+    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
+    var C = getSpecies(this);
+    return new C(function (observer) {
+      return _this2.subscribe({
+        next: function (value) {
+          try {
+            value = fn(value);
+          } catch (e) {
+            return observer.error(e);
+          }
+
+          observer.next(value);
+        },
+        error: function (e) {
+          observer.error(e);
+        },
+        complete: function () {
+          observer.complete();
+        }
+      });
+    });
+  };
+
+  _proto3.filter = function filter(fn) {
+    var _this3 = this;
+
+    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
+    var C = getSpecies(this);
+    return new C(function (observer) {
+      return _this3.subscribe({
+        next: function (value) {
+          try {
+            if (!fn(value)) return;
+          } catch (e) {
+            return observer.error(e);
+          }
+
+          observer.next(value);
+        },
+        error: function (e) {
+          observer.error(e);
+        },
+        complete: function () {
+          observer.complete();
+        }
+      });
+    });
+  };
+
+  _proto3.reduce = function reduce(fn) {
+    var _this4 = this;
+
+    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
+    var C = getSpecies(this);
+    var hasSeed = arguments.length > 1;
+    var hasValue = false;
+    var seed = arguments[1];
+    var acc = seed;
+    return new C(function (observer) {
+      return _this4.subscribe({
+        next: function (value) {
+          var first = !hasValue;
+          hasValue = true;
+
+          if (!first || hasSeed) {
+            try {
+              acc = fn(acc, value);
+            } catch (e) {
+              return observer.error(e);
+            }
+          } else {
+            acc = value;
+          }
+        },
+        error: function (e) {
+          observer.error(e);
+        },
+        complete: function () {
+          if (!hasValue && !hasSeed) return observer.error(new TypeError('Cannot reduce an empty sequence'));
+          observer.next(acc);
+          observer.complete();
+        }
+      });
+    });
+  };
+
+  _proto3.concat = function concat() {
+    var _this5 = this;
+
+    for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
+      sources[_key] = arguments[_key];
+    }
+
+    var C = getSpecies(this);
+    return new C(function (observer) {
+      var subscription;
+      var index = 0;
+
+      function startNext(next) {
+        subscription = next.subscribe({
+          next: function (v) {
+            observer.next(v);
+          },
+          error: function (e) {
+            observer.error(e);
+          },
+          complete: function () {
+            if (index === sources.length) {
+              subscription = undefined;
+              observer.complete();
+            } else {
+              startNext(C.from(sources[index++]));
+            }
+          }
+        });
+      }
+
+      startNext(_this5);
+      return function () {
+        if (subscription) {
+          subscription.unsubscribe();
+          subscription = undefined;
+        }
+      };
+    });
+  };
+
+  _proto3.flatMap = function flatMap(fn) {
+    var _this6 = this;
+
+    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
+    var C = getSpecies(this);
+    return new C(function (observer) {
+      var subscriptions = [];
+
+      var outer = _this6.subscribe({
+        next: function (value) {
+          if (fn) {
+            try {
+              value = fn(value);
+            } catch (e) {
+              return observer.error(e);
+            }
+          }
+
+          var inner = C.from(value).subscribe({
+            next: function (value) {
+              observer.next(value);
+            },
+            error: function (e) {
+              observer.error(e);
+            },
+            complete: function () {
+              var i = subscriptions.indexOf(inner);
+              if (i >= 0) subscriptions.splice(i, 1);
+              completeIfDone();
+            }
+          });
+          subscriptions.push(inner);
+        },
+        error: function (e) {
+          observer.error(e);
+        },
+        complete: function () {
+          completeIfDone();
+        }
+      });
+
+      function completeIfDone() {
+        if (outer.closed && subscriptions.length === 0) observer.complete();
+      }
+
+      return function () {
+        subscriptions.forEach(function (s) {
+          return s.unsubscribe();
+        });
+        outer.unsubscribe();
+      };
+    });
+  };
+
+  _proto3[SymbolObservable] = function () {
+    return this;
+  };
+
+  Observable.from = function from(x) {
+    var C = typeof this === 'function' ? this : Observable;
+    if (x == null) throw new TypeError(x + ' is not an object');
+    var method = getMethod(x, SymbolObservable);
+
+    if (method) {
+      var observable = method.call(x);
+      if (Object(observable) !== observable) throw new TypeError(observable + ' is not an object');
+      if (isObservable(observable) && observable.constructor === C) return observable;
+      return new C(function (observer) {
+        return observable.subscribe(observer);
+      });
+    }
+
+    if (hasSymbol('iterator')) {
+      method = getMethod(x, SymbolIterator);
+
+      if (method) {
+        return new C(function (observer) {
+          enqueue(function () {
+            if (observer.closed) return;
+
+            for (var _iterator = _createForOfIteratorHelperLoose(method.call(x)), _step; !(_step = _iterator()).done;) {
+              var item = _step.value;
+              observer.next(item);
+              if (observer.closed) return;
+            }
+
+            observer.complete();
+          });
+        });
+      }
+    }
+
+    if (Array.isArray(x)) {
+      return new C(function (observer) {
+        enqueue(function () {
+          if (observer.closed) return;
+
+          for (var i = 0; i < x.length; ++i) {
+            observer.next(x[i]);
+            if (observer.closed) return;
+          }
+
+          observer.complete();
+        });
+      });
+    }
+
+    throw new TypeError(x + ' is not observable');
+  };
+
+  Observable.of = function of() {
+    for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      items[_key2] = arguments[_key2];
+    }
+
+    var C = typeof this === 'function' ? this : Observable;
+    return new C(function (observer) {
+      enqueue(function () {
+        if (observer.closed) return;
+
+        for (var i = 0; i < items.length; ++i) {
+          observer.next(items[i]);
+          if (observer.closed) return;
+        }
+
+        observer.complete();
+      });
+    });
+  };
+
+  _createClass(Observable, null, [{
+    key: SymbolSpecies,
+    get: function () {
+      return this;
+    }
+  }]);
+
+  return Observable;
+}();
+
+if (hasSymbols()) {
+  Object.defineProperty(Observable, Symbol('extensions'), {
+    value: {
+      symbol: SymbolObservable,
+      hostReportError: hostReportError
+    },
+    configurable: true
+  });
+}
+
+export { Observable };

package.json

 {
   "name": "zen-observable-ts",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Thin wrapper around zen-observable and @types/zen-observable, to support ESM exports as well as CommonJS exports",
@@ -17,17 +17,22 @@ "license": "MIT",
   "scripts": {
-    "pretest": "rollup -c rollup.config.js",
+    "build": "rollup -c rollup.config.js",
+    "prepare": "npm run build",
+    "pretest": "npm run build && rollup -c rollup.test.config.js",
     "test": "mocha tests/bundle.js"
   },
   "dependencies": {
-    "@types/zen-observable": "^0.8.2",
-    "zen-observable": "^0.8.15"
+    "@types/zen-observable": "0.8.3",
+    "zen-observable": "0.8.15"
   },
   "devDependencies": {
-    "@rollup/plugin-node-resolve": "^11.1.1",
-    "@rollup/plugin-typescript": "^8.1.1",
+    "@babel/core": "^7.14.6",
+    "@babel/preset-env": "^7.14.7",
+    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-node-resolve": "^13.0.0",
+    "@rollup/plugin-typescript": "^8.2.1",
     "@types/chai": "^4.2.14",
     "@types/mocha": "^8.2.0",
-    "@types/node": "^14.14.22",
+    "@types/node": "^16.0.1",
     "chai": "^4.2.0",
-    "mocha": "^8.2.1",
+    "mocha": "^9.0.2",
     "rollup": "^2.38.4",
@@ -34,0 +39,0 @@ "tslib": "^2.1.0",

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

20890

increased by230.17%

Number of package files

11

increased by22.22%

Lines of code

503

increased by1522.58%

Worsened metrics

Dev dependency count

13

increased by30%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• + Added@types/zen-observable@0.8.3(transitive)

• - Removed@types/zen-observable@0.8.7(transitive)

• Updated@types/zen-observable@0.8.3

• Updatedzen-observable@0.8.15