@lwrjs/router 0.10.0-alpha.1 → 0.10.0-alpha.10

package/build/es/modules/lwr/routerBridge/routerBridge.js

@@ -0,0 +1,85 @@
+import { PARENT_EVENT } from 'lwr/domRouter';
+// Bridge navigation events, without access to a <lwr-router-container> or NavigationContext
+// Used to allow a bridge between a LWR Router and vanilla HTML/JS (eg: in LWR Everywhere)
+class DomRouterBridge {
+    constructor(config = {}, target = window) {
+        // Routers send out the PARENT_EVENT to build a router hierarchy
+        // Listen for this event to find the topmost router located beneath the bridge in the DOM
+        // NOTE: because of the restrictions on "lwr/router" hierachy, this is only called 0 or 1 time(s)
+        //       - only ONE root router is allowed in a document
+        //       - sibling routers are NOT allowed
+        this.handleParentEvent = (event) => {
+            const parentEvent = event;
+            if (parentEvent && parentEvent.detail && typeof parentEvent.detail === 'function') {
+                // event.detail() will call this.addChild()
+                parentEvent.detail(this);
+                if (this.bridgedRouter) {
+                    // Ensure the bridge does not become part of the router hierarchy
+                    this.bridgedRouter.parent = undefined;
+                    this.target.removeEventListener(PARENT_EVENT, this.handleParentEvent);
+                }
+            }
+        };
+        // Provide fallbacks for missing config values
+        this.config = {
+            historyDisabled: !!config.historyDisabled,
+            onReady: config.onReady ||
+                (() => {
+                    /* noop */
+                }),
+            onPostNavigate: config.onPostNavigate ||
+                (() => {
+                    /* noop */
+                }),
+            onError: config.onError ||
+                (() => {
+                    return true;
+                }),
+        };
+        // Add a listener for the parent router event
+        this.target = target;
+        this.target.addEventListener(PARENT_EVENT, this.handleParentEvent);
+    }
+    // Save an observed router and subscribe to its navigation and error updates
+    async addChild(child) {
+        this.bridgedRouter = child;
+        this.bridgedRouter.subscribe(({ route: { pageReference } }) => {
+            this.config.onPostNavigate(pageReference); // ONLY return the page reference
+        });
+        this.bridgedRouter.addErrorNavigate(this.config.onError);
+        // Prevent the observed router from altering the browser URL or history
+        // This is good practice for routers embedded in an outside host document
+        if (this.config.historyDisabled) {
+            this.bridgedRouter.historyDisabled = true;
+        }
+        // The router PARENT_EVENT is sent before the NAV_EVENT is subscribed,
+        //      so mark this bridge as ready in the next event loop.
+        // The events are both set up during router.connect(),
+        //      so they'll be finished before the timeout triggers.
+        await new Promise((resolve) => {
+            /* eslint-disable-next-line */
+            setTimeout(() => {
+                this.config.onReady();
+                resolve();
+            }, 0);
+        });
+    }
+    // Use the observed router to navigate to the given page reference
+    // Return true if the router is connected and the navigation event was sent
+    // False is returned if there are no mounted routers to observe (yet)
+    navigate(pageRef) {
+        if (this.bridgedRouter && this.bridgedRouter.connected) {
+            this.bridgedRouter.navigate(pageRef);
+            return true;
+        }
+        return false;
+    }
+}
+// Return a subset of the bridge class instance, as an API
+export function createBridge(config, target) {
+    const bridge = new DomRouterBridge(config, target);
+    return {
+        navigate: bridge.navigate.bind(bridge),
+    };
+}
+//# sourceMappingURL=routerBridge.js.map

package/build/es/modules/lwr/routerContainer/routerContainer.js

