@lwrjs/router 0.10.0-alpha.6 → 0.10.0-alpha.7

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

@@ -0,0 +1,30 @@
+import { createContextProvider } from 'lwc';
+import { hasDocument } from 'lwr/routerUtils';
+import { CurrentPageReference, CurrentView, NavigationContext } from 'lwr/navigation';
+// Creating a context with LWC requires eventing APIs, which are not available from "@lwc/engine-server"
+export const currentPageReferenceContextualizer = hasDocument
+    ? createContextProvider(CurrentPageReference)
+    : undefined;
+export const currentViewContextualizer = hasDocument ? createContextProvider(CurrentView) : undefined;
+export const navigationContextContextualizer = hasDocument
+    ? createContextProvider(NavigationContext)
+    : undefined;
+/**
+ *
+ * @param {TContext} contextValue - Context API object
+ * @param {EventTarget} providerNode - Context DOM element
+ * @param {Contextualizer} contextualizer - Function for providing this context to subtree nodes wired to a specific adapter
+ * @param {ContextualWireAdapter<TContext, TEmit, TConfig>} contextualAdapter - Contextual wire adapter capable of subscribing to context changes
+ */
+export function provideContext(contextValue, providerNode, contextualizer, contextualAdapter) {
+    if (contextualizer && contextualAdapter) {
+        // Set up provider to give context to wire adpaters so that a component connected
+        // under the providerNode subtree and wired to those adapters will receive this id
+        contextualAdapter.setContext(providerNode, contextValue);
+        contextualizer(providerNode, {
+            consumerConnectedCallback: contextualAdapter.subscribeContext.bind(contextualAdapter, providerNode),
+            consumerDisconnectedCallback: contextualAdapter.unsubscribeContext.bind(contextualAdapter, providerNode),
+        });
+    }
+}
+//# sourceMappingURL=contextProvider.js.map

package/build/es/modules/lwr/contextUtils/contextInfo.js

@@ -0,0 +1,93 @@
+function validateProvider(obj) {
+    if (obj === undefined || obj === null) {
+        throw new TypeError('Provider must be defined.');
+    }
+}
+/**
+ * Manages context for various providers
+ */
+export class ContextInfo {
+    constructor(defaultValue) {
+        this.infoMap = new WeakMap();
+        this.defaultValue = defaultValue;
+    }
+    /**
+     * Gets the stored info for a context provider
+     * @param targetProvider the context provider
+     */
+    getInfo(targetProvider) {
+        let info = this.infoMap.get(targetProvider);
+        if (info === undefined) {
+            info = { consumers: new Set() };
+            this.infoMap.set(targetProvider, info);
+        }
+        return info;
+    }
+    /**
+     * Set the context value directly associated with the target as a context provider.
+     *
+     * @param {Object} targetProvider
+     * @param {FeatureContext} contextValue
+     */
+    setContext(targetProvider, contextValue) {
+        validateProvider(targetProvider);
+        const value = contextValue;
+        const info = this.getInfo(targetProvider);
+        info.contextValue = contextValue;
+        info.consumers.forEach((consumer) => consumer.provide(value));
+        if (info.consumers.size === 0 && value?.onComplete) {
+            // Ensure that wire callbacks are executed even if the wire has 0 subscribers
+            value.onComplete();
+        }
+    }
+    /**
+     * Get the context value directly associated with the target as a context provider.
+     *
+     * @param {Object} targetProvider
+     */
+    getContext(targetProvider) {
+        validateProvider(targetProvider);
+        const { contextValue } = this.getInfo(targetProvider);
+        return contextValue !== undefined ? contextValue : this.defaultValue;
+    }
+    /**
+     * Clear the context value and registered subscribers directly associated with the
+     * target as a context provider.
+     *
+     * @param {Object} targetProvider
+     */
+    clearContext(targetProvider) {
+        validateProvider(targetProvider);
+        this.infoMap.delete(targetProvider);
+    }
+    /**
+     * Subscribe a consumer to the context value directly associated with the target as
+     * a context provider. Calls to #set(targetProvider, contextValue) with the same
+     * target will invoke the consumer.provide(contextValue) function.
+     *
+     * NOTE: Mutations to the contextValue directly do not result in calls to
+     * consumer.provide(contextValue).
+     *
+     * @param {Object} targetProvider
+     * @param {ContextConsumer} consumer object with a provide(context) function property.
+     */
+    subscribeContext(targetProvider, consumer) {
+        validateProvider(targetProvider);
+        const { consumers, contextValue } = this.getInfo(targetProvider);
+        if (!consumers.has(consumer)) {
+            consumers.add(consumer);
+            consumer.provide(contextValue);
+        }
+    }
+    /**
+     * Unsubscribe a previously subscribed consumer from listening to changes on the
+     * target
+     * @param {Object} targetProvider
+     * @param {ContextConsumer} consumer
+     */
+    unsubscribeContext(targetProvider, consumer) {
+        validateProvider(targetProvider);
+        this.getInfo(targetProvider).consumers.delete(consumer);
+    }
+}
+//# sourceMappingURL=contextInfo.js.map

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

