@builder.io/sdk 3.0.2-2 → 3.0.3

package/dist/src/classes/observable.class.js

@@ -1,115 +1,110 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.Observable = exports.Observer = exports.BehaviorSubject = exports.Subscription = void 0;
 var Subscription = /** @class */ (function () {
-  function Subscription(listeners, listener) {
-    this.listeners = listeners;
-    this.listener = listener;
-    this.unsubscribed = false;
-    this.otherSubscriptions = [];
-  }
-  Object.defineProperty(Subscription.prototype, 'closed', {
-    get: function () {
-      return this.unsubscribed;
-    },
-    enumerable: false,
-    configurable: true,
-  });
-  Subscription.prototype.add = function (subscription) {
-    this.otherSubscriptions.push(subscription);
-  };
-  Subscription.prototype.unsubscribe = function () {
-    if (this.unsubscribed) {
-      return;
+    function Subscription(listeners, listener) {
+        this.listeners = listeners;
+        this.listener = listener;
+        this.unsubscribed = false;
+        this.otherSubscriptions = [];
     }
-    if (this.listener && this.listeners) {
-      var index = this.listeners.indexOf(this.listener);
-      if (index > -1) {
-        this.listeners.splice(index, 1);
-      }
-    }
-    this.otherSubscriptions.forEach(function (sub) {
-      return sub.unsubscribe();
+    Object.defineProperty(Subscription.prototype, "closed", {
+        get: function () {
+            return this.unsubscribed;
+        },
+        enumerable: false,
+        configurable: true
     });
-    this.unsubscribed = true;
-  };
-  return Subscription;
-})();
+    Subscription.prototype.add = function (subscription) {
+        this.otherSubscriptions.push(subscription);
+    };
+    Subscription.prototype.unsubscribe = function () {
+        if (this.unsubscribed) {
+            return;
+        }
+        if (this.listener && this.listeners) {
+            var index = this.listeners.indexOf(this.listener);
+            if (index > -1) {
+                this.listeners.splice(index, 1);
+            }
+        }
+        this.otherSubscriptions.forEach(function (sub) { return sub.unsubscribe(); });
+        this.unsubscribed = true;
+    };
+    return Subscription;
+}());
 exports.Subscription = Subscription;
 // TODO: follow minimal basic spec: https://github.com/tc39/proposal-observable
 var BehaviorSubject = /** @class */ (function () {
-  function BehaviorSubject(value) {
-    var _this = this;
-    this.value = value;
-    this.listeners = [];
-    this.errorListeners = [];
-    this.then = function () {
-      var _a;
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
-      return (_a = _this.toPromise()).then.apply(_a, args);
-    };
-  }
-  BehaviorSubject.prototype.next = function (value) {
-    this.value = value;
-    for (var _i = 0, _a = this.listeners; _i < _a.length; _i++) {
-      var listener = _a[_i];
-      listener(value);
-    }
-  };
-  // TODO: implement this as PIPE instead
-  BehaviorSubject.prototype.map = function (fn) {
-    var newSubject = new BehaviorSubject(fn(this.value));
-    // TODO: on destroy delete these
-    this.subscribe(function (val) {
-      newSubject.next(fn(val));
-    });
-    this.catch(function (err) {
-      newSubject.error(err);
-    });
-    return newSubject;
-  };
-  BehaviorSubject.prototype.catch = function (errorListener) {
-    this.errorListeners.push(errorListener);
-    return new Subscription(this.errorListeners, errorListener);
-  };
-  BehaviorSubject.prototype.error = function (error) {
-    for (var _i = 0, _a = this.errorListeners; _i < _a.length; _i++) {
-      var listener = _a[_i];
-      listener(error);
-    }
-  };
-  BehaviorSubject.prototype.subscribe = function (listener, errorListener) {
-    this.listeners.push(listener);
-    if (errorListener) {
-      this.errorListeners.push(errorListener);
+    function BehaviorSubject(value) {
+        var _this = this;
+        this.value = value;
+        this.listeners = [];
+        this.errorListeners = [];
+        this.then = function () {
+            var _a;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return (_a = _this.toPromise()).then.apply(_a, args);
+        };
     }
-    return new Subscription(this.listeners, listener);
-  };
-  BehaviorSubject.prototype.toPromise = function () {
-    var _this = this;
-    return new Promise(function (resolve, reject) {
-      var subscription = _this.subscribe(
-        function (value) {
-          resolve(value);
-          subscription.unsubscribe();
-        },
-        function (err) {
-          reject(err);
-          subscription.unsubscribe();
+    BehaviorSubject.prototype.next = function (value) {
+        this.value = value;
+        for (var _i = 0, _a = this.listeners; _i < _a.length; _i++) {
+            var listener = _a[_i];
+            listener(value);
         }
-      );
-    });
-  };
-  BehaviorSubject.prototype.promise = function () {
-    return this.toPromise();
-  };
-  return BehaviorSubject;
-})();
+    };
+    // TODO: implement this as PIPE instead
+    BehaviorSubject.prototype.map = function (fn) {
+        var newSubject = new BehaviorSubject(fn(this.value));
+        // TODO: on destroy delete these
+        this.subscribe(function (val) {
+            newSubject.next(fn(val));
+        });
+        this.catch(function (err) {
+            newSubject.error(err);
+        });
+        return newSubject;
+    };
+    BehaviorSubject.prototype.catch = function (errorListener) {
+        this.errorListeners.push(errorListener);
+        return new Subscription(this.errorListeners, errorListener);
+    };
+    BehaviorSubject.prototype.error = function (error) {
+        for (var _i = 0, _a = this.errorListeners; _i < _a.length; _i++) {
+            var listener = _a[_i];
+            listener(error);
+        }
+    };
+    BehaviorSubject.prototype.subscribe = function (listener, errorListener) {
+        this.listeners.push(listener);
+        if (errorListener) {
+            this.errorListeners.push(errorListener);
+        }
+        return new Subscription(this.listeners, listener);
+    };
+    BehaviorSubject.prototype.toPromise = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var subscription = _this.subscribe(function (value) {
+                resolve(value);
+                subscription.unsubscribe();
+            }, function (err) {
+                reject(err);
+                subscription.unsubscribe();
+            });
+        });
+    };
+    BehaviorSubject.prototype.promise = function () {
+        return this.toPromise();
+    };
+    return BehaviorSubject;
+}());
 exports.BehaviorSubject = BehaviorSubject;
 // TODO: make different classes
 exports.Observer = BehaviorSubject;
 exports.Observable = BehaviorSubject;