@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+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;
+};
+import { LightningElement, api } from 'lwc';
+import { createNavigationContext } from './utils';
+import { hasDocument } from 'lwr/routerUtils';
+/*
+ * Provides a LWC router component. These can be nested and all report to the root router.
+ */
+export default class RouterContainer extends LightningElement {
+    constructor() {
+        super();
+        this.historyDisabled = false;
+        this.currentTitle = hasDocument ? document.title : '';
+    }
+    /**
+     * Create a router attached to this component.
+     */
+    connectedCallback() {
+        const config = {
+            historyDisabled: this.historyDisabled,
+            handleNavigation: this.handleNavigation.bind(this),
+        };
+        if (this.router) {
+            // Create the router.
+            this.routerApi = createNavigationContext(this, config, this.router);
+            // Convert hook APIs into DOM events.
+            // The events do not bubble and are not composed (they cannot exit this shadow DOM)
+            //     They are meant to be exposed only to the owner (direct parent) of the router
+            this.routerApi
+                .addPreNavigate(this.preNavigate.bind(this))
+                .addPostNavigate(this.postNavigate.bind(this))
+                .addErrorNavigate(this.errorNavigate.bind(this))
+                // Connect the router.
+                .connect();
+        }
+    }
+    /**
+     * The preNavigate hook surfaced as a cancelable CustomEvent.
+     * @param {RouteChange} - the current and proposed route information
+     */
+    preNavigate(routeChange) {
+        const event = this._createEvent('prenavigate', routeChange, true);
+        this.dispatchEvent(event);
+        return !event.defaultPrevented;
+    }
+    /**
+     * The postNavigate hook surfaced as a CustomEvent.
+     * @param {RoutingResult} - the resulting navigation information
+     */
+    postNavigate(routingResult) {
+        this.dispatchEvent(this._createEvent('postnavigate', routingResult));
+        // If the current route definition metadata contains a title, set it as the document title
+        const title = routingResult.routeDefinition.metadata && routingResult.routeDefinition.metadata.title;
+        if (title) {
+            this.currentTitle = title;
+            document.title = title;
+        }
+        // Update the inner HTML of the aria-live region for screen readers
+        // This DOM node must be touched for every route change
+        const a11yTitle = this.querySelector('span.router-title');
+        if (a11yTitle)
+            a11yTitle.innerHTML = this.currentTitle;
+    }
+    /**
+     * The errorNavigate hook surfaced as a CustomEvent.
+     * @param {MessageObject} - error, the error encountered while navigating (if applicable)
+     */
+    errorNavigate(error) {
+        this.dispatchEvent(this._createEvent('errornavigate', error));
+        return true;
+    }
+    /**
+     * The preNavigate hook surfaced as a cancelable CustomEvent.
+     * @param {object} - address: The address being navigated to
+     * @param {boolean} - shouldReplace
+     */
+    handleNavigation(address, replace) {
+        const event = this._createEvent('handlenavigation', { address, replace }, true);
+        this.dispatchEvent(event);
+        return !event.defaultPrevented;
+    }
+    /**
+     * Disconnect the router after DOM removal.
+     */
+    disconnectedCallback() {
+        if (this.routerApi) {
+            this.routerApi.disconnect();
+        }
+    }
+    _createEvent(name, payload, cancelable) {
+        return new CustomEvent(name, {
+            detail: payload,
+            bubbles: false,
+            composed: false,
+            cancelable,
+        });
+    }
+}
+RouterContainer.renderMode = 'light';
+__decorate([
+    api
+], RouterContainer.prototype, "router", void 0);
+__decorate([
+    api
+], RouterContainer.prototype, "historyDisabled", void 0);
+//# sourceMappingURL=routerContainer.js.map

