bernie-core 3.767.0

package/dist/store/common/experiment-store.js

@@ -0,0 +1,64 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExperimentStore = void 0;
+var spi_1 = require("../spi");
+var bernie_logger_1 = require("bernie-logger");
+var mobx_1 = require("mobx");
+/**
+ * Future home of Abacus related data. Currently just allows
+ * `.logExperiment` to be injected.
+ */
+var ExperimentStore = /** @class */ (function (_super) {
+    __extends(ExperimentStore, _super);
+    /**
+     * @param experimentLogger The experiment logger
+     * @param logger The standard logger
+     */
+    function ExperimentStore(experimentContext, experimentLogger, logger) {
+        if (logger === void 0) { logger = bernie_logger_1.NOOP_LOGGER; }
+        var _this = _super.call(this, {}, logger) || this;
+        _this.experimentLogger = experimentLogger;
+        _this.exposures = experimentContext && experimentContext.exposures;
+        return _this;
+    }
+    /**
+     * Using the Abacus public API, log a batch of exposures.
+     * @param context The platform `Context`.
+     * @param pageData The `PageData` store containing `pageName`.
+     * @param exposure An Abacus exposure.
+     */
+    ExperimentStore.prototype.logExperiment = function (context, pageData, exposure) {
+        this.experimentLogger(context, pageData, exposure);
+    };
+    /**
+     * Does nothing for now.
+     */
+    ExperimentStore.prototype.hydrate = function (data) {
+        this.exposures = data.exposures;
+    };
+    __decorate([
+        mobx_1.observable
+    ], ExperimentStore.prototype, "exposures", void 0);
+    return ExperimentStore;
+}(spi_1.Store));
+exports.ExperimentStore = ExperimentStore;
+//# sourceMappingURL=experiment-store.js.map

package/dist/store/common/get-experiment-logger.js

@@ -0,0 +1,80 @@
+"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 });
+exports.getExperimentLogger = void 0;
+var fetch = require("isomorphic-fetch");
+var bernie_logger_1 = require("bernie-logger");
+var __1 = require("../..");
+var util_1 = require("../../util");
+var TIMEOUT = 400;
+/**
+ * Retrieves and configures an `ExperimentLogger`.
+ * @param options Configuration options, e.g. the base URL for server side calls
+ */
+exports.getExperimentLogger = function (options) {
+    var baseUrl = options.baseUrl || '';
+    var logger = options.logger || bernie_logger_1.NOOP_LOGGER;
+    var loggedExperiments = new Set();
+    var queue;
+    var fetchWithTimeout = function (url, requestOptions) {
+        var fetchOptions = requestOptions;
+        if (typeof window === 'undefined' && typeof options.timeout === 'number') {
+            fetchOptions = __assign(__assign({}, fetchOptions), { timeout: options.timeout });
+        }
+        return fetch(url, __assign({}, fetchOptions));
+    };
+    /**
+     * Using the Abacus public API, log a batch of exposures.
+     * @param context The platform `Context`.
+     * @param pageData The `PageData` store containing `pageName`.
+     * @param exposure An Abacus exposure.
+     */
+    return function (context, pageData, exposure) {
+        var overrides = (context && context.debugContext && context.debugContext.abacusOverrides) || [];
+        if (queue === undefined) {
+            queue = new util_1.UniqueBatchQueue(TIMEOUT, function (e) { return e.name; }, function (exposures) {
+                fetchWithTimeout(baseUrl + "/api/bucketing/v1/evaluateExperimentsAndLog", {
+                    body: JSON.stringify({
+                        guid: context.deviceId,
+                        tpid: context.site.tpid,
+                        eapid: context.site.eapid,
+                        pageName: pageData.pageName,
+                        name: exposures.map(function (item) { return item.name; }),
+                        overrides: overrides.map(function (override) { return override.id + "|0|" + override.bucket; }).join(':') || undefined
+                    }),
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json'
+                    },
+                    method: 'POST'
+                })
+                    .then(function (res) { return res.json(); })
+                    .then(function () {
+                    exposures.forEach(function (e) {
+                        loggedExperiments.add(e.name);
+                    });
+                })
+                    .catch(function (error) {
+                    if (logger) {
+                        logger.logEvent(__1.BERNIE_CORE_EVENTS.LOG_EXPERIMENT_ERROR, bernie_logger_1.getErrorString(error));
+                    }
+                });
+            });
+        }
+        if (!loggedExperiments.has(exposure.name)) {
+            queue.add(exposure);
+        }
+        return true;
+    };
+};
+//# sourceMappingURL=get-experiment-logger.js.map

