bernie-core 982.772.0

package/dist/code-split.js

@@ -0,0 +1,172 @@
+"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 __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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeSplit = exports.CodeSplit = void 0;
+var React = require("react");
+var CodeSplit = /** @class */ (function (_super) {
+    __extends(CodeSplit, _super);
+    function CodeSplit(props) {
+        return _super.call(this, props) || this;
+    }
+    CodeSplit.loadRoute = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('loadRoute not implemented');
+            });
+        });
+    };
+    CodeSplit.componentLoaded = false;
+    return CodeSplit;
+}(React.Component));
+exports.CodeSplit = CodeSplit;
+/**
+ * Gets the appropriate name of a code split component.
+ * @param WrappedComponent The internally loaded React component.
+ */
+var getDisplayName = function (WrappedComponent) { return WrappedComponent.displayName || WrappedComponent.name || 'Component'; };
+/**
+ * Produces a new React component class that asynchronously loads the internal component.
+ *
+ * For use with dynamic imports. See more:
+ * - Mozilla: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#Dynamic_Imports
+ * - Webpack: https://github.com/webpack/webpack.js.org/blob/master/src/content/guides/code-splitting.md#dynamic-imports
+ *   - or use commit hash b77b222c1c52873f7d8b2fb66573598ef4ad5232 instead of master
+ *
+ * @param {CodeSplitLoader} loaderFunction A function that returns a `Promise` containing an object with a default
+ * export of a React component. Bernie is unable to know any specifics of the imported component, therefore it requires
+ * a default export so it has something to run. It will throw an error if a default export is not found.
+ */
+exports.codeSplit = function (loaderFunction) {
+    // tslint:disable-next-line:max-classes-per-file
+    return /** @class */ (function (_super) {
+        __extends(WebpackRoute, _super);
+        function WebpackRoute(props) {
+            var _this = _super.call(this, props) || this;
+            _this.logger = {};
+            _this.state = { component: WebpackRoute.wrappedComponent };
+            if (!_this.state.component) {
+                _this.doLoadRoute(false);
+            }
+            return _this;
+        }
+        WebpackRoute.prototype.componentDidMount = function () {
+            if (!this.state.component) {
+                this.doLoadRoute();
+            }
+        };
+        WebpackRoute.prototype.render = function () {
+            var Component = this.state.component;
+            var loadingComponent = this.props.loadingState || null;
+            return Component ? React.createElement(Component, __assign({}, this.props)) : loadingComponent;
+        };
+        WebpackRoute.prototype.doLoadRoute = function (setState) {
+            if (setState === void 0) { setState = true; }
+            return __awaiter(this, void 0, void 0, function () {
+                var component, error_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 2, , 3]);
+                            return [4 /*yield*/, WebpackRoute.loadRoute()];
+                        case 1:
+                            component = _a.sent();
+                            if (setState) {
+                                this.setState({ component: component });
+                            }
+                            return [3 /*break*/, 3];
+                        case 2:
+                            error_1 = _a.sent();
+                            if (this.logger && this.logger.error) {
+                                this.logger.error(error_1);
+                            }
+                            return [3 /*break*/, 3];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        WebpackRoute.loadRoute = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var component;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!!WebpackRoute.componentLoaded) return [3 /*break*/, 2];
+                            return [4 /*yield*/, loaderFunction()];
+                        case 1:
+                            component = _a.sent();
+                            if (!component || !component.default) {
+                                throw new Error('Code split components must have a default export');
+                            }
+                            WebpackRoute.wrappedComponent = component.default;
+                            WebpackRoute.displayName = "WebpackRoute(" + getDisplayName(component.default) + ")";
+                            WebpackRoute.componentLoaded = true;
+                            _a.label = 2;
+                        case 2: return [2 /*return*/, WebpackRoute.wrappedComponent];
+                    }
+                });
+            });
+        };
+        return WebpackRoute;
+    }(CodeSplit));
+};
+//# sourceMappingURL=code-split.js.map