package/build/es/modules/lwr/routerContainer/utils.js

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import { HistoryRouter } from 'lwr/historyRouter';
+import { invariant, messages } from 'lwr/routerErrors';
+import { DomRouterImpl } from 'lwr/domRouter';
+/*
+ * Provides programmatic routing capabilities.
+ */
+// The application may create 1 root router at a time.
+let hasRoot = false;
+/**
+ * Create a new navigation context, attach to the given node.
+ * An application can only have ONE root router.
+ *
+ * @param {HTMLElement} - The DOM node where the navigation context should be established
+ * @param {object} config - The router config object, all properties are optional
+ *
+ * @returns {object} - { addPreNavigate, addPostNavigate, addErrorNavigate, connect, disconnect }
+ */
+export function createNavigationContext(node, config = {}, portableRouter) {
+    // Create a DOM or History Router
+    const newRouter = config.historyDisabled
+        ? new DomRouterImpl(config, portableRouter, node)
+        : new HistoryRouter(config, portableRouter, node);
+    // Return a subset of the new router's capabilities.
+    const routerAPI = {
+        /**
+         * Surface the preNavigate hook register function.
+         *
+         * @param {function} listener - The preNavigate hook listener function
+         * @returns {object} - This bag of Router functions, for chaining
+         */
+        addPreNavigate: (listener) => {
+            newRouter.addPreNavigate(listener);
+            return routerAPI;
+        },
+        /**
+         * Surface the postNavigate hook register function.
+         *
+         * @param {function} listener - The postNavigate hook listener function
+         * @returns {object} - This bag of Router functions, for chaining
+         */
+        addPostNavigate: (listener) => {
+            newRouter.subscribe(listener);
+            return routerAPI;
+        },
+        /**
+         * Surface the errorNavigate hook register function.
+         *
+         * @param {function} listener - The errorNavigate hook listener function
+         * @returns {object} - This bag of Router functions, for chaining
+         */
+        addErrorNavigate: (listener) => {
+            newRouter.addErrorNavigate(listener);
+            return routerAPI;
+        },
+        /**
+         * Connect the root router if there isn't already one connected.
+         */
+        connect: () => {
+            // Connect and expose this router's navigation context.
+            newRouter.connect();
+            // If there is already a root router, the new router must be a child (have a parent).
+            invariant(!hasRoot || !!newRouter.parent, messages.MULTIPLE_ROOTS);
+            hasRoot = hasRoot || !newRouter.parent;
+            routerAPI.id = newRouter.contextId;
+        },
+        /**
+         * Disconnect the router, and reset the root tracking variable.
+         */
+        disconnect: () => {
+            hasRoot = hasRoot && !!newRouter.parent;
+            newRouter.disconnect();
+        },
+    };
+    // Return the public Router functions.
+    return routerAPI;
+}
+//# sourceMappingURL=utils.js.map

package/build/es/modules/lwr/routerErrors/routerErrors.js