package/dist/store/common/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var context_store_1 = require("./context-store");
+Object.defineProperty(exports, "ContextStore", { enumerable: true, get: function () { return context_store_1.ContextStore; } });
+var page_store_1 = require("./page-store");
+Object.defineProperty(exports, "PageStore", { enumerable: true, get: function () { return page_store_1.PageStore; } });
+var analytics_store_1 = require("./analytics-store");
+Object.defineProperty(exports, "AnalyticsStore", { enumerable: true, get: function () { return analytics_store_1.AnalyticsStore; } });
+var experiment_store_1 = require("./experiment-store");
+Object.defineProperty(exports, "ExperimentStore", { enumerable: true, get: function () { return experiment_store_1.ExperimentStore; } });
+var get_experiment_logger_1 = require("./get-experiment-logger");
+Object.defineProperty(exports, "getExperimentLogger", { enumerable: true, get: function () { return get_experiment_logger_1.getExperimentLogger; } });
+//# sourceMappingURL=index.js.map

package/dist/store/common/page-store.js

@@ -0,0 +1,102 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageStore = void 0;
+var spi_1 = require("../spi");
+var mobx_1 = require("mobx");
+/**
+ * MobX store that houses page specific data, such
+ * as SEO information or the page title.
+ */
+var PageStore = /** @class */ (function (_super) {
+    __extends(PageStore, _super);
+    /**
+     * Constructs a new page store.
+     * @param title The HTML page title.
+     * @param seo SEO specific information.
+     * @param scripts JS scripts to include on page.
+     */
+    function PageStore(pageData, logger) {
+        return _super.call(this, pageData, logger) || this;
+    }
+    /**
+     * {@inheritDoc}
+     */
+    PageStore.prototype.hydrate = function (data) {
+        Object.assign(this, data);
+    };
+    PageStore.prototype.fetch = function (meta, site, locale) {
+        var _this = this;
+        this.loading = true;
+        var metadata = PageStore.getMeta(meta, site, locale);
+        this.title = metadata.title;
+        this.meta = metadata;
+        return new Promise(function (resolve) {
+            _this.loading = false;
+            resolve(_this.toJSON());
+        });
+    };
+    PageStore.getMeta = function (meta, site, locale) {
+        var robots = meta.robots;
+        var localeSpecificMeta = PageStore.localeSpecificMeta(meta, site.id, locale);
+        var description = localeSpecificMeta.description;
+        var title = localeSpecificMeta.title;
+        var canonical = meta.canonical && meta.canonical(site);
+        return {
+            title: title,
+            robots: robots,
+            description: description,
+            canonical: canonical
+        };
+    };
+    PageStore.localeSpecificMeta = function (meta, siteId, locale) {
+        var siteMeta = meta[siteId];
+        if (siteMeta) {
+            var result = siteMeta[locale];
+            if (!result) {
+                result = siteMeta.default || {};
+            }
+            return result;
+        }
+        return {};
+    };
+    __decorate([
+        mobx_1.observable
+    ], PageStore.prototype, "title", void 0);
+    __decorate([
+        mobx_1.observable
+    ], PageStore.prototype, "navigationId", void 0);
+    __decorate([
+        mobx_1.observable
+    ], PageStore.prototype, "meta", void 0);
+    __decorate([
+        mobx_1.observable
+    ], PageStore.prototype, "seo", void 0);
+    __decorate([
+        mobx_1.action
+    ], PageStore.prototype, "hydrate", null);
+    __decorate([
+        mobx_1.action
+    ], PageStore.prototype, "fetch", null);
+    return PageStore;
+}(spi_1.Store));
+exports.PageStore = PageStore;
+//# sourceMappingURL=page-store.js.map

