multitude/dist/push/classes/assistance/SubscriptionObserver.js

Comprehensive streams for push and pull

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SubscriptionObserver = void 0;

var _helpers = require("../../../helpers");

var _helpers2 = require("../helpers");

var _Hooks = require("./Hooks");

var _typeCore = require("type-core");

function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }

function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }

function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }

function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }

function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }

function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }

function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }

/** @ignore */
const $empty = Symbol('empty');
/** @ignore */

const $subscription = Symbol('subscription');

var _hooks = /*#__PURE__*/new WeakMap();

class SubscriptionObserver {
  constructor(subscription, ...hooks) {
    _classPrivateFieldInitSpec(this, _hooks, {
      writable: true,
      value: void 0
    });

    _classPrivateFieldSet(this, _hooks, _Hooks.Hooks.from(hooks[0]));

    _helpers.Accessor.define(this, $subscription, subscription);
  }

  get closed() {
    return _helpers2.SubscriptionManager.isClosed(this[$subscription]);
  }

  next(value) {
    const subscription = this[$subscription];

    if (_helpers2.SubscriptionManager.isClosed(subscription)) {
      _classPrivateFieldGet(this, _hooks).onStoppedNotification(value, subscription);

      return;
    } // Does not use invoke to improve performance


    const observer = _helpers2.SubscriptionManager.getObserver(subscription);

    let method = $empty;

    try {
      (method = observer.next).call(observer, value);
    } catch (err) {
      if (!_typeCore.TypeGuard.isEmpty(method)) {
        _classPrivateFieldGet(this, _hooks).onUnhandledError(err, subscription);
      }
    }
  }

  error(error) {
    _helpers2.Invoke.observer('error', error, this[$subscription], _classPrivateFieldGet(this, _hooks));
  }

  complete() {
    _helpers2.Invoke.observer('complete', undefined, this[$subscription], _classPrivateFieldGet(this, _hooks));
  }

}

exports.SubscriptionObserver = SubscriptionObserver;
SubscriptionObserver.prototype.constructor = Object;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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