multitude/dist/push/classes/Observable.js

Comprehensive streams for push and pull

"use strict";

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

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

var _typeGuards = require("../utils/type-guards");

var _assistance = require("./assistance");

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

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

require("symbol-observable");

let _Symbol$observable;

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; } }

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

_Symbol$observable = Symbol.observable;

class Observable {
  static of(...items) {
    const Constructor = _typeCore.TypeGuard.isFunction(this) ? this : Observable;
    return _helpers2.From.iterable(Constructor, items);
  }

  static from(item) {
    const Constructor = _typeCore.TypeGuard.isFunction(this) ? this : Observable;

    if (item instanceof Observable) {
      return item.constructor === Constructor ? item : _helpers2.From.like(Constructor, item);
    } else if (item.constructor === Constructor) {
      return item;
    }

    if ((0, _typeGuards.isObservableCompatible)(item)) {
      return _helpers2.From.compatible(Constructor, item);
    }

    if ((0, _typeGuards.isObservableLike)(item)) {
      return _helpers2.From.like(Constructor, item);
    }

    if (_typeCore.TypeGuard.isIterable(item)) {
      return _helpers2.From.iterable(Constructor, item);
    }

    throw new TypeError(`Unable to convert ${typeof item} into a Observable`);
  }

  constructor(subscriber) {
    _classPrivateFieldInitSpec(this, _subscriber, {
      writable: true,
      value: void 0
    });

    if (!_typeCore.TypeGuard.isFunction(subscriber)) {
      throw new TypeError('Expected subscriber to be a function');
    }

    _classPrivateFieldSet(this, _subscriber, subscriber);
  }

  [_Symbol$observable]() {
    return this;
  }

  subscribe(observer, ...arr) {
    let subscriber = _classPrivateFieldGet(this, _subscriber);

    if (_typeCore.TypeGuard.isFunction(observer)) {
      observer = {
        next: observer,
        error: arr[0],
        complete: arr[1]
      };
    } else if (!_typeCore.TypeGuard.isObject(observer)) {
      if (!_typeCore.TypeGuard.isEmpty(observer)) {
        subscriber = () => {
          throw new TypeError(`Expected observer to be an object or a function`);
        };
      }

      observer = {};
    }

    return new _assistance.Subscription(observer, subscriber, _helpers.HooksManager.get());
  }

}

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