@@ -0,0 +1,154 @@
+const ERROR_CODE_PREFIX = 'LWR';
+const DiagnosticLevel = {
+    Fatal: 0,
+    Error: 1,
+    Warning: 2,
+    Log: 3,
+};
+function replaceArgs(message, args) {
+    return Array.isArray(args)
+        ? message.replace(/\{([0-9]+)\}/g, (_, index) => {
+            return args[index];
+        })
+        : message;
+}
+export function generateMessage(info, args) {
+    return `${info.code}: ${replaceArgs(info.message, args)}`;
+}
+export function generateMessageObject(info, args) {
+    const messageObject = {
+        ...info,
+        message: replaceArgs(info.message, args),
+    };
+    if (info.address) {
+        messageObject.address = replaceArgs(info.address, args);
+    }
+    if (info.stack) {
+        messageObject.stack = replaceArgs(info.stack, args);
+    }
+    return messageObject;
+}
+export function invariant(condition, errorInfo, args) {
+    if (!condition) {
+        throw new Error(generateMessage(errorInfo, args));
+    }
+}
+export const messages = {
+    INVALID_MIXIN_CMP: {
+        code: `${ERROR_CODE_PREFIX}4001`,
+        message: '{0} must be an Element type',
+        level: DiagnosticLevel.Error,
+    },
+    MISSING_CONTEXT: {
+        code: `${ERROR_CODE_PREFIX}4002`,
+        message: 'Could not find context to perform navigation action.',
+        level: DiagnosticLevel.Error,
+    },
+    INVALID_CONTEXT: {
+        code: `${ERROR_CODE_PREFIX}4003`,
+        message: 'Cannot register navigation context; it must have this shape: { navigate, generateUrl, subscribe }',
+        level: DiagnosticLevel.Error,
+    },
+    MULTIPLE_ROOTS: {
+        code: `${ERROR_CODE_PREFIX}4004`,
+        message: 'Router connection failed. There can only be one root router.',
+        level: DiagnosticLevel.Error,
+    },
+    MULTIPLE_CHILDREN: {
+        code: `${ERROR_CODE_PREFIX}4005`,
+        message: 'Could not add to the navigation hierarchy. There can only be one child per navigation node.',
+        level: DiagnosticLevel.Error,
+    },
+    MISSING_ROUTE: {
+        code: `${ERROR_CODE_PREFIX}4006`,
+        message: 'A route cannot be created to navigate to URL "{0}"',
+        level: DiagnosticLevel.Error,
+        address: '{0}',
+    },
+    MISSING_URL: {
+        code: `${ERROR_CODE_PREFIX}4007`,
+        message: 'A URL cannot be created to navigate to route "{0}"',
+        level: DiagnosticLevel.Error,
+        address: '{0}',
+    },
+    PRENAV_FAILED: {
+        code: `${ERROR_CODE_PREFIX}4008`,
+        message: 'A preNavigate hook listener blocked routing to "{0}"',
+        level: DiagnosticLevel.Warning,
+        address: '{0}',
+    },
+    MISSING_ROUTE_TEMPLATE: {
+        code: `${ERROR_CODE_PREFIX}4009`,
+        message: 'A route definition must contain a "uri" property.',
+        level: DiagnosticLevel.Error,
+    },
+    MISSING_ROUTE_CMP: {
+        code: `${ERROR_CODE_PREFIX}4016`,
+        message: 'Expected a route view component with a default export.',
+        level: DiagnosticLevel.Error,
+    },
+    MISSING_DATA_CONTEXT: {
+        code: `${ERROR_CODE_PREFIX}4018`,
+        message: 'Could not find context to retrieve navigation data.',
+        level: DiagnosticLevel.Error,
+    },
+    INVALID_ROUTE_QUERY: {
+        code: `${ERROR_CODE_PREFIX}4019`,
+        message: 'Invalid query param in route definition.',
+        level: DiagnosticLevel.Error,
+    },
+    MISSING_PAGE_BINDING: {
+        code: `${ERROR_CODE_PREFIX}4020`,
+        message: 'Route definition must provide page binding',
+        level: DiagnosticLevel.Error,
+    },
+    INVALID_PAGE_BINDING: {
+        code: `${ERROR_CODE_PREFIX}4021`,
+        message: 'Invalid page binding in route definition',
+        level: DiagnosticLevel.Error,
+    },
+    INVALID_URI_SYNTAX: {
+        code: `${ERROR_CODE_PREFIX}4022`,
+        message: 'Invalid uri syntax. URI cannot contain *, +, (, ), ',
+        level: DiagnosticLevel.Error,
+    },
+    VIEW_IMPORT_FAILED: {
+        code: `${ERROR_CODE_PREFIX}4023`,
+        message: 'Error importing view with name "{0}", failure was: {1}',
+        level: DiagnosticLevel.Error,
+        stack: '{2}',
+    },
+    VIEW_MISSING: {
+        code: `${ERROR_CODE_PREFIX}4024`,
+        message: 'Expected a view with name "{0}" in the viewset',
+        level: DiagnosticLevel.Error,
+    },
+    VIEW_IMPORT_FAILED_WITH_SPECIFIER: {
+        code: `${ERROR_CODE_PREFIX}4025`,
+        message: 'Error importing module "{0}" from view with name "{1}", failure was: {2}',
+        level: DiagnosticLevel.Error,
+        stack: '{3}',
+    },
+    NO_ROUTE_MATCH: {
+        code: `${ERROR_CODE_PREFIX}4026`,
+        message: 'A routing match cannot be found for: {0}',
+        level: DiagnosticLevel.Error,
+    },
+    INVALID_ROUTE_HANDLER: {
+        code: `${ERROR_CODE_PREFIX}4027`,
+        message: 'Route definition "{0}" does not have a valid route handler module',
+        level: DiagnosticLevel.Error,
+    },
+    DESTINATION_NOT_FOUND: {
+        code: `${ERROR_CODE_PREFIX}4028`,
+        message: 'Route handler returned 404: Not Found',
+        level: DiagnosticLevel.Error,
+    },
+    DESTINATION_ERROR: {
+        code: `${ERROR_CODE_PREFIX}4029`,
+        message: 'Route handler returned error status {0}: {1}',
+        level: DiagnosticLevel.Error,
+        stack: '{2}',
+    },
+};
+//# sourceMappingURL=routerErrors.js.map