package/dist/store/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./spi"), exports);
+__exportStar(require("./common"), exports);
+//# sourceMappingURL=index.js.map

package/dist/store/spi/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var store_1 = require("./store");
+Object.defineProperty(exports, "Store", { enumerable: true, get: function () { return store_1.Store; } });
+var store_container_1 = require("./store-container");
+Object.defineProperty(exports, "StoreContainer", { enumerable: true, get: function () { return store_container_1.StoreContainer; } });
+//# sourceMappingURL=index.js.map

package/dist/store/spi/store-container.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreContainer = void 0;
+/**
+ * Wraps an object containing MobX stores to all for
+ * typed access.
+ */
+var StoreContainer = /** @class */ (function () {
+    /**
+     * Constructs a new `StoreContainer` from an object
+     * containing stores.
+     * @param stores A `Stores` object.
+     */
+    function StoreContainer(stores) {
+        this.stores = stores;
+    }
+    /**
+     * Retrieves an individual store from the container.
+     * @param name The name of the store.
+     */
+    StoreContainer.prototype.get = function (name) {
+        return this.stores[name];
+    };
+    return StoreContainer;
+}());
+exports.StoreContainer = StoreContainer;
+//# sourceMappingURL=store-container.js.map

package/dist/store/spi/store.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = void 0;
+var mobx_1 = require("mobx");
+var merge_1 = require("../../util/merge");
+var Store = /** @class */ (function () {
+    /**
+     * Constructs a new `Store`.
+     * @param state Serialized state JSON.
+     * @param logger Bernie logger
+     */
+    function Store(state, logger) {
+        var _this = this;
+        if (state === void 0) { state = {}; }
+        var defaults = this.constructor['DEFAULTS'] || {};
+        mobx_1.runInAction(function () { return Object.assign(_this, defaults, state, { logger: logger }); });
+    }
+    /**
+     * Creates a basic JSON object from the store, excluding
+     * any fields provided in `excludedFields`.
+     */
+    Store.prototype.toJSON = function (ignoreAdditionalKeys) {
+        if (ignoreAdditionalKeys === void 0) { ignoreAdditionalKeys = []; }
+        if (!Array.isArray(ignoreAdditionalKeys)) {
+            ignoreAdditionalKeys = ignoreAdditionalKeys.constructor === String ? [ignoreAdditionalKeys] : [];
+        }
+        var regexIgnorePrivate = /^_.+/;
+        var simpleObject = mobx_1.toJS(this);
+        var ignoreKeys = Object.keys(simpleObject)
+            .filter(function (key) { return regexIgnorePrivate.test(key) || typeof simpleObject[key] === 'function'; })
+            .concat(ignoreAdditionalKeys, 'logger');
+        return merge_1.withoutKeys(ignoreKeys).merge({}, simpleObject);
+    };
+    return Store;
+}());
+exports.Store = Store;
+//# sourceMappingURL=store.js.map

package/dist/util/autobind.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autobind = void 0;
+/*
+ * Code pulled from https://github.com/andreypopp/autobind-decorator/blob/master/src/index.js
+ *
+ * A decorator that automatically bind a class method to an instance of that class.
+ */
+exports.autobind = function (target, key, descriptor) {
+    var fn = descriptor.value;
+    if (typeof fn !== 'function') {
+        throw new Error("@autobind decorator can only be applied to methods not: " + typeof fn);
+    }
+    // In IE11 calling Object.defineProperty has a side-effect of evaluating the
+    // getter for the property which is being replaced. This causes infinite
+    // recursion and an "Out of stack space" error.
+    var definingProperty = false;
+    return {
+        configurable: true,
+        get: function () {
+            if (definingProperty || this === target.prototype || this.hasOwnProperty(key) || typeof fn !== 'function') {
+                return fn;
+            }
+            var boundFn = fn.bind(this);
+            definingProperty = true;
+            Object.defineProperty(this, key, {
+                configurable: true,
+                get: function () {
+                    return boundFn;
+                },
+                set: function (value) {
+                    fn = value;
+                    delete this[key];
+                }
+            });
+            definingProperty = false;
+            return boundFn;
+        },
+        set: function (value) {
+            fn = value;
+        }
+    };
+};
+//# sourceMappingURL=autobind.js.map