@@ -0,0 +1,77 @@
+import { ContextInfo } from './contextInfo';
+export { ContextInfo };
+export { getNavigationHelm, registerNavigationHelm } from './navigationApiStore';
+export function generateContextualWireAdapter(contextInstance) {
+    var _a;
+    const Adapter = (_a = class Adapter {
+            constructor(callback) {
+                this._callback = callback;
+            }
+            connect() {
+                // There is no 'connect' because context is provided via the update API.
+            }
+            disconnect() {
+                // no-op
+            }
+            // The default update method services wires that emit context as TEmit when their value changes.
+            // Wires that need more complex logic or use another emit type should override this method.
+            update(config, context) {
+                if (context) {
+                    this._callback(context);
+                }
+            }
+            /**
+             * Set the context value directly associated with the target as a context provider.
+             *
+             * @param {EventTarget} targetProvider
+             * @param {ContextId} contextValue
+             */
+            static setContext(targetProvider, contextValue) {
+                contextInstance.setContext(targetProvider, contextValue);
+            }
+            /**
+             * Get the context value directly associated with the target as a context provider.
+             *
+             * @param {EventTarget} targetProvider
+             */
+            static getContext(targetProvider) {
+                return contextInstance.getContext(targetProvider);
+            }
+            /**
+             * Clear the context value and registered subscribers directly associated with the
+             * target as a context provider.
+             *
+             * @param {EventTarget} targetProvider
+             */
+            static clearContext(targetProvider) {
+                contextInstance.clearContext(targetProvider);
+            }
+            /**
+             * Subscribe a consumer to the context value directly associated with the target as
+             * a context provider. Calls to #set(targetProvider, contextValue) with the same
+             * target will invoke the consumer.provide(contextValue) function.
+             *
+             * NOTE: Mutations to the contextValue directly do not result in calls to
+             * consumer.provide(contextValue).
+             *
+             * @param {EventTarget} targetProvider
+             * @param {ContextConsumer} consumer object with a provide(context) function property.
+             */
+            static subscribeContext(targetProvider, consumer) {
+                contextInstance.subscribeContext(targetProvider, consumer);
+            }
+            /**
+             * Unsubscribe a previously subscribed consumer from listening to changes on the
+             * target
+             * @param {EventTarget} targetProvider
+             * @param {ContextConsumer} consumer
+             */
+            static unsubscribeContext(targetProvider, consumer) {
+                contextInstance.unsubscribeContext(targetProvider, consumer);
+            }
+        },
+        _a.contextSchema = { value: 'required' },
+        _a);
+    return Adapter;
+}
+//# sourceMappingURL=contextUtils.js.map

package/build/es/modules/lwr/contextUtils/navigationApiStore.js