package/dist/components/get-providers.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProviders = void 0;
+var React = require("react");
+var l10n_provider_1 = require("bernie-l10n/dist/components/l10n-provider");
+var viewport_context_1 = require("@shared-ui/viewport-context");
+var brand_context_1 = require("@shared-ui/brand-context");
+var logger_1 = require("../logger");
+exports.getProviders = function (options) {
+    var deviceInformation = options.deviceInformation, localization = options.localization, loggerFactory = options.loggerFactory, brandData = options.brandData;
+    var Providers = function (props) { return (React.createElement(l10n_provider_1.LocalizationContext.Provider, { value: localization },
+        React.createElement(logger_1.LoggerProvider, { factory: loggerFactory },
+            React.createElement(viewport_context_1.ViewportProvider, { deviceInformation: deviceInformation },
+                React.createElement(brand_context_1.BrandProvider, { config: brandData }, props.children || null))))); };
+    return Providers;
+};
+//# sourceMappingURL=get-providers.js.map

package/dist/components/index.js

@@ -0,0 +1,14 @@
+"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("./get-providers"), exports);
+//# sourceMappingURL=index.js.map

package/dist/controller/get-controllers.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getControllers = void 0;
+/**
+ * Collects all exported controllers from the client
+ * application as an array.
+ */
+exports.getControllers = function () {
+    var controllers;
+    if (!controllers) {
+        var root = global || window;
+        controllers = root['Bernie'] ? root['Bernie']['controllers'] : null;
+        if (!controllers) {
+            throw new Error('Could not find "Bernie.controllers" on global object.');
+        }
+    }
+    if (controllers instanceof Function) {
+        controllers = controllers();
+    }
+    if (!Array.isArray(controllers)) {
+        throw new TypeError('Controllers should be exported as an array of Controller class definitions.');
+    }
+    return controllers.map(function (controller) { return new controller(); });
+};
+//# sourceMappingURL=get-controllers.js.map

package/dist/controller/index.js

@@ -0,0 +1,18 @@
+"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 });
+var get_controllers_1 = require("./get-controllers");
+Object.defineProperty(exports, "getControllers", { enumerable: true, get: function () { return get_controllers_1.getControllers; } });
+var match_route_1 = require("./match-route");
+Object.defineProperty(exports, "matchRoute", { enumerable: true, get: function () { return match_route_1.matchRoute; } });
+__exportStar(require("./result"), exports);
+//# sourceMappingURL=index.js.map

package/dist/controller/match-route.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchRoute = void 0;
+var react_router_dom_1 = require("react-router-dom");
+/**
+ * Using React Router's `matchPath` function, chooses the
+ * controller that matches the inbound request path.
+ * @param controllers An array of application controllers.
+ * @param path The incoming request path, e.g. `/Hotels`.
+ */
+exports.matchRoute = function (controllers, path, options) {
+    if (options === void 0) { options = {}; }
+    var match;
+    var result = {};
+    var hasPrefix = options.baseUrl && path.indexOf(options.baseUrl) === 0;
+    var strippedPath = hasPrefix ? path.replace(new RegExp('^' + options.baseUrl), '') : path;
+    controllers.some(function (controller) {
+        match = react_router_dom_1.matchPath(strippedPath, controller);
+        if (match) {
+            result = {
+                route: controller,
+                params: match.params,
+                location: {
+                    path: path,
+                    pathname: controller.routeName || 'unknown'
+                }
+            };
+            return true;
+        }
+        return false;
+    });
+    return result;
+};
+//# sourceMappingURL=match-route.js.map

package/dist/controller/result.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Result = void 0;
+var bernie_http_1 = require("bernie-http");
+// tslint:disable-next-line:no-namespace
+var Result;
+(function (Result) {
+    Result.ok = function () { return ({
+        status: bernie_http_1.HttpStatus.OK
+    }); };
+    Result.internalServerError = function () { return ({
+        status: bernie_http_1.HttpStatus.INTERNAL_SERVER_ERROR
+    }); };
+    Result.partialContent = function () { return ({
+        status: bernie_http_1.HttpStatus.PARTIAL_CONTENT
+    }); };
+    Result.notFound = function () { return ({
+        status: bernie_http_1.HttpStatus.NOT_FOUND
+    }); };
+})(Result = exports.Result || (exports.Result = {}));
+//# sourceMappingURL=result.js.map