package/dist/util/batch-queue.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchQueue = void 0;
+/**
+ * A Queue which will process elements at intervals, only if the
+ * queue contains any elements.
+ */
+var BatchQueue = /** @class */ (function () {
+    function BatchQueue(batchPeriod, handler) {
+        this.batchPeriod = batchPeriod;
+        this.handler = handler;
+        this.timeoutId = null;
+        this.items = [];
+    }
+    BatchQueue.prototype.add = function (item) {
+        var _this = this;
+        this.items.push(item);
+        if (this.timeoutId === null) {
+            this.timeoutId = setTimeout(function () {
+                _this.handleBatch();
+            }, this.batchPeriod);
+        }
+    };
+    BatchQueue.prototype.handleBatch = function () {
+        var batch = this.items;
+        this.timeoutId = null;
+        this.items = [];
+        this.handler(batch);
+    };
+    return BatchQueue;
+}());
+exports.BatchQueue = BatchQueue;
+//# sourceMappingURL=batch-queue.js.map

package/dist/util/brand-config.js

@@ -0,0 +1,32 @@
+"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 });
+exports.getBrandConfiguration = void 0;
+var React = require("react");
+exports.getBrandConfiguration = function (brandData) {
+    var iconSet = (brandData && brandData.iconData) || null;
+    var getIcon = function (name) {
+        if (!iconSet || (!iconSet.icons[name] && !iconSet.nameMapping[name])) {
+            return null;
+        }
+        var iconDataVal = iconSet.nameMapping[name] || name;
+        return function (props) {
+            var innerSvgProps = __assign({ dangerouslySetInnerHTML: { __html: iconSet.icons[iconDataVal].data } }, props);
+            return React.createElement("svg", __assign({}, innerSvgProps));
+        };
+    };
+    return {
+        getIcon: getIcon
+    };
+};
+//# sourceMappingURL=brand-config.js.map

package/dist/util/debounce.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = void 0;
+exports.debounce = function (func, delay, thisContext) {
+    var timer;
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var callback = function () {
+            timer = null;
+            func.apply(thisContext || null, args);
+        };
+        clearTimeout(timer);
+        timer = setTimeout(callback, delay);
+    };
+};
+//# sourceMappingURL=debounce.js.map

package/dist/util/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidDate = exports.parseDate = exports.autobind = exports.merge = void 0;
+var merge = require("./merge");
+exports.merge = merge;
+var autobind_1 = require("./autobind");
+Object.defineProperty(exports, "autobind", { enumerable: true, get: function () { return autobind_1.autobind; } });
+var BernieL10n = require("bernie-l10n");
+__exportStar(require("./timeout-promise"), exports);
+__exportStar(require("./retry"), exports);
+var batch_queue_1 = require("./batch-queue");
+Object.defineProperty(exports, "BatchQueue", { enumerable: true, get: function () { return batch_queue_1.BatchQueue; } });
+var unique_batch_queue_1 = require("./unique-batch-queue");
+Object.defineProperty(exports, "UniqueBatchQueue", { enumerable: true, get: function () { return unique_batch_queue_1.UniqueBatchQueue; } });
+var not_serialize_1 = require("./not-serialize");
+Object.defineProperty(exports, "serializable", { enumerable: true, get: function () { return not_serialize_1.serializable; } });
+Object.defineProperty(exports, "toJSON", { enumerable: true, get: function () { return not_serialize_1.toJSON; } });
+var debounce_1 = require("./debounce");
+Object.defineProperty(exports, "debounce", { enumerable: true, get: function () { return debounce_1.debounce; } });
+__exportStar(require("./brand-config"), exports);
+/***/
+/*** previously from: ./parse-data ***/
+/************************************/
+/**
+ * @deprecated
+ * @see bernie-l10n for replacement
+ */
+exports.parseDate = BernieL10n.parseDate;
+/**
+ * @deprecated
+ * @see bernie-l10n for replacement
+ */
+exports.isValidDate = BernieL10n.isValidDate;
+//# sourceMappingURL=index.js.map