@@ -0,0 +1,46 @@
+/**
+ * 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 { generateMessage, messages } from 'lwr/routerErrors';
+// Keep a cache of context metadata, with their IDs as keys
+const CACHE = new WeakMap();
+/**
+ * Return a navigation context by ID.
+ * Exported API.
+ *
+ * @param {*} id - The ID of a navigation context.
+ *
+ * @return {object} - { navigate(), generateUrl(), subscribe() }
+ */
+export function getNavigationHelm(id) {
+    const metadata = CACHE.get(id);
+    if (!metadata || !metadata.value) {
+        throw new Error(generateMessage(messages.MISSING_CONTEXT));
+    }
+    return metadata.value;
+}
+/**
+ * Create and return the metadata for this context provider.
+ * Cache the metadata by ID.
+ *
+ * @param {object} contextValue - Context API object
+ * @param {RouteDefinition[]} data - Route data for this context
+ *
+ * @return {object} - The metadata object
+ */
+export function registerNavigationHelm(contextId, contextValue) {
+    const metadata = {
+        id: contextId,
+        value: contextValue,
+        update: (newValue) => {
+            metadata.value = newValue;
+        },
+    };
+    // Cache and return.
+    CACHE.set(metadata.id, metadata);
+    return metadata;
+}
+//# sourceMappingURL=navigationApiStore.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * 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 { generateContextualWireAdapter, ContextInfo } from 'lwr/contextUtils';
+const CURRENT_PAGE_REFERENCE_CONTEXT = new ContextInfo(undefined);
+/**
+ * Services @wire(CurrentPageReference) requests.
+ * Hooks up to an Observable from the current navigation context.
+ */
+export const CurrentPageReference = generateContextualWireAdapter(CURRENT_PAGE_REFERENCE_CONTEXT);
+//# sourceMappingURL=currentPageReference.js.map

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

@@ -0,0 +1,62 @@
+/**
+ * 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 { generateContextualWireAdapter, ContextInfo } from 'lwr/contextUtils';
+import { generateMessageObject, messages } from 'lwr/routerErrors';
+const CURRENT_VIEW_CONTEXT = new ContextInfo(undefined);
+/**
+ * Services @wire(CurrentView) requests.
+ * Hooks up to an Observable from the current navigation context.
+ */
+export const CurrentView = class CurrentView extends generateContextualWireAdapter(CURRENT_VIEW_CONTEXT) {
+    async update(config, context) {
+        if (context) {
+            const viewName = config && config.viewName ? config.viewName : 'default';
+            const viewEntry = context.viewset[viewName]; // either ViewInfo or an importer function
+            const viewInfo = viewEntry;
+            const viewImporter = (viewInfo && viewInfo.module) || viewEntry;
+            let importError;
+            if (viewImporter) {
+                try {
+                    const viewModule = await viewImporter();
+                    const newViewCtor = viewModule && viewModule.default;
+                    if (newViewCtor && newViewCtor.constructor !== undefined) {
+                        this._callback(newViewCtor);
+                    }
+                    else {
+                        // delegate to catch for consistent error handling
+                        throw new Error('error occurred with view import');
+                    }
+                }
+                catch (e) {
+                    const error = e;
+                    if (viewInfo.specifier) {
+                        importError = generateMessageObject(messages.VIEW_IMPORT_FAILED_WITH_SPECIFIER, [
+                            viewInfo.specifier,
+                            viewName,
+                            error.message,
+                            error.stack || '',
+                        ]);
+                    }
+                    else {
+                        importError = generateMessageObject(messages.VIEW_IMPORT_FAILED, [
+                            viewName,
+                            error.message,
+                            error.stack || '',
+                        ]);
+                    }
+                }
+            }
+            else {
+                importError = generateMessageObject(messages.VIEW_MISSING, [viewName]);
+            }
+            if (context.onComplete) {
+                context.onComplete(importError);
+            }
+        }
+    }
+};
+//# sourceMappingURL=currentView.js.map