@builder.io/sdk 2.2.7-0 → 2.2.8

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

package/dist/src/classes/query-string.class.js

@@ -1,82 +1,83 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryString = void 0;
 var PROPERTY_NAME_DENY_LIST = Object.freeze(['__proto__', 'prototype', 'constructor']);
 // TODO: unit tests
 var QueryString = /** @class */ (function () {
-  function QueryString() {}
-  QueryString.parseDeep = function (queryString) {
-    var obj = this.parse(queryString);
-    return this.deepen(obj);
-  };
-  QueryString.stringifyDeep = function (obj) {
-    var map = this.flatten(obj);
-    return this.stringify(map);
-  };
-  QueryString.parse = function (queryString) {
-    var query = {};
-    var pairs = (queryString[0] === '?' ? queryString.substr(1) : queryString).split('&');
-    for (var i = 0; i < pairs.length; i++) {
-      var pair = pairs[i].split('=');
-      // TODO: node support?
-      try {
-        query[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1] || '');
-      } catch (error) {
-        // Ignore malformed URI components
-      }
+    function QueryString() {
     }
-    return query;
-  };
-  QueryString.stringify = function (map) {
-    var str = '';
-    for (var key in map) {
-      if (map.hasOwnProperty(key)) {
-        var value = map[key];
-        if (str) {
-          str += '&';
+    QueryString.parseDeep = function (queryString) {
+        var obj = this.parse(queryString);
+        return this.deepen(obj);
+    };
+    QueryString.stringifyDeep = function (obj) {
+        var map = this.flatten(obj);
+        return this.stringify(map);
+    };
+    QueryString.parse = function (queryString) {
+        var query = {};
+        var pairs = (queryString[0] === '?' ? queryString.substr(1) : queryString).split('&');
+        for (var i = 0; i < pairs.length; i++) {
+            var pair = pairs[i].split('=');
+            // TODO: node support?
+            try {
+                query[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1] || '');
+            }
+            catch (error) {
+                // Ignore malformed URI components
+            }
         }
-        str += encodeURIComponent(key) + '=' + encodeURIComponent(value);
-      }
-    }
-    return str;
-  };
-  QueryString.deepen = function (map) {
-    // FIXME; Should be type Tree = Record<string, string | Tree>
-    // requires a typescript upgrade.
-    var output = {};
-    for (var k in map) {
-      var t = output;
-      var parts = k.split('.');
-      var key = parts.pop();
-      for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
-        var part = parts_1[_i];
-        assertAllowedPropertyName(part);
-        t = t[part] = t[part] || {};
-      }
-      t[key] = map[k];
-    }
-    return output;
-  };
-  QueryString.flatten = function (obj, _current, _res) {
-    if (_res === void 0) {
-      _res = {};
-    }
-    for (var key in obj) {
-      var value = obj[key];
-      var newKey = _current ? _current + '.' + key : key;
-      if (value && typeof value === 'object') {
-        this.flatten(value, newKey, _res);
-      } else {
-        _res[newKey] = value;
-      }
-    }
-    return _res;
-  };
-  return QueryString;
-})();
+        return query;
+    };
+    QueryString.stringify = function (map) {
+        var str = '';
+        for (var key in map) {
+            if (map.hasOwnProperty(key)) {
+                var value = map[key];
+                if (str) {
+                    str += '&';
+                }
+                str += encodeURIComponent(key) + '=' + encodeURIComponent(value);
+            }
+        }
+        return str;
+    };
+    QueryString.deepen = function (map) {
+        // FIXME; Should be type Tree = Record<string, string | Tree>
+        // requires a typescript upgrade.
+        var output = {};
+        for (var k in map) {
+            var t = output;
+            var parts = k.split('.');
+            var key = parts.pop();
+            for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+                var part = parts_1[_i];
+                assertAllowedPropertyName(part);
+                t = t[part] = t[part] || {};
+            }
+            t[key] = map[k];
+        }
+        return output;
+    };
+    QueryString.flatten = function (obj, _current, _res) {
+        if (_res === void 0) { _res = {}; }
+        for (var key in obj) {
+            var value = obj[key];
+            var newKey = _current ? _current + '.' + key : key;
+            if (value && typeof value === 'object') {
+                this.flatten(value, newKey, _res);
+            }
+            else {
+                _res[newKey] = value;
+            }
+        }
+        return _res;
+    };
+    return QueryString;
+}());
 exports.QueryString = QueryString;
 function assertAllowedPropertyName(name) {
-  if (PROPERTY_NAME_DENY_LIST.indexOf(name) >= 0)
-    throw new Error('Property name "'.concat(name, '" is not allowed'));
+    if (PROPERTY_NAME_DENY_LIST.indexOf(name) >= 0)
+        throw new Error("Property name \"".concat(name, "\" is not allowed"));
 }