package/build/es/modules/lwr/routerUtils/domUtils.js

@@ -0,0 +1,3 @@
+/* eslint-disable lwr/no-unguarded-apis */
+export const hasDocument = typeof document !== 'undefined';
+//# sourceMappingURL=domUtils.js.map

package/build/{modules → es/modules}/lwr/routerUtils/filterUtils.d.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-export declare type Filter<V> = (v: V) => Promise<boolean> | boolean;
+export type Filter<V> = (v: V) => Promise<boolean> | boolean;
 export interface FilterChain<V> {
     add: (f: Filter<V>[] | Filter<V>) => void;
     compile: (arg: V) => Promise<boolean>;

package/build/es/modules/lwr/routerUtils/filterUtils.js

@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * Creates a filter chain as an array. Filters can return true, false or a Promise resulting in true or false.
+ *
+ * @returns {object}
+ */
+export function createFilterChain() {
+    // The filter array.
+    const filters = [];
+    // Return true if this chain contains no filters.
+    const empty = () => {
+        return filters.length === 0;
+    };
+    const addSingle = (filter) => {
+        if (typeof filter === 'function') {
+            filters.push(filter);
+        }
+    };
+    // Add a filter or array of filters to the chain.
+    const add = (f = []) => {
+        if (Array.isArray(f)) {
+            f.forEach((l) => addSingle(l));
+        }
+        else {
+            addSingle(f);
+        }
+    };
+    // Get the Promised results for all filters.
+    const compile = (arg) => {
+        // Call all the functions with the given arguments.
+        // Return Promise<true> if there are no filters.
+        return filters.length === 0
+            ? Promise.resolve(true)
+            : // Reduce the listener array down to a single value:
+                //      a false -> false
+                //      all truthy -> true
+                // Previous is a Promise and current is a function.
+                filters
+                    .reduce((previous, current) => {
+                    // Chain the current to the previous listener function; reject false values.
+                    // Remember that previous is a Promise and current is a functions.
+                    return previous.then((val) => {
+                        return val === false ? Promise.reject() : Promise.resolve(current(arg));
+                    });
+                    // Start optimistically with TRUE.
+                }, Promise.resolve(true))
+                    // Handle trailing false values
+                    // This happens when the last listener returns a Promise that resolves to false
+                    .then((val) => {
+                    return val === false ? false : true;
+                })
+                    // If caught promise rejection contains an Error, throw instead of resolving to false
+                    .catch((error) => {
+                    if (error instanceof Error) {
+                        throw error;
+                    }
+                    else {
+                        return false;
+                    }
+                });
+    };
+    // Return the API methods.
+    return {
+        add,
+        compile,
+        empty,
+    };
+}
+//# sourceMappingURL=filterUtils.js.map