preboot/esm2015/api/event.replayer.js

import { getNodeKeyForPreboot } from '../common/get-node-key';
export function _window() {
    return {
        prebootData: window['prebootData'],
        getComputedStyle: window.getComputedStyle,
        document: document
    };
}
export class EventReplayer {
    constructor() {
        this.clientNodeCache = {};
        this.replayStarted = false;
    }
    /**
     * Window setting and getter to facilitate testing of window
     * in non-browser environments
     */
    setWindow(win) {
        this.win = win;
    }
    /**
     * Window setting and getter to facilitate testing of window
     * in non-browser environments
     */
    getWindow() {
        if (!this.win) {
            this.win = _window();
        }
        return this.win;
    }
    /**
     * Replay all events for all apps. this can only be run once.
     * if called multiple times, will only do something once
     */
    replayAll() {
        if (this.replayStarted) {
            return;
        }
        else {
            this.replayStarted = true;
        }
        // loop through each of the preboot apps
        const prebootData = this.getWindow().prebootData || {};
        const apps = prebootData.apps || [];
        apps.forEach(appData => this.replayForApp(appData));
        // once all events have been replayed and buffers switched, then we cleanup preboot
        this.cleanup(prebootData);
    }
    /**
     * Replay all events for one app (most of the time there is just one app)
     * @param appData
     */
    replayForApp(appData) {
        appData = (appData || {});
        // try catch around events b/c even if error occurs, we still move forward
        try {
            const events = appData.events || [];
            // replay all the events from the server view onto the client view
            events.forEach(event => this.replayEvent(appData, event));
        }
        catch (ex) {
            console.error(ex);
        }
        // if we are buffering, switch the buffers
        this.switchBuffer(appData);
    }
    /**
     * Replay one particular event
     * @param appData
     * @param prebootEvent
     */
    replayEvent(appData, prebootEvent) {
        appData = (appData || {});
        prebootEvent = (prebootEvent || {});
        const event = prebootEvent.event;
        const serverNode = prebootEvent.node || {};
        const nodeKey = prebootEvent.nodeKey;
        const clientNode = this.findClientNode({
            root: appData.root,
            node: serverNode,
            nodeKey: nodeKey
        });
        // if client node can't be found, log a warning
        if (!clientNode) {
            console.warn(`Trying to dispatch event ${event.type} to node ${nodeKey}
        but could not find client node. Server node is: ${serverNode}`);
            return;
        }
        // now dispatch events and whatnot to the client node
        clientNode.checked = serverNode.checked;
        clientNode.selected = serverNode.selected;
        clientNode.value = serverNode.value;
        clientNode.dispatchEvent(event);
    }
    /**
     * Switch the buffer for one particular app (i.e. display the client
     * view and destroy the server view)
     * @param appData
     */
    switchBuffer(appData) {
        appData = (appData || {});
        const root = (appData.root || {});
        const serverView = root.serverNode;
        const clientView = root.clientNode;
        // if no client view or the server view is the body or client
        // and server view are the same, then don't do anything and return
        if (!clientView || !serverView || serverView === clientView || serverView.nodeName === 'BODY') {
            return;
        }
        // do a try-catch just in case something messed up
        try {
            // get the server view display mode
            const gcs = this.getWindow().getComputedStyle;
            const display = gcs(serverView).getPropertyValue('display') || 'block';
            // first remove the server view
            serverView.remove ? serverView.remove() : (serverView.style.display = 'none');
            // now add the client view
            clientView.style.display = display;
        }
        catch (ex) {
            console.error(ex);
        }
    }
    /**
     * Finally, set focus, remove all the event listeners and remove
     * any freeze screen that may be there
     * @param prebootData
     */
    cleanup(prebootData) {
        prebootData = prebootData || {};
        const listeners = prebootData.listeners || [];
        // set focus on the active node AFTER a small delay to ensure buffer
        // switched
        const activeNode = prebootData.activeNode;
        if (activeNode != null) {
            setTimeout(() => this.setFocus(activeNode), 1);
        }
        // remove all event listeners
        for (const listener of listeners) {
            listener.node.removeEventListener(listener.eventName, listener.handler);
        }
        // remove the freeze overlay if it exists
        const doc = this.getWindow().document;
        const prebootOverlay = doc.getElementById('prebootOverlay');
        if (prebootOverlay) {
            prebootOverlay.remove ?
                prebootOverlay.remove() : prebootOverlay.parentNode !== null ?
                prebootOverlay.parentNode.removeChild(prebootOverlay) :
                prebootOverlay.style.display = 'none';
        }
        // clear out the data stored for each app
        prebootData.apps = [];
        this.clientNodeCache = {};
        // send event to document that signals preboot complete
        // constructor is not supported by older browsers ( i.e. IE9-11 )
        // in these browsers, the type of CustomEvent will be "object"
        if (typeof CustomEvent === 'function') {
            const completeEvent = new CustomEvent('PrebootComplete');
            doc.dispatchEvent(completeEvent);
        }
        else {
            console.warn(`Could not dispatch PrebootComplete event.
       You can fix this by including a polyfill for CustomEvent.`);
        }
    }
    setFocus(activeNode) {
        // only do something if there is an active node
        if (!activeNode || !activeNode.node || !activeNode.nodeKey) {
            return;
        }
        // find the client node in the new client view
        const clientNode = this.findClientNode(activeNode);
        if (clientNode) {
            // set focus on the client node
            clientNode.focus();
            // set selection if a modern browser (i.e. IE9+, etc.)
            const selection = activeNode.selection;
            if (clientNode.setSelectionRange && selection) {
                try {
                    clientNode
                        .setSelectionRange(selection.start, selection.end, selection.direction);
                }
                catch (ex) { }
            }
        }
    }
    /**
     * Given a node from the server rendered view, find the equivalent
     * node in the client rendered view. We do this by the following approach:
     *      1. take the name of the server node tag (ex. div or h1 or input)
     *      2. add either id (ex. div#myid) or class names (ex. div.class1.class2)
     *      3. use that value as a selector to get all the matching client nodes
     *      4. loop through all client nodes found and for each generate a key value
     *      5. compare the client key to the server key; once there is a match,
     *          we have our client node
     *
     * NOTE: this only works when the client view is almost exactly the same as
     * the server view. we will need an improvement here in the future to account
     * for situations where the client view is different in structure from the
     * server view
     */
    findClientNode(serverNodeContext) {
        serverNodeContext = (serverNodeContext || {});
        const serverNode = serverNodeContext.node;
        const root = serverNodeContext.root;
        // if no server or client root, don't do anything
        if (!root || !root.serverNode || !root.clientNode) {
            return null;
        }
        // we use the string of the node to compare to the client node & as key in
        // cache
        const serverNodeKey = serverNodeContext.nodeKey || getNodeKeyForPreboot(serverNodeContext);
        // if client node already in cache, return it
        if (this.clientNodeCache[serverNodeKey]) {
            return this.clientNodeCache[serverNodeKey];
        }
        // get the selector for client nodes
        const className = (serverNode.className || '').replace('ng-binding', '').trim();
        let selector = serverNode.tagName;
        if (serverNode.id) {
            selector += `#${serverNode.id}`;
        }
        else if (className) {
            selector += `.${className.replace(/ /g, '.')}`;
        }
        // select all possible client nodes and look through them to try and find a
        // match
        const rootClientNode = root.clientNode;
        let clientNodes = rootClientNode.querySelectorAll(selector);
        // if nothing found, then just try the tag name as a final option
        if (!clientNodes.length) {
            console.log(`nothing found for ${selector} so using ${serverNode.tagName}`);
            clientNodes = rootClientNode.querySelectorAll(serverNode.tagName);
        }
        const length = clientNodes.length;
        for (let i = 0; i < length; i++) {
            const clientNode = clientNodes.item(i);
            // get the key for the client node
            const clientNodeKey = getNodeKeyForPreboot({
                root: root,
                node: clientNode
            });
            // if the client node key is exact match for the server node key, then we
            // found the client node
            if (clientNodeKey === serverNodeKey) {
                this.clientNodeCache[serverNodeKey] = clientNode;
                return clientNode;
            }
        }
        // if we get here and there is one clientNode, use it as a fallback
        if (clientNodes.length === 1) {
            this.clientNodeCache[serverNodeKey] = clientNodes[0];
            return clientNodes[0];
        }
        // if we get here it means we couldn't find the client node so give the user
        // a warning
        console.warn(`No matching client node found for ${serverNodeKey}.
       You can fix this by assigning this element a unique id attribute.`);
        return null;
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event.replayer.js","sourceRoot":"../../src/lib/","sources":["api/event.replayer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {\n  NodeContext,\n  PrebootAppData,\n  PrebootData,\n  PrebootEvent,\n  PrebootWindow,\n  ServerClientRoot,\n} from '../common/preboot.interfaces';\nimport {getNodeKeyForPreboot} from '../common/get-node-key';\n\nexport function _window(): PrebootWindow {\n  return {\n    prebootData: (window as any)['prebootData'],\n    getComputedStyle: window.getComputedStyle,\n    document: document\n  };\n}\n\nexport class EventReplayer {\n  clientNodeCache: { [key: string]: Element } = {};\n  replayStarted = false;\n  win: PrebootWindow;\n\n  /**\n   * Window setting and getter to facilitate testing of window\n   * in non-browser environments\n   */\n  setWindow(win: PrebootWindow) {\n    this.win = win;\n  }\n\n  /**\n   * Window setting and getter to facilitate testing of window\n   * in non-browser environments\n   */\n  getWindow() {\n    if (!this.win) {\n      this.win = _window();\n    }\n    return this.win;\n  }\n\n  /**\n   * Replay all events for all apps. this can only be run once.\n   * if called multiple times, will only do something once\n   */\n  replayAll() {\n    if (this.replayStarted) {\n      return;\n    } else {\n      this.replayStarted = true;\n    }\n\n    // loop through each of the preboot apps\n    const prebootData = this.getWindow().prebootData || {};\n    const apps = prebootData.apps || [];\n    apps.forEach(appData => this.replayForApp(appData));\n\n    // once all events have been replayed and buffers switched, then we cleanup preboot\n    this.cleanup(prebootData);\n  }\n\n  /**\n   * Replay all events for one app (most of the time there is just one app)\n   * @param appData\n   */\n  replayForApp(appData: PrebootAppData) {\n    appData = <PrebootAppData>(appData || {});\n\n    // try catch around events b/c even if error occurs, we still move forward\n    try {\n      const events = appData.events || [];\n\n      // replay all the events from the server view onto the client view\n      events.forEach(event => this.replayEvent(appData, event));\n    } catch (ex) {\n      console.error(ex);\n    }\n\n    // if we are buffering, switch the buffers\n    this.switchBuffer(appData);\n  }\n\n  /**\n   * Replay one particular event\n   * @param appData\n   * @param prebootEvent\n   */\n  replayEvent(appData: PrebootAppData, prebootEvent: PrebootEvent) {\n    appData = <PrebootAppData>(appData || {});\n    prebootEvent = <PrebootEvent>(prebootEvent || {});\n\n    const event = prebootEvent.event as Event;\n    const serverNode = prebootEvent.node || {};\n    const nodeKey = prebootEvent.nodeKey;\n    const clientNode = this.findClientNode({\n      root: appData.root,\n      node: serverNode,\n      nodeKey: nodeKey\n    });\n\n    // if client node can't be found, log a warning\n    if (!clientNode) {\n      console.warn(\n        `Trying to dispatch event ${event.type} to node ${nodeKey}\n        but could not find client node. Server node is: ${serverNode}`\n      );\n      return;\n    }\n\n    // now dispatch events and whatnot to the client node\n    (clientNode as HTMLInputElement).checked = serverNode.checked;\n    (clientNode as HTMLOptionElement).selected = serverNode.selected;\n    (clientNode as HTMLOptionElement).value = serverNode.value;\n    clientNode.dispatchEvent(event);\n  }\n\n  /**\n   * Switch the buffer for one particular app (i.e. display the client\n   * view and destroy the server view)\n   * @param appData\n   */\n  switchBuffer(appData: PrebootAppData) {\n    appData = <PrebootAppData>(appData || {});\n\n    const root = <ServerClientRoot>(appData.root || {});\n    const serverView = root.serverNode;\n    const clientView = root.clientNode;\n\n    // if no client view or the server view is the body or client\n    // and server view are the same, then don't do anything and return\n    if (!clientView || !serverView || serverView === clientView || serverView.nodeName === 'BODY') {\n      return;\n    }\n\n    // do a try-catch just in case something messed up\n    try {\n      // get the server view display mode\n      const gcs = this.getWindow().getComputedStyle;\n      const display = gcs(serverView).getPropertyValue('display') || 'block';\n\n      // first remove the server view\n      serverView.remove ? serverView.remove() : (serverView.style.display = 'none');\n\n      // now add the client view\n      clientView.style.display = display;\n    } catch (ex) {\n      console.error(ex);\n    }\n  }\n\n  /**\n   * Finally, set focus, remove all the event listeners and remove\n   * any freeze screen that may be there\n   * @param prebootData\n   */\n  cleanup(prebootData: PrebootData) {\n    prebootData = prebootData || {};\n\n    const listeners = prebootData.listeners || [];\n\n    // set focus on the active node AFTER a small delay to ensure buffer\n    // switched\n    const activeNode = prebootData.activeNode;\n    if (activeNode != null) {\n      setTimeout(() => this.setFocus(activeNode), 1);\n    }\n\n    // remove all event listeners\n    for (const listener of listeners) {\n      listener.node.removeEventListener(listener.eventName, listener.handler);\n    }\n\n    // remove the freeze overlay if it exists\n    const doc = this.getWindow().document;\n    const prebootOverlay = doc.getElementById('prebootOverlay');\n    if (prebootOverlay) {\n      prebootOverlay.remove ?\n        prebootOverlay.remove() : prebootOverlay.parentNode !== null ?\n        prebootOverlay.parentNode.removeChild(prebootOverlay) :\n        prebootOverlay.style.display = 'none';\n    }\n\n    // clear out the data stored for each app\n    prebootData.apps = [];\n    this.clientNodeCache = {};\n\n    // send event to document that signals preboot complete\n    // constructor is not supported by older browsers ( i.e. IE9-11 )\n    // in these browsers, the type of CustomEvent will be \"object\"\n    if (typeof CustomEvent === 'function') {\n      const completeEvent = new CustomEvent('PrebootComplete');\n      doc.dispatchEvent(completeEvent);\n    } else {\n      console.warn(`Could not dispatch PrebootComplete event.\n       You can fix this by including a polyfill for CustomEvent.`);\n    }\n  }\n\n  setFocus(activeNode: NodeContext) {\n    // only do something if there is an active node\n    if (!activeNode || !activeNode.node || !activeNode.nodeKey) {\n      return;\n    }\n\n    // find the client node in the new client view\n    const clientNode = this.findClientNode(activeNode);\n    if (clientNode) {\n      // set focus on the client node\n      clientNode.focus();\n\n      // set selection if a modern browser (i.e. IE9+, etc.)\n      const selection = activeNode.selection;\n      if ((clientNode as HTMLInputElement).setSelectionRange && selection) {\n        try {\n          (clientNode as HTMLInputElement)\n            .setSelectionRange(selection.start, selection.end, selection.direction);\n        } catch (ex) {}\n      }\n    }\n  }\n\n  /**\n   * Given a node from the server rendered view, find the equivalent\n   * node in the client rendered view. We do this by the following approach:\n   *      1. take the name of the server node tag (ex. div or h1 or input)\n   *      2. add either id (ex. div#myid) or class names (ex. div.class1.class2)\n   *      3. use that value as a selector to get all the matching client nodes\n   *      4. loop through all client nodes found and for each generate a key value\n   *      5. compare the client key to the server key; once there is a match,\n   *          we have our client node\n   *\n   * NOTE: this only works when the client view is almost exactly the same as\n   * the server view. we will need an improvement here in the future to account\n   * for situations where the client view is different in structure from the\n   * server view\n   */\n  findClientNode(serverNodeContext: NodeContext): HTMLElement | null {\n    serverNodeContext = <NodeContext>(serverNodeContext || {});\n\n    const serverNode = serverNodeContext.node;\n    const root = serverNodeContext.root;\n\n    // if no server or client root, don't do anything\n    if (!root || !root.serverNode || !root.clientNode) {\n      return null;\n    }\n\n    // we use the string of the node to compare to the client node & as key in\n    // cache\n    const serverNodeKey = serverNodeContext.nodeKey || getNodeKeyForPreboot(serverNodeContext);\n\n    // if client node already in cache, return it\n    if (this.clientNodeCache[serverNodeKey]) {\n      return this.clientNodeCache[serverNodeKey] as HTMLElement;\n    }\n\n    // get the selector for client nodes\n    const className = (serverNode.className || '').replace('ng-binding', '').trim();\n    let selector = serverNode.tagName;\n\n    if (serverNode.id) {\n      selector += `#${serverNode.id}`;\n    } else if (className) {\n      selector += `.${className.replace(/ /g, '.')}`;\n    }\n\n    // select all possible client nodes and look through them to try and find a\n    // match\n    const rootClientNode = root.clientNode;\n    let clientNodes = rootClientNode.querySelectorAll(selector);\n\n    // if nothing found, then just try the tag name as a final option\n    if (!clientNodes.length) {\n      console.log(`nothing found for ${selector} so using ${serverNode.tagName}`);\n      clientNodes = rootClientNode.querySelectorAll(serverNode.tagName);\n    }\n\n    const length = clientNodes.length;\n    for (let i = 0; i < length; i++) {\n      const clientNode = clientNodes.item(i);\n\n      // get the key for the client node\n      const clientNodeKey = getNodeKeyForPreboot({\n        root: root,\n        node: clientNode\n      });\n\n      // if the client node key is exact match for the server node key, then we\n      // found the client node\n      if (clientNodeKey === serverNodeKey) {\n        this.clientNodeCache[serverNodeKey] = clientNode;\n        return clientNode as HTMLElement;\n      }\n    }\n\n    // if we get here and there is one clientNode, use it as a fallback\n    if (clientNodes.length === 1) {\n      this.clientNodeCache[serverNodeKey] = clientNodes[0];\n      return clientNodes[0] as HTMLElement;\n    }\n\n    // if we get here it means we couldn't find the client node so give the user\n    // a warning\n    console.warn(\n      `No matching client node found for ${serverNodeKey}.\n       You can fix this by assigning this element a unique id attribute.`\n    );\n    return null;\n  }\n}\n"]}