@builder.io/sdk/dist/src/builder.class.js

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
require("./polyfills/custom-event-polyfill");
var next_tick_function_1 = require("./functions/next-tick.function");
var query_string_class_1 = require("./classes/query-string.class");
var package_json_1 = require("../package.json");
var observable_class_1 = require("./classes/observable.class");
var fetch_function_1 = require("./functions/fetch.function");
var assign_function_1 = require("./functions/assign.function");
var throttle_function_1 = require("./functions/throttle.function");
var animator_class_1 = require("./classes/animator.class");
var cookies_class_1 = require("./classes/cookies.class");
var omit_function_1 = require("./functions/omit.function");
var get_top_level_domain_1 = require("./functions/get-top-level-domain");
var server_only_require_function_1 = require("./functions/server-only-require.function");
var uuid_1 = require("./functions/uuid");
function datePlusMinutes(minutes) {
    if (minutes === void 0) { minutes = 30; }
    return new Date(Date.now() + minutes * 60000);
}
var isPositiveNumber = function (thing) {
    return typeof thing === 'number' && !isNaN(thing) && thing >= 0;
};
exports.isReactNative = typeof navigator === 'object' && navigator.product === 'ReactNative';
exports.validEnvList = [
    'production',
    'qa',
    'development',
    'dev',
    'cdn-qa',
    'cloud',
    'fast',
    'cdn2',
];
function getQueryParam(url, variable) {
    var query = url.split('?')[1] || '';
    var vars = query.split('&');
    for (var i = 0; i < vars.length; i++) {
        var pair = vars[i].split('=');
        if (decodeURIComponent(pair[0]) === variable) {
            return decodeURIComponent(pair[1]);
        }
    }
    return null;
}
var urlParser = {
    parse: function (url) {
        var parser = document.createElement('a');
        parser.href = url;
        var out = {};
        var props = 'username password host hostname port protocol origin pathname search hash'.split(' ');
        for (var i = props.length; i--;) {
            out[props[i]] = parser[props[i]];
        }
        // IE 11 pathname handling workaround
        // (IE omits preceeding '/', unlike other browsers)
        if ((out.pathname || out.pathname === '') &&
            typeof out.pathname === 'string' &&
            out.pathname.indexOf('/') !== 0) {
            out.pathname = '/' + out.pathname;
        }
        return out;
    },
};
var parse = exports.isReactNative
    ? function () { return ({}); }
    : typeof window === 'object'
        ? urlParser.parse
        : server_only_require_function_1.default('url').parse;