package/dist/util/merge.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenFields = exports.withoutKeys = exports.withKeys = exports.allKeys = void 0;
+/* tslint:disable */
+function _mergeWithKeys(keys, objects) {
+    if (keys === void 0) { keys = []; }
+    if (objects.length === 0 || keys instanceof Array === false) {
+        return {};
+    }
+    // only use objects for the merge, ignore null which is also typeof object
+    objects = objects.filter(function (object) { return typeof object === 'object' && object; });
+    var base = {};
+    objects.forEach(function (object) {
+        keys.forEach(function (key) {
+            if (object.hasOwnProperty(key)) {
+                base[key] = object[key];
+            }
+        });
+    });
+    return base;
+}
+function _mergeWithoutKeys(keys, objects) {
+    if (keys === void 0) { keys = []; }
+    if (objects.length === 0 || keys instanceof Array === false) {
+        return {};
+    }
+    // only use objects for the merge, ignore null which is also typeof object
+    objects = objects.filter(function (object) { return typeof object === 'object' && object; });
+    // bracket notation lookup should be faster than repeated indexOf
+    var omittedKeys = keys.reduce(function (holder, key) {
+        holder[key] = true;
+        return holder;
+    }, {});
+    var base = {};
+    objects.forEach(function (object) {
+        Object.keys(object).forEach(function (key) {
+            if (omittedKeys[key] !== true) {
+                base[key] = object[key];
+            }
+        });
+    });
+    return base;
+}
+function _validKeys(keys) {
+    if (Array.isArray(keys)) {
+        // only use strings as keys, and make sure they're unique
+        return keys.filter(function (key, index, array) { return typeof key === 'string' && array.indexOf(key) === index && key.length > 0; });
+    }
+    return [];
+}
+function _flattenFields(refObject, delimiter, flattenArrays, newObject, prefix) {
+    if (delimiter === void 0) { delimiter = '_'; }
+    if (flattenArrays === void 0) { flattenArrays = false; }
+    if (newObject === void 0) { newObject = {}; }
+    var label;
+    var currentItem;
+    if (typeof delimiter !== 'string' || delimiter.length > 5) {
+        delimiter = '_';
+    }
+    flattenArrays = Boolean(flattenArrays);
+    if (typeof refObject === 'object' && refObject) {
+        Object.keys(refObject).forEach(function (key) {
+            label = prefix ? "" + prefix + delimiter + key : key;
+            currentItem = refObject[key];
+            if (currentItem !== null &&
+                ((typeof currentItem === 'object' && Object.keys(currentItem).length > 0) || Array.isArray(currentItem))) {
+                if (Array.isArray(currentItem) && flattenArrays === false) {
+                    newObject[label] = currentItem.concat();
+                }
+                else {
+                    _flattenFields(currentItem, delimiter, flattenArrays, newObject, label);
+                }
+            }
+            else {
+                newObject[label] = currentItem;
+            }
+        });
+    }
+    return newObject;
+}
+// public exports
+function allKeys() {
+    return withoutKeys([]);
+}
+exports.allKeys = allKeys;
+function withKeys(keys) {
+    if (keys === void 0) { keys = []; }
+    keys = _validKeys(keys);
+    return {
+        merge: function () {
+            var objects = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                objects[_i] = arguments[_i];
+            }
+            return _mergeWithKeys(keys, objects);
+        }
+    };
+}
+exports.withKeys = withKeys;
+function withoutKeys(keys) {
+    if (keys === void 0) { keys = []; }
+    keys = _validKeys(keys);
+    return {
+        merge: function () {
+            var objects = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                objects[_i] = arguments[_i];
+            }
+            return _mergeWithoutKeys(keys, objects);
+        }
+    };
+}
+exports.withoutKeys = withoutKeys;
+function flattenFields(refObject, delimiter, flattenArrays) {
+    if (delimiter === void 0) { delimiter = '_'; }
+    if (flattenArrays === void 0) { flattenArrays = false; }
+    return _flattenFields(refObject, delimiter, flattenArrays, {}, '');
+}
+exports.flattenFields = flattenFields;
+//# sourceMappingURL=merge.js.map