-//# sourceMappingURL=observable.class.js.map
+//# sourceMappingURL=observable.class.js.map

package/dist/src/classes/promise.class.js

@@ -1,166 +1,170 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.TinyPromise = void 0;
-var next_tick_function_1 = require('../functions/next-tick.function');
+var next_tick_function_1 = require("../functions/next-tick.function");
 var State = {
-  Pending: 'Pending',
-  Fulfilled: 'Fulfilled',
-  Rejected: 'Rejected',
+    Pending: 'Pending',
+    Fulfilled: 'Fulfilled',
+    Rejected: 'Rejected',
 };
 function isFunction(val) {
-  return val && typeof val === 'function';
+    return val && typeof val === 'function';
 }
 function isObject(val) {
-  return val && typeof val === 'object';
+    return val && typeof val === 'object';
 }
 var TinyPromise = /** @class */ (function () {
-  function TinyPromise(executor) {
-    this._state = State.Pending;
-    this._handlers = [];
-    this._value = null;
-    executor(this._resolve.bind(this), this._reject.bind(this));
-  }
-  TinyPromise.prototype._resolve = function (x) {
-    var _this = this;
-    if (x instanceof TinyPromise) {
-      x.then(this._resolve.bind(this), this._reject.bind(this));
-    } else if (isObject(x) || isFunction(x)) {
-      var called_1 = false;
-      try {
-        var thenable = x.then;
-        if (isFunction(thenable)) {
-          thenable.call(
-            x,
-            function (result) {
-              if (!called_1) _this._resolve(result);
-              called_1 = true;
-              return undefined;
-            },
-            function (error) {
-              if (!called_1) _this._reject(error);
-              called_1 = true;
-              return undefined;
-            }
-          );
-        } else {
-          this._fulfill(x);
-        }
-      } catch (ex) {
-        if (!called_1) {
-          this._reject(ex);
-        }
-      }
-    } else {
-      this._fulfill(x);
+    function TinyPromise(executor) {
+        this._state = State.Pending;
+        this._handlers = [];
+        this._value = null;
+        executor(this._resolve.bind(this), this._reject.bind(this));
     }
-  };
-  TinyPromise.prototype._fulfill = function (result) {
-    var _this = this;
-    this._state = State.Fulfilled;
-    this._value = result;
-    this._handlers.forEach(function (handler) {
-      return _this._callHandler(handler);
-    });
-  };
-  TinyPromise.prototype._reject = function (error) {
-    var _this = this;
-    this._state = State.Rejected;
-    this._value = error;
-    this._handlers.forEach(function (handler) {
-      return _this._callHandler(handler);
-    });
-  };
-  TinyPromise.prototype._isPending = function () {
-    return this._state === State.Pending;
-  };
-  TinyPromise.prototype._isFulfilled = function () {
-    return this._state === State.Fulfilled;
-  };
-  TinyPromise.prototype._isRejected = function () {
-    return this._state === State.Rejected;
-  };
-  TinyPromise.prototype._addHandler = function (onFulfilled, onRejected) {
-    this._handlers.push({
-      onFulfilled: onFulfilled,
-      onRejected: onRejected,
-    });
-  };
-  TinyPromise.prototype._callHandler = function (handler) {
-    if (this._isFulfilled() && isFunction(handler.onFulfilled)) {
-      handler.onFulfilled(this._value);
-    } else if (this._isRejected() && isFunction(handler.onRejected)) {
-      handler.onRejected(this._value);
-    }
-  };
-  TinyPromise.prototype.then = function (onFulfilled, onRejected) {
-    var _this = this;
-    switch (this._state) {
-      case State.Pending: {
-        return new TinyPromise(function (resolve, reject) {
-          _this._addHandler(
-            function (value) {
-              (0, next_tick_function_1.nextTick)(function () {
-                try {
-                  if (isFunction(onFulfilled)) {
-                    resolve(onFulfilled(value));
-                  } else {
-                    resolve(value);
-                  }
-                } catch (ex) {
-                  reject(ex);
+    TinyPromise.prototype._resolve = function (x) {
+        var _this = this;
+        if (x instanceof TinyPromise) {
+            x.then(this._resolve.bind(this), this._reject.bind(this));
+        }
+        else if (isObject(x) || isFunction(x)) {
+            var called_1 = false;
+            try {
+                var thenable = x.then;
+                if (isFunction(thenable)) {
+                    thenable.call(x, function (result) {
+                        if (!called_1)
+                            _this._resolve(result);
+                        called_1 = true;
+                        return undefined;
+                    }, function (error) {
+                        if (!called_1)
+                            _this._reject(error);
+                        called_1 = true;
+                        return undefined;
+                    });
                 }
-              });
-            },
-            function (error) {
-              (0, next_tick_function_1.nextTick)(function () {
-                try {
-                  if (isFunction(onRejected)) {
-                    resolve(onRejected(error));
-                  } else {
-                    reject(error);
-                  }
-                } catch (ex) {
-                  reject(ex);
+                else {
+                    this._fulfill(x);
                 }
-              });
             }
-          );
-        });
-      }
-      case State.Fulfilled: {
-        return new TinyPromise(function (resolve, reject) {
-          (0, next_tick_function_1.nextTick)(function () {
-            try {
-              if (isFunction(onFulfilled)) {
-                resolve(onFulfilled(_this._value));
-              } else {
-                resolve(_this._value);
-              }
-            } catch (ex) {
-              reject(ex);
+            catch (ex) {
+                if (!called_1) {
+                    this._reject(ex);
+                }
             }
-          });
+        }
+        else {
+            this._fulfill(x);
+        }
+    };
+    TinyPromise.prototype._fulfill = function (result) {
+        var _this = this;
+        this._state = State.Fulfilled;
+        this._value = result;
+        this._handlers.forEach(function (handler) { return _this._callHandler(handler); });
+    };
+    TinyPromise.prototype._reject = function (error) {
+        var _this = this;
+        this._state = State.Rejected;
+        this._value = error;
+        this._handlers.forEach(function (handler) { return _this._callHandler(handler); });
+    };
+    TinyPromise.prototype._isPending = function () {
+        return this._state === State.Pending;
+    };
+    TinyPromise.prototype._isFulfilled = function () {
+        return this._state === State.Fulfilled;
+    };
+    TinyPromise.prototype._isRejected = function () {
+        return this._state === State.Rejected;
+    };
+    TinyPromise.prototype._addHandler = function (onFulfilled, onRejected) {
+        this._handlers.push({
+            onFulfilled: onFulfilled,
+            onRejected: onRejected,
         });
-      }
-      case State.Rejected: {
-        return new TinyPromise(function (resolve, reject) {
-          (0, next_tick_function_1.nextTick)(function () {
-            try {
-              if (isFunction(onRejected)) {
-                resolve(onRejected(_this._value));
-              } else {
-                reject(_this._value);
-              }
-            } catch (ex) {
-              reject(ex);
+    };
+    TinyPromise.prototype._callHandler = function (handler) {
+        if (this._isFulfilled() && isFunction(handler.onFulfilled)) {
+            handler.onFulfilled(this._value);
+        }
+        else if (this._isRejected() && isFunction(handler.onRejected)) {
+            handler.onRejected(this._value);
+        }
+    };
+    TinyPromise.prototype.then = function (onFulfilled, onRejected) {
+        var _this = this;
+        switch (this._state) {
+            case State.Pending: {
+                return new TinyPromise(function (resolve, reject) {
+                    _this._addHandler(function (value) {
+                        (0, next_tick_function_1.nextTick)(function () {
+                            try {
+                                if (isFunction(onFulfilled)) {
+                                    resolve(onFulfilled(value));
+                                }
+                                else {
+                                    resolve(value);
+                                }
+                            }
+                            catch (ex) {
+                                reject(ex);
+                            }
+                        });
+                    }, function (error) {
+                        (0, next_tick_function_1.nextTick)(function () {
+                            try {
+                                if (isFunction(onRejected)) {
+                                    resolve(onRejected(error));
+                                }
+                                else {
+                                    reject(error);
+                                }
+                            }
+                            catch (ex) {
+                                reject(ex);
+                            }
+                        });
+                    });
+                });
             }
-          });
-        });
-      }
-    }
-  };
-  return TinyPromise;
-})();
+            case State.Fulfilled: {
+                return new TinyPromise(function (resolve, reject) {
+                    (0, next_tick_function_1.nextTick)(function () {
+                        try {
+                            if (isFunction(onFulfilled)) {
+                                resolve(onFulfilled(_this._value));
+                            }
+                            else {
+                                resolve(_this._value);
+                            }
+                        }
+                        catch (ex) {
+                            reject(ex);
+                        }
+                    });
+                });
+            }
+            case State.Rejected: {
+                return new TinyPromise(function (resolve, reject) {
+                    (0, next_tick_function_1.nextTick)(function () {
+                        try {
+                            if (isFunction(onRejected)) {
+                                resolve(onRejected(_this._value));
+                            }
+                            else {
+                                reject(_this._value);
+                            }
+                        }
+                        catch (ex) {
+                            reject(ex);
+                        }
+                    });
+                });
+            }
+        }
+    };
+    return TinyPromise;
+}());
 exports.TinyPromise = TinyPromise;
-exports.default = typeof Promise !== 'undefined' ? Promise : TinyPromise;
-//# sourceMappingURL=promise.class.js.map
+exports.default = (typeof Promise !== 'undefined' ? Promise : TinyPromise);
+//# sourceMappingURL=promise.class.js.map