function setCookie(name, value, expires) {
    try {
        var expiresString = '';
        // TODO: need to know if secure server side
        if (expires) {
            expiresString = '; expires=' + expires.toUTCString();
        }
        var secure = exports.isBrowser ? location.protocol === 'https:' : true;
        document.cookie =
            name +
                '=' +
                (value || '') +
                expiresString +
                '; path=/' +
                ("; domain=" + get_top_level_domain_1.getTopLevelDomain(location.hostname)) +
                (secure ? ';secure ; SameSite=None' : '');
    }
    catch (err) {
        console.warn('Could not set cookie', err);
    }
}
function getCookie(name) {
    try {
        return (decodeURIComponent(document.cookie.replace(new RegExp('(?:(?:^|.*;)\\s*' +
            encodeURIComponent(name).replace(/[\-\.\+\*]/g, '\\$&') +
            '\\s*\\=\\s*([^;]*).*$)|^.*$'), '$1')) || null);
    }
    catch (err) {
        console.warn('Could not get cookie', err);
    }
}
function size(object) {
    return Object.keys(object).length;
}
function find(target, callback) {
    var list = target;
    // Makes sures is always has an positive integer as length.
    var length = list.length >>> 0;
    var thisArg = arguments[1];
    for (var i = 0; i < length; i++) {
        var element = list[i];
        if (callback.call(thisArg, element, i, list)) {
            return element;
        }
    }
}
var sessionStorageKey = 'builderSessionId';
var localStorageKey = 'builderVisitorId';
exports.isBrowser = typeof window !== 'undefined' && !exports.isReactNative;
exports.isIframe = exports.isBrowser && window.top !== window.self;
function BuilderComponent(info) {
    if (info === void 0) { info = {}; }
    return Builder.Component(info);
}
exports.BuilderComponent = BuilderComponent;
var Builder = /** @class */ (function () {
    function Builder(apiKey, request, response, forceNewInstance) {
        var _this = this;
        if (apiKey === void 0) { apiKey = null; }
        if (forceNewInstance === void 0) { forceNewInstance = false; }
        this.request = request;
        this.response = response;
        this.authToken = '';
        this.eventsQueue = [];
        this.throttledClearEventsQueue = throttle_function_1.throttle(function () {
            _this.processEventsQueue();
            // Extend the session cookie
            _this.setCookie(sessionStorageKey, _this.sessionId, datePlusMinutes(30));
        }, 100);
        this.env = 'production';
        this.sessionId = this.getSessionId();
        this.targetContent = true;
        this.cookies = null;
        // TODO: api options object
        this.cachebust = false;
        this.overrideParams = '';
        this.noCache = false;
        this.preview = false;
        this.canTrack$ = new observable_class_1.BehaviorSubject(!this.browserTrackingDisabled);
        this.apiKey$ = new observable_class_1.BehaviorSubject(null);
        this.userAttributesChanged = new observable_class_1.BehaviorSubject(null);
        this.editingMode$ = new observable_class_1.BehaviorSubject(exports.isIframe);
        // TODO: decorator to do this stuff with the get/set (how do with typing too? compiler?)
        this.editingModel$ = new observable_class_1.BehaviorSubject(null);
        this.userAgent = (typeof navigator === 'object' && navigator.userAgent) || '';
        // Set this to control the userId
        // TODO: allow changing it mid session and updating existing data to be associated
        // e.g. for when a user navigates and then logs in
        this.visitorId = this.getVisitorId();
        this.autoTrack = !Builder.isBrowser
            ? false
            : !this.isDevelopmentEnv &&
                !(Builder.isBrowser && location.search.indexOf('builder.preview=') !== -1);
        this.useNewContentApi = false;
        this.blockContentLoading = '';
        this.observersByKey = {};
        this.overrides = {};
        this.getContentQueue = null;
        this.priorContentQueue = null;
        this.testCookiePrefix = 'builder.tests';
        this.cookieQueue = [];
        // TODO: use a window variable for this perhaps, e.g. bc webcomponents may be loading builder twice
        // with it's and react (use rollup build to fix)
        if (Builder.isBrowser && !forceNewInstance && Builder.singletonInstance) {
            return Builder.singletonInstance;
        }
        if (this.request && this.response) {
            this.setUserAgent(this.request.headers['user-agent'] || '');
            this.cookies = new cookies_class_1.default(this.request, this.response);
        }
        if (apiKey) {
            this.apiKey = apiKey;
        }
        if (exports.isBrowser) {
            this.bindMessageListeners();
            // TODO: postmessage to parent the builder info for every package
            // type: 'builder.sdk', data: { name: '@builder.io/react', version: '0.1.23' }
            // (window as any).BUILDER_VERSION = Builder.VERSION;
            // Ensure always one Builder global singleton
            // TODO: some people won't want this, e.g. rakuten
            // Maybe hide this behind symbol or on document, etc
            // if ((window as any).Builder) {
            //   Builder.components = (window as any).Builder.components;
            // } else {
            //   (window as any).Builder = Builder;
            // }
        }
        if (exports.isIframe) {
            this.messageFrameLoaded();
        }
        // TODO: on destroy clear subscription
        this.canTrack$.subscribe(function (value) {
            if (value) {
                if (typeof sessionStorage !== 'undefined') {
                    try {
                        if (!sessionStorage.getItem(sessionStorageKey)) {
                            sessionStorage.setItem(sessionStorageKey, _this.sessionId);
                        }
                    }
                    catch (err) {
                        console.debug('Session storage error', err);
                    }
                }
                if (_this.eventsQueue.length) {
                    _this.throttledClearEventsQueue();
                }
                if (_this.cookieQueue.length) {
                    _this.cookieQueue.forEach(function (item) {
                        _this.setCookie(item[0], item[1]);
                    });
                    _this.cookieQueue.length = 0;
                }
            }
        });
        if (exports.isBrowser) {
            // TODO: defer so subclass constructor runs and injects location service
            this.setTestsFromUrl();
            // TODO: do this on every request send?
            this.getOverridesFromQueryString();
        }
    }
    Builder.register = function (type, info) {
        // TODO: all must have name and can't conflict?
        var typeList = this.registry[type];
        if (!typeList) {
            typeList = this.registry[type] = [];
        }
        typeList.push(info);
        if (Builder.isBrowser) {
            var message = {
                type: 'builder.register',
                data: {
                    type: type,
                    info: info,
                },
            };
            try {
                parent.postMessage(message, '*');
                if (parent !== window) {
                    window.postMessage(message, '*');
                }
            }
            catch (err) {
                console.debug('Could not postmessage', err);
            }
        }
        this.registryChange.next(this.registry);
    };
    Builder.registerEditor = function (info) {
        if (Builder.isBrowser) {
            window.postMessage({
                type: 'builder.registerEditor',
                data: omit_function_1.omit(info, 'component'),
            }, '*');
            var host = location.host;
            if (!(host === 'localhost:1234' || host.indexOf('builder.io') !== -1)) {
                console.error('Builder.registerEditor() called in the wrong environment! You cannot load custom editors from your app, they must be loaded through the Builder.io app itself. Follow the readme here for more details: https://github.com/builderio/builder/tree/master/plugins/cloudinary or contact chat us in our Spectrum community for help: https://spectrum.chat/builder');
            }
        }
        this.editors.push(info);
    };
    Builder.registerPlugin = function (info) {
        this.plugins.push(info);
    };
    Builder.registerAction = function (action) {
        this.actions.push(action);
    };
    Builder.runAction = function (action) {
        // TODO
        var actionObject = typeof action === 'string' ? find(this.actions, function (item) { return item.name === action; }) : action;
        if (!actionObject) {
            throw new Error("Action not found: " + action);
        }
    };
    Builder.fields = function (name, fields) {
        var _a;
        (_a = window.parent) === null || _a === void 0 ? void 0 : _a.postMessage({
            type: 'builder.fields',
            data: { name: name, fields: fields },
        }, '*');
    };
    Builder.set = function (settings) {
        if (Builder.isBrowser) {
            // TODO: merge
            Object.assign(this.settings, settings);
            var message = {
                type: 'builder.settingsChange',
                data: this.settings,
            };
            parent.postMessage(message, '*');
        }
        this.settingsChange.next(this.settings);
    };
    Builder.import = function (packageName) {
        if (!Builder.isBrowser) {
            // TODO: server side support *maybe*
            console.warn('Builder.import used on the server - this should only be used in the browser');
            return;
        }
        var System = window.System;
        if (!System) {
            console.warn('System.js not available. Please include System.js when using Builder.import');
            return;
        }
        return System.import("https://cdn.builder.io/systemjs/" + packageName);
    };
    Object.defineProperty(Builder, "editingPage", {
        // useCdnApi = false;
        get: function () {
            return this._editingPage;
        },
        set: function (editingPage) {
            this._editingPage = editingPage;
            if (exports.isBrowser && exports.isIframe) {
                if (editingPage) {
                    document.body.classList.add('builder-editing-page');
                }
                else {
                    document.body.classList.remove('builder-editing-page');
                }
            }
        },
        enumerable: true,
        configurable: true
    });
    Builder.prepareComponentSpecToSend = function (spec) {
        return __assign(__assign(__assign({}, spec), (spec.inputs && {
            inputs: spec.inputs.map(function (input) {
                var _a;
                // TODO: do for nexted fields too
                // TODO: probably just convert all functions, not just
                // TODO: put this in input hooks: { onChange: ..., showIf: ... }
                var keysToConvertFnToString = ['onChange', 'showIf'];
                for (var _i = 0, keysToConvertFnToString_1 = keysToConvertFnToString; _i < keysToConvertFnToString_1.length; _i++) {
                    var key = keysToConvertFnToString_1[_i];
                    if (input[key] && typeof input[key] === 'function') {
                        var fn = input[key];
                        input = __assign(__assign({}, input), (_a = {}, _a[key] = "return (" + fn.toString() + ").apply(this, arguments)", _a));
                    }
                }
                return input;
            }),
        })), { hooks: Object.keys(spec.hooks || {}).reduce(function (memo, key) {
                var value = spec.hooks && spec.hooks[key];
                if (!value) {
                    return memo;
                }
                if (typeof value === 'string') {
                    memo[key] = value;
                }
                else {
                    memo[key] = "return (" + value.toString() + ").apply(this, arguments)";
                }
                return memo;
            }, {}), class: undefined });
    };
    // static registerComponent(...) { .. }
    Builder.registerComponent = function (component, options) {
        var _a;
        var spec = __assign(__assign({ class: component }, component.builderOptions), options);
        this.addComponent(spec);
        if (exports.isBrowser) {
            var sendSpec = this.prepareComponentSpecToSend(spec);
            (_a = window.parent) === null || _a === void 0 ? void 0 : _a.postMessage({
                type: 'builder.registerComponent',
                data: sendSpec,
            }, '*');
        }
    };
    Builder.addComponent = function (component) {
        var current = find(this.components, function (item) { return item.name === component.name; });
        if (current) {
            // FIXME: why does sometimes we get an extra post without class - probably
            // from postMessage handler wrong in some place
            if (current.class && !component.class) {
                return;
            }
            this.components.splice(this.components.indexOf(current), 1, component);
        }
        else {
            this.components.push(component);
        }
    };
    // TODO: style guide, etc off this system as well?
    Builder.component = function (info) {
        var _this = this;
        if (info === void 0) { info = {}; }
        return function (component) {
            var _a;
            var spec = __assign(__assign({}, info), { class: component });
            if (!spec.name) {
                spec.name = component.name;
            }
            _this.addComponent(spec);
            var sendSpec = _this.prepareComponentSpecToSend(spec);
            // TODO: serialize component name and inputs
            if (exports.isBrowser) {
                (_a = window.parent) === null || _a === void 0 ? void 0 : _a.postMessage({
                    type: 'builder.registerComponent',
                    data: sendSpec,
                }, '*');
            }
            return component;
        };
    };
    Object.defineProperty(Builder, "Component", {
        get: function () {
            return this.component;
        },
        enumerable: true,
        configurable: true
    });
    Builder.prototype.processEventsQueue = function () {
        if (!this.eventsQueue.length) {
            return;
        }
        var events = this.eventsQueue;
        this.eventsQueue = [];
        var host = this.host;
        fetch_function_1.fetch(host + "/api/v1/track", {
            method: 'POST',
            body: JSON.stringify({ events: events }),
            headers: {
                'content-type': 'application/json',
            },
            mode: 'cors',
        }).catch(function () {
            // Not the end of the world
        });
    };
    Object.defineProperty(Builder.prototype, "browserTrackingDisabled", {
        get: function () {
            return Boolean(Builder.isBrowser && (navigator.doNotTrack === '1' || window.builderNoTrack));
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(Builder.prototype, "canTrack", {
        get: function () {
            return this.canTrack$.value;
        },
        set: function (canTrack) {
            if (this.canTrack !== canTrack) {
                this.canTrack$.next(canTrack);
            }
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(Builder.prototype, "editingMode", {
        get: function () {
            return this.editingMode$.value;
        },
        set: function (value) {
            if (value !== this.editingMode) {
                this.editingMode$.next(value);
            }
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(Builder.prototype, "editingModel", {
        get: function () {
            return this.editingModel$.value;
        },
        set: function (value) {
            if (value !== this.editingModel) {
                this.editingModel$.next(value);
            }
        },
        enumerable: true,
        configurable: true
    });
    Builder.prototype.findParentElement = function (target, callback, checkElement) {
        if (checkElement === void 0) { checkElement = true; }
        if (!(target instanceof HTMLElement)) {
            return null;
        }
        var parent = checkElement ? target : target.parentElement;
        do {
            if (!parent) {
                return null;
            }
            var matches = callback(parent);
            if (matches) {
                return parent;
            }
        } while ((parent = parent.parentElement));
        return null;
    };
    Builder.prototype.findBuilderParent = function (target) {
        return this.findParentElement(target, function (el) {
            var id = el.getAttribute('builder-id') || el.id;
            return Boolean(id && id.indexOf('builder-') === 0);
        });
    };
    Builder.prototype.setUserAgent = function (userAgent) {
        this.userAgent = userAgent || '';
    };
    Builder.prototype.track = function (eventName, properties) {
        if (properties === void 0) { properties = {}; }
        // TODO: queue up track requests and fire them off when canTrack set to true - otherwise may get lots of clicks with no impressions
        if (exports.isIframe || !exports.isBrowser || Builder.isPreviewing) {
            return;
        }
        // batch events
        this.eventsQueue.push({
            type: eventName,
            data: __assign(__assign({}, omit_function_1.omit(properties, 'meta')), { metadata: __assign(__assign({ sdkVersion: Builder.VERSION, url: location.href }, properties.meta), properties.metadata), ownerId: this.apiKey, userAttributes: this.getUserAttributes(), sessionId: this.sessionId, visitorId: this.visitorId }),
        });
        if (this.canTrack) {
            this.throttledClearEventsQueue();
        }
    };
    Builder.prototype.getSessionId = function () {
        var sessionId = null;
        try {
            if (Builder.isBrowser && typeof sessionStorage !== 'undefined') {
                sessionId = this.getCookie(sessionStorageKey);
            }
        }
        catch (err) {
            console.debug('Session storage error', err);
            // It's ok
        }
        if (!sessionId) {
            sessionId = uuid_1.uuid();
        }
        // Give the app a second to start up and set canTrack to false if needed
        if (Builder.isBrowser) {
            this.setCookie(sessionStorageKey, sessionId, datePlusMinutes(30));
        }
        return sessionId;
    };
    Builder.prototype.getVisitorId = function () {
        var _this = this;
        if (this.visitorId) {
            return this.visitorId;
        }
        var visitorId = null;
        try {
            if (Builder.isBrowser && typeof localStorage !== 'undefined') {
                // TODO: cookie instead?
                visitorId = localStorage.getItem(localStorageKey);
            }
        }
        catch (err) {
            console.debug('Local storage error', err);
            // It's ok
        }
        if (!visitorId) {
            visitorId = uuid_1.uuid();
        }
        this.visitorId = visitorId;
        // Give the app a second to start up and set canTrack to false if needed
        if (Builder.isBrowser) {
            setTimeout(function () {
                try {
                    if (_this.canTrack && typeof localStorage !== 'undefined' && visitorId) {
                        localStorage.setItem(localStorageKey, visitorId);
                    }
                }
                catch (err) {
                    console.debug('Session storage error', err);
                }
            });
        }
        return visitorId;
    };
    Builder.prototype.trackImpression = function (contentId, variationId) {
        if (exports.isIframe || !exports.isBrowser || Builder.isPreviewing) {
            return;
        }
        // TODO: use this.track method
        this.eventsQueue.push({
            type: 'impression',
            data: {
                contentId: contentId,
                variationId: variationId !== contentId ? variationId : undefined,
                ownerId: this.apiKey,
                userAttributes: this.getUserAttributes(),
                sessionId: this.sessionId,
                visitorId: this.visitorId,
            },
        });
        this.throttledClearEventsQueue();
    };
    Builder.prototype.trackConversion = function (amount, contentId, variationId, customProperties) {
        if (exports.isIframe || !exports.isBrowser || Builder.isPreviewing) {
            return;
        }
        var meta = typeof contentId === 'object' ? contentId : customProperties;
        var useContentId = typeof contentId === 'string' ? contentId : undefined;
        // TODO: use this.track method
        this.eventsQueue.push({
            type: 'conversion',
            data: {
                amount: amount,
                variationId: variationId,
                meta: meta,
                contentId: useContentId,
                ownerId: this.apiKey,
                userAttributes: this.getUserAttributes(),
                sessionId: this.sessionId,
                visitorId: this.visitorId,
            },
        });
        this.throttledClearEventsQueue();
    };
    Object.defineProperty(Builder.prototype, "isDevelopmentEnv", {
        // TODO: set this for QA
        get: function () {
            // Automatic determining of development environment
            return (Builder.isIframe ||
                (Builder.isBrowser && (location.hostname === 'localhost' || location.port !== '')) ||
                this.env !== 'production');
        },
        enumerable: true,
        configurable: true
    });
    Builder.prototype.trackInteraction = function (contentId, variationId, alreadyTrackedOne, event) {
        if (alreadyTrackedOne === void 0) { alreadyTrackedOne = false; }
        if (exports.isIframe || !exports.isBrowser || Builder.isPreviewing) {
            return;
        }
        var target = event && event.target;
        var targetBuilderElement = target && this.findBuilderParent(target);
        function round(num) {
            return Math.round(num * 1000) / 1000;
        }
        var metadata = {};
        if (event) {
            var clientX = event.clientX, clientY = event.clientY;
            if (target) {
                var targetRect = target.getBoundingClientRect();
                var xOffset = clientX - targetRect.left;
                var yOffset = clientY - targetRect.top;
                var xRatio = round(xOffset / targetRect.width);
                var yRatio = round(yOffset / targetRect.height);
                metadata.targetOffset = {
                    x: xRatio,
                    y: yRatio,
                };
            }
            if (targetBuilderElement) {
                var targetRect = targetBuilderElement.getBoundingClientRect();
                var xOffset = clientX - targetRect.left;
                var yOffset = clientY - targetRect.top;
                var xRatio = round(xOffset / targetRect.width);
                var yRatio = round(yOffset / targetRect.height);
                metadata.builderTargetOffset = {
                    x: xRatio,
                    y: yRatio,
                };
            }
        }
        // let selector: string | undefined = undefined;
        // if (target) {
        //   try {
        //     selector = finder(target);
        //   } catch (err) {
        //     // nbd
        //   }
        // }
        var builderId = targetBuilderElement &&
            (targetBuilderElement.getAttribute('builder-id') || targetBuilderElement.id);
        if (builderId && targetBuilderElement) {
            metadata.builderElementIndex = [].slice
                .call(document.getElementsByClassName(builderId))
                .indexOf(targetBuilderElement);
        }
        // TODO: use this.track method
        this.eventsQueue.push({
            type: 'click',
            data: {
                contentId: contentId,
                metadata: metadata,
                variationId: variationId !== contentId ? variationId : undefined,
                ownerId: this.apiKey,
                unique: !alreadyTrackedOne,
                // targetSelector: selector,
                targetBuilderElement: builderId || undefined,
                userAttributes: this.getUserAttributes(),
                sessionId: this.sessionId,
                visitorId: this.visitorId,
            },
        });
        this.throttledClearEventsQueue();
    };
    Builder.prototype.component = function (info) {
        if (info === void 0) { info = {}; }
        return Builder.component(info);
    };
    Object.defineProperty(Builder.prototype, "apiKey", {
        get: function () {
            return this.apiKey$.value;
        },
        set: function (key) {
            this.apiKey$.next(key);
        },
        enumerable: true,
        configurable: true
    });
    Builder.prototype.modifySearch = function (search) {
        return search.replace(/(^|&|\?)(builder_.*?)=/gi, function (_match, group1, group2) { return group1 + group2.replace(/_/g, '.') + '='; });
    };
    Builder.prototype.setTestsFromUrl = function () {
        var search = this.getLocation().search;
        var params = query_string_class_1.QueryString.parseDeep(this.modifySearch(search || '').substr(1));
        var tests = params.builder && params.builder.tests;
        if (tests && typeof tests === 'object') {
            for (var key in tests) {
                if (tests.hasOwnProperty(key)) {
                    this.setTestCookie(key, tests[key]);
                }
            }
        }
    };
    Builder.prototype.resetOverrides = function () {
        // Ugly - pass down instances per request instead using react context
        // or use builder.get('foo', { req, res }) in react...........
        Builder.overrideUserAttributes = {};
        this.cachebust = false;
        this.noCache = false;
        this.preview = false;
        this.editingModel = null;
        this.overrides = {};
        this.env = 'production';
        this.userAgent = '';
        this.request = undefined;
        this.response = undefined;
    };
    Builder.prototype.getOverridesFromQueryString = function () {
        var location = this.getLocation();
        var params = query_string_class_1.QueryString.parseDeep(this.modifySearch(location.search || '').substr(1));
        var builder = params.builder;
        if (builder) {
            var userAttributes = builder.userAttributes, overrides = builder.overrides, env = builder.env, host = builder.host, api = builder.api, cachebust = builder.cachebust, noCache = builder.noCache, preview = builder.preview, editing = builder.editing, frameEditing = builder.frameEditing, overrideParams = builder.params;
            if (userAttributes) {
                this.setUserAttributes(userAttributes);
            }
            if (overrides) {
                this.overrides = overrides;
            }
            if (exports.validEnvList.indexOf(env || api) > -1) {
                this.env = env || api;
            }
            if (Builder.isEditing) {
                var editingModel = frameEditing || editing || preview;
                if (editingModel && editingModel !== 'true') {
                    this.editingModel = editingModel;
                }
            }
            if (cachebust) {
                this.cachebust = true;
            }
            if (noCache) {
                this.noCache = true;
            }
            if (preview) {
                this.preview = true;
            }
            if (params) {
                this.overrideParams = overrideParams;
            }
        }
    };
    Builder.prototype.messageFrameLoaded = function () {
        var _a;
        (_a = window.parent) === null || _a === void 0 ? void 0 : _a.postMessage({
            type: 'builder.loaded',
            data: {
                value: true,
            },
        }, '*');
    };
    Builder.prototype.bindMessageListeners = function () {
        var _this = this;
        if (exports.isBrowser) {
            addEventListener('message', function (event) {
                var _a, _b, _c, _d, _e;
                var url = parse(event.origin);
                var isRestricted = ['builder.register', 'builder.registerComponent'].indexOf((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === -1;
                if (isRestricted &&
                    !(url.hostname &&
                        (url.hostname === 'builder.io' ||
                            url.hostname.endsWith('.builder.io') ||
                            url.hostname === 'localhost'))) {
                    return;
                }
                var data = event.data;
                if (data) {
                    switch (data.type) {
                        case 'builder.ping': {
                            (_b = window.parent) === null || _b === void 0 ? void 0 : _b.postMessage({
                                type: 'builder.pong',
                                data: {},
                            }, '*');
                            break;
                        }
                        case 'builder.register': {
                            // TODO: possibly do this for all...
                            if (event.source === window) {
                                break;
                            }
                            var options = data.data;
                            if (!options) {
                                break;
                            }
                            var type = options.type, info = options.info;
                            // TODO: all must have name and can't conflict?
                            var typeList = Builder.registry[type];
                            if (!typeList) {
                                typeList = Builder.registry[type] = [];
                            }
                            typeList.push(info);
                            Builder.registryChange.next(Builder.registry);
                            break;
                        }
                        case 'builder.settingsChange': {
                            // TODO: possibly do this for all...
                            if (event.source === window) {
                                break;
                            }
                            var settings = data.data;
                            if (!settings) {
                                break;
                            }
                            Object.assign(Builder.settings, settings);
                            Builder.settingsChange.next(Builder.settings);
                            break;
                        }
                        case 'builder.registerEditor': {
                            // TODO: possibly do this for all...
                            if (event.source === window) {
                                break;
                            }
                            var info_1 = data.data;
                            if (!info_1) {
                                break;
                            }
                            var hasComponent_1 = !!info_1.component;
                            Builder.editors.every(function (thisInfo, index) {
                                if (info_1.name === thisInfo.name) {
                                    if (thisInfo.component && !hasComponent_1) {
                                        return false;
                                    }
                                    else {
                                        Builder.editors[index] = thisInfo;
                                    }
                                    return false;
                                }
                                return true;
                            });
                            break;
                        }
                        case 'builder.triggerAnimation': {
                            Builder.animator.triggerAnimation(data.data);
                            break;
                        }
                        case 'builder.contentUpdate':
                            var key = data.data.key || data.data.alias || data.data.entry || data.data.modelName;
                            var contentData = data.data.data; // hmmm...
                            var observer = _this.observersByKey[key];
                            if (observer) {
                                observer.next([contentData]);
                            }
                            break;
                        case 'builder.getComponents':
                            (_c = window.parent) === null || _c === void 0 ? void 0 : _c.postMessage({
                                type: 'builder.components',
                                data: Builder.components.map(function (item) { return Builder.prepareComponentSpecToSend(item); }),
                            }, '*');
                            break;
                        case 'builder.editingModel':
                            _this.editingModel = data.data.model;
                            break;
                        case 'builder.registerComponent':
                            var componentData = data.data;
                            Builder.addComponent(componentData);
                            break;
                        case 'builder.blockContentLoading':
                            if (typeof data.data.model === 'string') {
                                _this.blockContentLoading = data.data.model;
                            }
                            break;
                        case 'builder.editingMode':
                            var editingMode = data.data;
                            if (editingMode) {
                                _this.editingMode = true;
                                document.body.classList.add('builder-editing');
                            }
                            else {
                                _this.editingMode = false;
                                document.body.classList.remove('builder-editing');
                            }
                            break;
                        case 'builder.editingPageMode':
                            var editingPageMode = data.data;
                            Builder.editingPage = editingPageMode;
                            break;
                        case 'builder.overrideUserAttributes':
                            var userAttributes = data.data;
                            assign_function_1.assign(Builder.overrideUserAttributes, userAttributes);
                            _this.flushGetContentQueue(true);
                            // TODO: refetch too
                            break;
                        case 'builder.overrideTestGroup':
                            var _f = data.data, variationId = _f.variationId, contentId = _f.contentId;
                            if (variationId && contentId) {
                                _this.setTestCookie(contentId, variationId);
                                _this.flushGetContentQueue(true);
                            }
                            break;
                        case 'builder.evaluate': {
                            var text = data.data.text;
                            var args = data.data.arguments || [];
                            var id_1 = data.data.id;
                            // tslint:disable-next-line:no-function-constructor-with-string-args
                            var fn = new Function(text);
                            var result = void 0;
                            var error = null;
                            try {
                                result = fn.apply(_this, args);
                            }
                            catch (err) {
                                error = err;
                            }
                            if (error) {
                                (_d = window.parent) === null || _d === void 0 ? void 0 : _d.postMessage({
                                    type: 'builder.evaluateError',
                                    data: { id: id_1, error: error.message },
                                }, '*');
                            }
                            else {
                                if (result && typeof result.then === 'function') {
                                    result
                                        .then(function (finalResult) {
                                        var _a;
                                        (_a = window.parent) === null || _a === void 0 ? void 0 : _a.postMessage({
                                            type: 'builder.evaluateResult',
                                            data: { id: id_1, result: finalResult },
                                        }, '*');
                                    })
                                        .catch(console.error);
                                }
                                else {
                                    (_e = window.parent) === null || _e === void 0 ? void 0 : _e.postMessage({
                                        type: 'builder.evaluateResult',
                                        data: { result: result, id: id_1 },
                                    }, '*');
                                }
                            }
                            break;
                        }
                    }
                }
            });
        }
    };
    Object.defineProperty(Builder.prototype, "defaultCanTrack", {
        get: function () {
            return Boolean(Builder.isBrowser &&
                navigator.userAgent.trim() &&
                !navigator.userAgent.match(/bot|crawler|spider|robot|crawling|prerender|google|baidu|bing|msn|duckduckbot|teoma|slurp|yandex|phantom|headless|selenium|puppeteer/i) &&
                !this.browserTrackingDisabled);
        },
        enumerable: true,
        configurable: true
    });
    Builder.prototype.init = function (apiKey, canTrack, req, res) {
        if (canTrack === void 0) { canTrack = this.defaultCanTrack; }
        if (req) {
            this.request = req;
        }
        if (res) {
            this.response = res;
        }
        this.canTrack = canTrack;
        this.apiKey = apiKey;
        return this;
    };
    // TODO: allow adding location object as property and/or in constructor
    Builder.prototype.getLocation = function () {
        var parsedLocation = {};
        // in ssr mode
        if (this.request) {
            parsedLocation = parse(this.request.url);
        }
        // in the browser
        if (typeof location === 'object') {
            parsedLocation = parse(location.href);
        }
        // IE11 bug with parsed path being empty string
        // causes issues with our user targeting
        if (parsedLocation.pathname === '') {
            parsedLocation.pathname = '/';
        }
        return parsedLocation;
    };
    Builder.prototype.getUserAttributes = function (userAgent) {
        if (userAgent === void 0) { userAgent = this.userAgent || ''; }
        var isMobile = {
            Android: function () {
                return userAgent.match(/Android/i);
            },
            BlackBerry: function () {
                return userAgent.match(/BlackBerry/i);
            },
            iOS: function () {
                return userAgent.match(/iPhone|iPod/i);
            },
            Opera: function () {
                return userAgent.match(/Opera Mini/i);
            },
            Windows: function () {
                return userAgent.match(/IEMobile/i) || userAgent.match(/WPDesktop/i);
            },
            any: function () {
                return (isMobile.Android() ||
                    isMobile.BlackBerry() ||
                    isMobile.iOS() ||
                    isMobile.Opera() ||
                    isMobile.Windows());
            },
        };
        var isTablet = userAgent.match(/Tablet|iPad/i);
        var url = this.getLocation();
        return __assign({ urlPath: url.pathname, host: url.host || url.hostname, 
            // TODO: maybe an option to choose to target off of mobile/tablet/desktop or just mobile/desktop
            device: isTablet ? 'tablet' : isMobile.any() ? 'mobile' : 'desktop' }, Builder.overrideUserAttributes);
    };
    Builder.prototype.setUserAttributes = function (options) {
        assign_function_1.assign(Builder.overrideUserAttributes, options);
        this.userAttributesChanged.next(options);
    };
    Builder.prototype.get = function (modelName, options) {
        if (options === void 0) { options = {}; }
        var instance = this;
        if (!Builder.isBrowser && (options.req || options.res)) {
            instance = new Builder(options.apiKey || this.apiKey, options.req, options.res);
        }
        else {
            if (options.apiKey && !this.apiKey) {
                this.apiKey = options.apiKey;
            }
        }
        return instance.queueGetContent(modelName, options).map(
        /* map( */ function (matches) {
            var match = matches && matches[0];
            if (Builder.isStatic) {
                return match;
            }
            var matchData = match && match.data;
            if (!matchData) {
                return null;
            }
            if (typeof matchData.blocksString !== 'undefined') {
                matchData.blocks = JSON.parse(matchData.blocksString);
                delete matchData.blocksString;
            }
            return {
                // TODO: add ab test info here and other high level stuff
                data: matchData,
                id: match.id,
                variationId: match.testVariationId || match.variationId,
                testVariationId: match.testVariationId || match.variationId,
                testVariationName: match.testVariationName,
            };
        });
        // );
    };
    // TODO: entry id in options
    Builder.prototype.queueGetContent = function (modelName, options) {
        var _this = this;
        if (options === void 0) { options = {}; }
        // TODO: if query do modelName + query
        var key = options.key ||
            options.alias ||
            // TODO: SDKs only pass entry key when given to them, and never when editing...
            // options.entry ||
            // TODO: this is ugly - instead of multiple of same model with different options are sent
            // say requires key/alias. Or if not perhaps make a reliable hash of the options and use that.
            // TODO: store last user state on last request and if user attributes different now
            // give a warning that need to use keys to request new contente
            // (options &&
            //   Object.keys(options).filter(key => key !== 'model').length &&
            //   JSON.stringify({ model: modelName, ...options, initialContent: undefined })) ||
            modelName;
        var isEditingThisModel = this.editingModel === modelName;
        // TODO: include params in this key........
        var currentObservable = this.observersByKey[key];
        // if (options.query && options.query._id) {
        //   this.flushGetContentQueue([options])
        // }
        if (this.apiKey === 'DEMO' && !this.overrides[key] && !options.initialContent) {
            options.initialContent = [];
        }
        var initialContent = options.initialContent;
        // TODO: refresh option in options
        if (currentObservable && (!currentObservable.value || options.cache)) {
            // TODO: test if this ran, otherwise on 404 some observers may never be called...
            if (currentObservable.value) {
                next_tick_function_1.nextTick(function () {
                    // TODO: return a new observable and only that one fires subscribers, don't refire for existing ones
                    currentObservable.next(currentObservable.value);
                });
            }
            return currentObservable;
        }
        if (isEditingThisModel) {
            if (Builder.isBrowser) {
                parent.postMessage({ type: 'builder.updateContent' }, '*');
            }
        }
        if (!initialContent /* || isEditingThisModel */) {
            if (!this.getContentQueue) {
                this.getContentQueue = [];
            }
            this.getContentQueue.push(__assign(__assign({}, options), { model: modelName, key: key }));
            if (this.getContentQueue && this.getContentQueue.length >= 5) {
                this.flushGetContentQueue();
            }
            else {
                next_tick_function_1.nextTick(function () {
                    _this.flushGetContentQueue();
                });
            }
        }
        var observable = new observable_class_1.BehaviorSubject(null);
        this.observersByKey[key] = observable;
        if (initialContent) {
            next_tick_function_1.nextTick(function () {
                // TODO: need to testModify this I think...?
                observable.next(initialContent);
            });
        }
        return observable;
    };
    Builder.prototype.requestUrl = function (url) {
        if (Builder.isBrowser) {
            // TODO: send auth header if builder.authToken
            return fetch_function_1.fetch(url, this.authToken
                ? {
                    headers: {
                        Authorization: "Bearer " + this.authToken,
                    },
                }
                : undefined).then(function (res) { return res.json(); });
        }
        return new Promise(function (resolve, reject) {
            var module = url.indexOf('http:') === 0 ? server_only_require_function_1.default('http') : server_only_require_function_1.default('https');
            module
                .get(url, function (resp) {
                var data = '';
                // A chunk of data has been recieved.
                resp.on('data', function (chunk) {
                    data += chunk;
                });
                // The whole response has been received. Print out the result.
                resp.on('end', function () {
                    resolve(JSON.parse(data));
                });
            })
                .on('error', function (error) {
                reject(error);
            });
        });
    };
    Object.defineProperty(Builder.prototype, "host", {
        get: function () {
            if (this.env.includes('//')) {
                return this.env;
            }
            if (this.env.includes('.')) {
                return 'http://' + this.env;
            }
            switch (this.env) {
                case 'qa':
                    return 'https://qa.builder.io';
                case 'fast':
                    return 'https://fast.builder.io';
                case 'cloud':
                    return 'https://cloud.builder.io';
                case 'cdn2':
                    return 'https://cdn2.builder.io';
                case 'cdn-qa':
                    return 'https://cdn-qa.builder.io';
                case 'development':
                case 'dev':
                    return 'http://localhost:5000';
                default:
                    return 'https://cdn.builder.io';
            }
        },
        enumerable: true,
        configurable: true
    });
    Builder.prototype.flushGetContentQueue = function (usePastQueue, useQueue) {
        var _this = this;
        if (usePastQueue === void 0) { usePastQueue = false; }
        if (!this.apiKey) {
            throw new Error('Builder needs to be initialized with an API key!');
        }
        if (!usePastQueue && !this.getContentQueue) {
            return;
        }
        var queue = useQueue || (usePastQueue ? this.priorContentQueue : this.getContentQueue) || [];
        // TODO: do this on every request send?
        this.getOverridesFromQueryString();
        var queryParams = {
            omit: 'meta.componentsUsed',
            apiKey: this.apiKey,
        };
        var pageQueryParams = typeof location !== 'undefined'
            ? query_string_class_1.QueryString.parseDeep(location.search.substr(1))
            : undefined || {};
        var userAttributes = 
        // FIXME: HACK: only checks first in queue for user attributes overrides, should check all
        // TODO: merge user attributes provided here with defaults and current user attiributes (?)
        queue && queue[0].userAttributes
            ? queue[0].userAttributes
            : this.targetContent
                ? this.getUserAttributes()
                : {
                    urlPath: this.getLocation().pathname,
                };
        var fullUrlQueueItem = queue.find(function (item) { return !!item.includeUrl; });
        if (fullUrlQueueItem) {
            var location_1 = this.getLocation();
            if (location_1.origin) {
                queryParams.url = "" + location_1.origin + location_1.pathname + location_1.search;
            }
        }
        var urlQueueItem = useQueue === null || useQueue === void 0 ? void 0 : useQueue.find(function (item) { return item.url; });
        if (urlQueueItem === null || urlQueueItem === void 0 ? void 0 : urlQueueItem.url) {
            userAttributes.urlPath = urlQueueItem.url.split('?')[0];
        }
        // TODO: merge in the attribute from query string ones
        // TODO: make this an option per component/request
        queryParams.userAttributes = Builder.useNewApi
            ? userAttributes
            : JSON.stringify(userAttributes);
        if (!usePastQueue && !useQueue) {
            this.priorContentQueue = queue;
            this.getContentQueue = null;
        }
        var cachebust = this.cachebust ||
            exports.isIframe ||
            pageQueryParams.cachebust ||
            pageQueryParams['builder.cachebust'];
        if (cachebust || this.env !== 'production') {
            queryParams.cachebust = true;
        }
        if (Builder.isEditing) {
            queryParams.isEditing = true;
        }
        if (this.noCache || this.env !== 'production') {
            queryParams.noCache = true;
        }
        if (size(this.overrides)) {
            for (var key in this.overrides) {
                if (this.overrides.hasOwnProperty(key)) {
                    queryParams["overrides." + key] = this.overrides[key];
                }
            }
        }
        if (Builder.useNewApi && !Builder.isReact) {
            // TODO: remove me once v1 page editors converted to v2
            // queryParams.extractCss = true;
            queryParams.prerender = true;
        }
        if (Builder.useNewApi) {
            for (var _i = 0, queue_1 = queue; _i < queue_1.length; _i++) {
                var options = queue_1[_i];
                if (options.format) {
                    queryParams.format = options.format;
                }
                // TODO: remove me and make permodel
                if (options.static) {
                    queryParams.static = options.static;
                }
                if (options.cachebust) {
                    queryParams.cachebust = options.cachebust;
                }
                if (isPositiveNumber(options.cacheSeconds)) {
                    queryParams.cacheSeconds = options.cacheSeconds;
                }
                if (isPositiveNumber(options.staleCacheSeconds)) {
                    queryParams.staleCacheSeconds = options.staleCacheSeconds;
                }
                var properties = [
                    'prerender',
                    'extractCss',
                    'limit',
                    'offset',
                    'query',
                    'preview',
                    'model',
                    'entry',
                    'rev',
                    'static',
                ];
                for (var _a = 0, properties_1 = properties; _a < properties_1.length; _a++) {
                    var key = properties_1[_a];
                    var value = options[key];
                    if (value !== undefined) {
                        queryParams.options = queryParams.options || {};
                        queryParams.options[options.key] = queryParams.options[options.key] || {};
                        queryParams.options[options.key][key] = JSON.stringify(value);
                    }
                }
            }
        }
        if (this.preview) {
            queryParams.preview = 'true';
        }
        var hasParams = Object.keys(queryParams).length > 0;
        // TODO: option to force dev or qa api here
        var host = this.useNewContentApi ? 'https://lambda.builder.codes' : this.host;
        var keyNames = queue.map(function (item) { return encodeURIComponent(item.key); }).join(',');
        if (this.overrideParams) {
            var params = omit_function_1.omit(query_string_class_1.QueryString.parse(this.overrideParams), 'apiKey');
            assign_function_1.assign(queryParams, params);
        }
        var queryStr = Builder.useNewApi
            ? query_string_class_1.QueryString.stringifyDeep(queryParams)
            : query_string_class_1.QueryString.stringify(queryParams);
        var promise = this.requestUrl(host + "/api/v1/" + (Builder.useNewApi ? 'query' : 'content') + "/" + this.apiKey + "/" + keyNames +
            (queryParams && hasParams ? "?" + queryStr : '')).then(function (result) {
            for (var _i = 0, queue_2 = queue; _i < queue_2.length; _i++) {
                var options = queue_2[_i];
                var keyName = options.key;
                if (options.model === _this.blockContentLoading) {
                    continue;
                }
                var isEditingThisModel = _this.editingModel === options.model;
                if (isEditingThisModel && Builder.isEditing) {
                    parent.postMessage({ type: 'builder.updateContent' }, '*');
                    // return;
                }
                var observer = _this.observersByKey[keyName];
                if (!observer) {
                    return;
                }
                var data = result[keyName];
                var sorted = data; // sortBy(data, item => item.priority);
                if (data) {
                    var testModifiedResults = Builder.isStatic
                        ? sorted
                        : _this.processResultsForTests(sorted);
                    observer.next(testModifiedResults);
                }
                else {
                    var search = _this.getLocation().search;
                    if ((search || '').includes('builder.preview=' + options.model)) {
                        var previewData = {
                            id: 'preview',
                            name: 'Preview',
                            data: {},
                        };
                        observer.next([previewData]);
                    }
                    observer.next([]);
                }
            }
        }, function (err) {
            for (var _i = 0, queue_3 = queue; _i < queue_3.length; _i++) {
                var options = queue_3[_i];
                var observer = _this.observersByKey[options.key];
                if (!observer) {
                    return;
                }
                observer.error(err);
            }
        });
        return promise;
    };
    Builder.prototype.processResultsForTests = function (results) {
        var _this = this;
        var _a;
        var mappedResults = results.map(function (item) {
            if (!item.variations) {
                return item;
            }
            var cookieValue = _this.getTestCookie(item.id);
            var cookieVariation = cookieValue === item.id ? item : item.variations[cookieValue];
            if (cookieVariation) {
                return __assign(__assign({}, item), { data: cookieVariation.data, variationId: cookieValue, testVariationId: cookieValue, testVariationName: cookieVariation.name });
            }
            if (item.variations && size(item.variations)) {
                var n = 0;
                var random = Math.random();
                for (var id in item.variations) {
                    var variation = item.variations[id];
                    var testRatio = variation.testRatio;
                    n += testRatio;
                    if (random < n) {
                        _this.setTestCookie(item.id, variation.id);
                        var variationName = variation.name || (variation.id === item.id ? 'Default variation' : '');
                        return __assign(__assign({}, item), { data: variation.data, variationId: variation.id, testVariationId: variation.id, variationName: variationName, testVariationName: variationName });
                    }
                }
                _this.setTestCookie(item.id, item.id);
            }
            return __assign(__assign(__assign({}, item), { variationId: item.id }), (item.variations &&
                size(item.variations) && {
                testVariationId: item.id,
                testVariationName: 'Default variation',
            }));
        });
        if (exports.isIframe) {
            (_a = window.parent) === null || _a === void 0 ? void 0 : _a.postMessage({ type: 'builder.contentResults', data: { results: mappedResults } }, '*');
        }
        return mappedResults;
    };
    Builder.prototype.getTestCookie = function (contentId) {
        return this.getCookie(this.testCookiePrefix + "." + contentId);
    };
    Builder.prototype.setTestCookie = function (contentId, variationId) {
        if (!this.canTrack) {
            this.cookieQueue.push([contentId, variationId]);
            return;
        }
        // 30 days from now
        var future = new Date();
        future.setDate(future.getDate() + 30);
        return this.setCookie(this.testCookiePrefix + "." + contentId, variationId, future);
    };
    Builder.prototype.getCookie = function (name) {
        if (this.cookies) {
            return this.cookies.get(name);
        }
        return Builder.isBrowser && getCookie(name);
    };
    Builder.prototype.setCookie = function (name, value, expires) {
        if (this.cookies) {
            return this.cookies.set(name, value, {
                expires: expires,
                secure: this.getLocation().protocol === 'https:',
            });
        }
        return Builder.isBrowser && setCookie(name, value, expires);
    };
    Builder.prototype.getContent = function (modelName, options) {
        if (options === void 0) { options = {}; }
        if (!this.apiKey) {
            throw new Error('Builder needs to be initialized with an API key!');
        }
        return this.queueGetContent(modelName);
    };
    Builder.VERSION = package_json_1.version;
    Builder.components = [];
    Builder.useNewApi = true;
    // isStatic delegates all variants rendering and election to the variants provider
    // which in turn will always render default variation on server and winning variation on client
    Builder.isStatic = false;
    Builder.animator = new animator_class_1.Animator();
    Builder.nextTick = next_tick_function_1.nextTick;
    Builder.throttle = throttle_function_1.throttle;
    Builder.editors = [];
    Builder.plugins = [];
    Builder.actions = [];
    Builder.registry = {};
    Builder.registryChange = new observable_class_1.BehaviorSubject({});
    Builder._editingPage = false;
    Builder.isIframe = exports.isIframe;
    Builder.isBrowser = exports.isBrowser;
    Builder.isReactNative = exports.isReactNative;
    Builder.isServer = !exports.isBrowser && !exports.isReactNative;
    Builder.previewingModel = Builder.isBrowser && getQueryParam(location.href, 'builder.preview');
    Builder.settings = {};
    Builder.settingsChange = new observable_class_1.BehaviorSubject({});
    // TODO: this is quick and dirty, do better implementation later. Also can be unreliable
    // if page 301s etc. Use a query param instead? also could have issues with redirects. Injecting var could
    // work but is async...
    Builder.isEditing = Boolean(exports.isIframe &&
        ((document.referrer && document.referrer.match(/builder\.io|localhost:1234/)) ||
            location.search.indexOf('builder.frameEditing=') !== -1));
    Builder.isPreviewing = Boolean(exports.isBrowser &&
        (location.search.indexOf('builder.preview=') !== -1 ||
            location.search.indexOf('builder.frameEditing=') !== -1));
    Builder.isReact = false;
    Builder.overrideUserAttributes = {};
    return Builder;
}());
exports.Builder = Builder;
//# sourceMappingURL=builder.class.js.map