package/dist/index.js

@@ -0,0 +1,22 @@
+"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("./controller"), exports);
+__exportStar(require("./util"), exports);
+var source_1 = require("./source");
+Object.defineProperty(exports, "BffSource", { enumerable: true, get: function () { return source_1.BffSource; } });
+__exportStar(require("./store"), exports);
+__exportStar(require("./routing"), exports);
+__exportStar(require("./code-split"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./components"), exports);
+//# sourceMappingURL=index.js.map

package/dist/logger/bernie-core-events.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BERNIE_CORE_EVENTS = void 0;
+var bernie_logger_1 = require("bernie-logger");
+exports.BERNIE_CORE_EVENTS = {
+    LOG_EXPERIMENT_ERROR: new bernie_logger_1.SystemEvent(bernie_logger_1.SystemEventLevel.ERROR, 'LOG_EXPERIMENT_ERROR'),
+    MERGE_OMNITURE_DATA_ERROR: new bernie_logger_1.SystemEvent(bernie_logger_1.SystemEventLevel.ERROR, 'MERGE_OMNITURE_DATA_ERROR'),
+    PAGE_NAMESPACE_ERROR: new bernie_logger_1.SystemEvent(bernie_logger_1.SystemEventLevel.ERROR, 'PAGE_NAMESPACE_ERROR'),
+    PAGE_OMNITURE_ERROR: new bernie_logger_1.SystemEvent(bernie_logger_1.SystemEventLevel.ERROR, 'PAGE_OMNITURE_ERROR'),
+    PUBLISH_ANALYTICS_ERROR: new bernie_logger_1.SystemEvent(bernie_logger_1.SystemEventLevel.ERROR, 'PUBLISH_ANALYTICS_ERROR'),
+    TRACK_EVENT_ERROR: new bernie_logger_1.SystemEvent(bernie_logger_1.SystemEventLevel.ERROR, 'TRACK_EVENT_ERROR'),
+    REACT_ROUTE_ERROR: new bernie_logger_1.SystemEvent(bernie_logger_1.SystemEventLevel.CRITICAL, 'REACT_ROUTE_ERROR')
+};
+//# sourceMappingURL=bernie-core-events.js.map

package/dist/logger/index.js

@@ -0,0 +1,18 @@
+"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 });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
+var logger_provider_1 = require("./logger-provider");
+Object.defineProperty(exports, "LoggerProvider", { enumerable: true, get: function () { return logger_provider_1.LoggerProvider; } });
+__exportStar(require("./bernie-core-events"), exports);
+//# sourceMappingURL=index.js.map

package/dist/logger/logger-provider.js

@@ -0,0 +1,45 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerProvider = void 0;
+var React = require("react");
+var PropTypes = require("prop-types");
+/**
+ * Provider component that injects a runtime `LoggerFactory`
+ * function into the child context of the component tree.
+ */
+var LoggerProvider = /** @class */ (function (_super) {
+    __extends(LoggerProvider, _super);
+    function LoggerProvider() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    LoggerProvider.prototype.render = function () {
+        return React.Children.only(this.props.children);
+    };
+    LoggerProvider.prototype.getChildContext = function () {
+        return {
+            factory: this.props.factory
+        };
+    };
+    LoggerProvider.contextTypes = {
+        factory: PropTypes.func
+    };
+    LoggerProvider.childContextTypes = {
+        factory: PropTypes.func
+    };
+    return LoggerProvider;
+}(React.Component));
+exports.LoggerProvider = LoggerProvider;
+//# sourceMappingURL=logger-provider.js.map

package/dist/logger/logger.js

@@ -0,0 +1,44 @@
+"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.logger = void 0;
+var React = require("react");
+var PropTypes = require("prop-types");
+var bernie_logger_1 = require("bernie-logger");
+/**
+ * Decorator that injects `logger` as a prop to the decorated
+ * component.
+ * @param name The name or identifier to associate with the
+ * injected logger.
+ */
+exports.logger = function (name) {
+    return function (componentClass) {
+        var Wrapper = function (props, context) {
+            var factory = context.factory || (function (_) { return bernie_logger_1.NOOP_LOGGER; });
+            var log = bernie_logger_1.NOOP_LOGGER;
+            try {
+                log = factory(name);
+            }
+            catch (e) {
+                //
+            }
+            return React.createElement(componentClass, __assign(__assign({}, props), { logger: log }));
+        };
+        Wrapper.contextTypes = {
+            factory: PropTypes.func
+        };
+        Wrapper['wrappedComponent'] = componentClass;
+        return Wrapper;
+    };
+};
+//# sourceMappingURL=logger.js.map

package/dist/routing/close-dialog.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeDialog = void 0;
+var update_search_1 = require("./update-search");
+exports.closeDialog = function (_a) {
+    var _b;
+    var history = _a.history, location = _a.location, _c = _a.key, key = _c === void 0 ? 'pwaOverlay' : _c;
+    // `MemoryHistory` instances: `history.index` is used to indicate the initial entry
+    // `BrowserHistory` instances: `location.key` is used: https://github.com/ReactTraining/history/blob/master/docs/api-reference.md#locationkey
+    //  - in v4, it defaults to `undefined` (https://github.com/ReactTraining/history/blob/3f69f9e07b0a739419704cffc3b3563133281548/modules/createBrowserHistory.js#L54)
+    //  - in v5, it defaults to `'default'` (https://github.com/ReactTraining/history/blob/v5.0.0/docs/api-reference.md#locationkey)
+    if (history['index'] === 0 || typeof location.key === 'undefined' || location.key === 'default') {
+        update_search_1.updateSearch({ history: history, location: location, newParams: (_b = {}, _b[key] = undefined, _b), replace: true });
+    }
+    else {
+        history.goBack();
+    }
+};
+//# sourceMappingURL=close-dialog.js.map

package/dist/routing/dialog-route.js

@@ -0,0 +1,69 @@
+"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 __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.DialogRoute = exports.buildDialogQueryFn = void 0;
+var React = require("react");
+var queryString = require("query-string");
+var query_route_1 = require("./query-route");
+//This function allows us to find dialogs in a comma-separate series
+// eg, foo.com/bar?pwaDialog=dialogA,dialogB,dialogC
+function buildDialogQueryFn(dialogId) {
+    return function (query) { return query.split(',').includes(dialogId); };
+}
+exports.buildDialogQueryFn = buildDialogQueryFn;
+var DialogRoute = /** @class */ (function (_super) {
+    __extends(DialogRoute, _super);
+    function DialogRoute() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DialogRoute.buildDialogChain = function (query, dialogId, key) {
+        if (key === void 0) { key = 'pwaDialog'; }
+        var queryObj = queryString.parse(query);
+        return queryObj[key] ? queryObj[key] + "," + dialogId : dialogId;
+    };
+    DialogRoute.appendDialogToQuery = function (query, dialogId, key) {
+        var _a;
+        if (key === void 0) { key = 'pwaDialog'; }
+        var queryObj = queryString.parse(query);
+        var dialogChain = queryObj[key] ? queryObj[key] + "," + dialogId : dialogId;
+        var enhancedQuery = __assign(__assign({}, queryObj), (_a = {}, _a[key] = dialogChain, _a));
+        return queryString.stringify(enhancedQuery);
+    };
+    DialogRoute.prototype.render = function () {
+        var _a;
+        var _b = this.props, children = _b.children, id = _b.id, type = _b.type, useQueryBuilder = _b.useQueryBuilder;
+        var query = useQueryBuilder ? buildDialogQueryFn(id) : id;
+        var queryVal = (_a = {}, _a[type] = query, _a);
+        return React.createElement(query_route_1.QueryRoute, { query: queryVal }, children);
+    };
+    DialogRoute.defaultProps = {
+        type: 'pwaDialog',
+        useQueryBuilder: true
+    };
+    return DialogRoute;
+}(React.Component));
+exports.DialogRoute = DialogRoute;
+//# sourceMappingURL=dialog-route.js.map

package/dist/routing/index.js

@@ -0,0 +1,24 @@
+"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 });
+var matches_query_1 = require("./matches-query");
+Object.defineProperty(exports, "matchesQuery", { enumerable: true, get: function () { return matches_query_1.matchesQuery; } });
+var dialog_route_1 = require("./dialog-route");
+Object.defineProperty(exports, "DialogRoute", { enumerable: true, get: function () { return dialog_route_1.DialogRoute; } });
+var query_route_1 = require("./query-route");
+Object.defineProperty(exports, "QueryRoute", { enumerable: true, get: function () { return query_route_1.QueryRoute; } });
+var query_switch_1 = require("./query-switch");
+Object.defineProperty(exports, "QuerySwitch", { enumerable: true, get: function () { return query_switch_1.QuerySwitch; } });
+__exportStar(require("./merge-query-string"), exports);
+__exportStar(require("./update-search"), exports);
+__exportStar(require("./close-dialog"), exports);
+//# sourceMappingURL=index.js.map

package/dist/routing/matches-query.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesQuery = void 0;
+var queryString = require('query-string');
+/**
+ * Example Calls:
+ * matchesQuery(location.search, "destination") => Does the query contain the key "destination"?
+ * matchesQuery(location.search, {adults: 2}) => Does the query contain the key "adults" with the value "2"?
+ * matchesQuery(location.search, ["startDate", "endDate"] ) => Does the query contain both startDate and endDate keys?
+ * matchesQuery(location.search, [{regionid: 179993}, "foobar"]) => Does the query contain a key of "regionid"
+ * with a value of 179993, AND a key of foobar (with any value)?
+ */
+exports.matchesQuery = function (locationSearch, specification) {
+    // Accept locationSearch as either a string, or a parsed query object.
+    var queryObj = typeof locationSearch === 'string' ? queryString.parse(locationSearch) : locationSearch;
+    var queryObjKeys = Object.keys(queryObj);
+    // If passed a string, find that query key's existance
+    if (typeof specification === 'string') {
+        return queryObjKeys.includes(specification);
+    }
+    // If passed an array, test each entry
+    if (typeof specification === 'object' && Array.isArray(specification)) {
+        return specification.reduce(function (matchesAll, item) { return matchesAll && exports.matchesQuery(queryObj, item); }, true);
+    }
+    // If passed an object, test against both keys and values
+    if (typeof specification === 'object') {
+        return Object.keys(specification).reduce(function (matchesAll, key) {
+            var queryValue = specification[key];
+            // Does the key exist in the location search
+            var matchesKey = queryObjKeys.includes(key);
+            if (!matchesKey) {
+                return false;
+            }
+            // Does the value of that key match the desired value
+            var matchesValue = false;
+            if (typeof queryValue === 'function') {
+                matchesValue = queryValue(queryObj[key]);
+            }
+            else {
+                matchesValue = queryObj[key] === queryValue.toString();
+            }
+            return matchesAll && matchesValue;
+        }, true);
+    }
+    return false;
+};
+//# sourceMappingURL=matches-query.js.map

package/dist/routing/merge-query-string.js

@@ -0,0 +1,29 @@
+"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.mergeQueryString = void 0;
+var queryString = require("query-string");
+function mergeQueryString(query, params, filterQueryParams) {
+    var queryObj = queryString.parse(query);
+    var paramObj = typeof params === 'string' ? queryString.parse(params) : params;
+    if (filterQueryParams) {
+        Object.keys(queryObj).forEach(function (key) {
+            if (!filterQueryParams(key)) {
+                delete queryObj[key];
+            }
+        });
+    }
+    return queryString.stringify(__assign(__assign({}, queryObj), paramObj));
+}
+exports.mergeQueryString = mergeQueryString;
+//# sourceMappingURL=merge-query-string.js.map