ngx-preboot
Version:
Record server view events and play back to Angular client view
267 lines • 34.6 kB
JavaScript
import { getNodeKeyForPreboot } from '../common/get-node-key';
export function _window() {
return {
prebootData: window['prebootData'],
getComputedStyle: window.getComputedStyle.bind(window),
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;
clientView.style.cssText = `display: ${display}; visibility:hidden; z-index: 0;position: absolute;top: 0;left: 0;right: 0;bottom: 0; transition: visibility .3s ease-in-out`;
setTimeout(() => {
serverView.remove ? serverView.remove() : (serverView.style.display = 'none');
clientView.style.visibility = 'visible';
}, 300);
}
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;
// 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);
const prebootOverlay = doc.getElementById('prebootOverlay');
if (prebootOverlay) {
prebootOverlay.remove
? prebootOverlay.remove()
: prebootOverlay.parentNode !== null
? prebootOverlay.parentNode.removeChild(prebootOverlay)
: (prebootOverlay.style.display = 'none');
}
}
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 { NodeContext, PrebootAppData, PrebootData, PrebootEvent, PrebootWindow, ServerClientRoot } 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.bind(window),\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\n      clientView.style.cssText = `display: ${display}; visibility:hidden; z-index: 0;position: absolute;top: 0;left: 0;right: 0;bottom: 0; transition: visibility .3s ease-in-out`;\n\n      setTimeout(() => {\n        serverView.remove ? serverView.remove() : (serverView.style.display = 'none');\n        clientView.style.visibility = 'visible';\n      }, 300);\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\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      const prebootOverlay = doc.getElementById('prebootOverlay');\n      if (prebootOverlay) {\n        prebootOverlay.remove\n          ? prebootOverlay.remove()\n          : prebootOverlay.parentNode !== null\n          ? prebootOverlay.parentNode.removeChild(prebootOverlay)\n          : (prebootOverlay.style.display = 'none');\n      }\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).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"]}