-//# sourceMappingURL=query-string.class.js.map
+//# sourceMappingURL=query-string.class.js.map

package/dist/src/classes/query-string.class.test.js

@@ -1,25 +1,25 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-var query_string_class_1 = require('./query-string.class');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var query_string_class_1 = require("./query-string.class");
 test.each([
-  // prettier-ignore
-  ['__proto__.foo.baz=1'],
-  ['prototype.foo=1'],
+    // prettier-ignore
+    ['__proto__.foo.baz=1'],
+    ['prototype.foo=1'],
 ])('(regression) prototype pollution %#', function (input) {
-  expect(function () {
-    query_string_class_1.QueryString.parseDeep(input);
-  }).toThrowError(/Property name \".*\" is not allowed/);
-  var pollutedObject = {};
-  expect(pollutedObject.foo).toBeUndefined();
+    expect(function () {
+        query_string_class_1.QueryString.parseDeep(input);
+    }).toThrowError(/Property name \".*\" is not allowed/);
+    var pollutedObject = {};
+    expect(pollutedObject.foo).toBeUndefined();
 });
 describe('.parseDeep', function () {
-  test('input string may be prefixed with a question mark', function () {
-    var result = query_string_class_1.QueryString.parseDeep('?foo=1');
-    expect(result).toEqual({ foo: '1' });
-  });
-  test('converts the paths to a single object', function () {
-    var result = query_string_class_1.QueryString.parseDeep('foo.bar.baz=1&foo.boo=2');
-    expect(result).toEqual({ foo: { bar: { baz: '1' }, boo: '2' } });
-  });
+    test('input string may be prefixed with a question mark', function () {
+        var result = query_string_class_1.QueryString.parseDeep('?foo=1');
+        expect(result).toEqual({ foo: '1' });
+    });
+    test('converts the paths to a single object', function () {
+        var result = query_string_class_1.QueryString.parseDeep('foo.bar.baz=1&foo.boo=2');
+        expect(result).toEqual({ foo: { bar: { baz: '1' }, boo: '2' } });
+    });
 });
-//# sourceMappingURL=query-string.class.test.js.map
+//# sourceMappingURL=query-string.class.test.js.map

package/dist/src/functions/assign.function.js

@@ -1,25 +1,25 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.assign = void 0;
 function assign(target) {
-  var args = [];
-  for (var _i = 1; _i < arguments.length; _i++) {
-    args[_i - 1] = arguments[_i];
-  }
-  var to = Object(target);
-  for (var index = 1; index < arguments.length; index++) {
-    var nextSource = arguments[index];
-    if (nextSource != null) {
-      // Skip over if undefined or null
-      for (var nextKey in nextSource) {
-        // Avoid bugs when hasOwnProperty is shadowed
-        if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
-          to[nextKey] = nextSource[nextKey];
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    var to = Object(target);
+    for (var index = 1; index < arguments.length; index++) {
+        var nextSource = arguments[index];
+        if (nextSource != null) {
+            // Skip over if undefined or null
+            for (var nextKey in nextSource) {
+                // Avoid bugs when hasOwnProperty is shadowed
+                if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+                    to[nextKey] = nextSource[nextKey];
+                }
+            }
         }
-      }
     }
-  }
-  return to;
+    return to;
 }
 exports.assign = assign;
-//# sourceMappingURL=assign.function.js.map
+//# sourceMappingURL=assign.function.js.map