ngx-preboot
Version:
Record server view events and play back to Angular client view
271 lines • 35.9 kB
JavaScript
import { getNodeKeyForPreboot } from '../common/get-node-key';
/**
* Called right away to initialize preboot
*
* @param opts All the preboot options
* @param win
*/
export function initAll(opts, win) {
const theWindow = (win || window);
// Add the preboot options to the preboot data and then add the data to
// the window so it can be used later by the client.
// Only set new options if they're not already set - we may have multiple app roots
// and each of them invokes the init function separately.
const data = (theWindow.prebootData = {
opts: opts,
apps: [],
listeners: [],
});
return () => start(data, theWindow);
}
/**
* Start up preboot by going through each app and assigning the appropriate
* handlers. Normally this wouldn't be called directly, but we have set it up so
* that it can for older versions of Universal.
*
* @param prebootData Global preboot data object that contains options and will
* have events
* @param win Optional param to pass in mock window for testing purposes
*/
export function start(prebootData, win) {
const theWindow = (win || window);
const _document = (theWindow.document || {});
// Remove the current script from the DOM so that child indexes match
// between the client & the server. The script is already running so it
// doesn't affect it.
const currentScript = _document.currentScript ||
// Support: IE 9-11 only
// IE doesn't support document.currentScript. Since the script is invoked
// synchronously, though, the current running script is just the last one
// currently in the document.
[].slice.call(_document.getElementsByTagName('script'), -1)[0];
if (!currentScript) {
console.error('Preboot initialization failed, no currentScript has been detected.');
return;
}
let serverNode = currentScript.parentNode;
if (!serverNode) {
console.error('Preboot initialization failed, the script is detached');
return;
}
serverNode.removeChild(currentScript);
const opts = prebootData.opts || {};
let eventSelectors = opts.eventSelectors || [];
// get the root info
const appRoot = prebootData.opts ? getAppRoot(_document, prebootData.opts, serverNode) : null;
// we track all events for each app in the prebootData object which is on
// the global scope; each `start` invocation adds data for one app only.
const appData = { root: appRoot, events: [] };
if (prebootData.apps) {
prebootData.apps.push(appData);
}
eventSelectors = eventSelectors.map((eventSelector) => {
if (!eventSelector.hasOwnProperty('replay')) {
eventSelector.replay = true;
}
return eventSelector;
});
// loop through all the eventSelectors and create event handlers
eventSelectors.forEach((eventSelector) => handleEvents(_document, prebootData, appData, eventSelector));
}
/**
* Create an overlay div and add it to the DOM so it can be used
* if a freeze event occurs
*
* @param _document The global document object (passed in for testing purposes)
* @returns Element The overlay node is returned
*/
export function createOverlay(_document) {
let overlay = _document.createElement('div');
overlay.setAttribute('id', 'prebootOverlay');
overlay.setAttribute('style', 'display:none;position:absolute;left:0;' + 'top:0;width:100%;height:100%;z-index:999999;background:black;opacity:.3');
_document.documentElement.appendChild(overlay);
return overlay;
}
/**
* Get references to the current app root node based on input options. Users can
* initialize preboot either by specifying appRoot which is just one or more
* selectors for apps. This section option is useful for people that are doing their own
* buffering (i.e. they have their own client and server view)
*
* @param _document The global document object used to attach the overlay
* @param opts Options passed in by the user to init()
* @param serverNode The server node serving as application root
* @returns ServerClientRoot An array of root info for the current app
*/
export function getAppRoot(_document, opts, serverNode) {
const root = { serverNode };
// if we are doing buffering, we need to create the buffer for the client
// else the client root is the same as the server
root.clientNode = opts.buffer ? createBuffer(root) : root.serverNode;
// create an overlay if not disabled ,that can be used later if a freeze event occurs
if (!opts.disableOverlay) {
root.overlay = createOverlay(_document);
}
return root;
}
/**
* Under given server root, for given selector, record events
*
* @param _document
* @param prebootData
* @param appData
* @param eventSelector
*/
export function handleEvents(_document, prebootData, appData, eventSelector) {
const serverRoot = appData.root.serverNode;
// don't do anything if no server root
if (!serverRoot) {
return;
}
// Attach delegated event listeners for each event selector.
// We need to use delegated events as only the top level server node
// exists at this point.
eventSelector.events.forEach((eventName) => {
// get the appropriate handler and add it as an event listener
const handler = createListenHandler(_document, prebootData, eventSelector, appData);
// attach the handler in the capture phase so that it fires even if
// one of the handlers below calls stopPropagation()
serverRoot.addEventListener(eventName, handler, true);
// need to keep track of listeners so we can do node.removeEventListener()
// when preboot done
if (prebootData.listeners) {
prebootData.listeners.push({
node: serverRoot,
eventName,
handler,
});
}
});
}
/**
* Create handler for events that we will record
*/
export function createListenHandler(_document, prebootData, eventSelector, appData) {
const CARET_EVENTS = ['keyup', 'keydown', 'focusin', 'mouseup', 'mousedown'];
const CARET_NODES = ['INPUT', 'TEXTAREA'];
// Support: IE 9-11 only
// IE uses a prefixed `matches` version
const matches = _document.documentElement.matches || _document.documentElement.msMatchesSelector;
const opts = prebootData.opts;
return function (event) {
const node = event.target;
// a delegated handlers on document is used so we need to check if
// event target matches a desired selector
if (!matches.call(node, eventSelector.selector)) {
return;
}
const root = appData.root;
const eventName = event.type;
// if no node or no event name, just return
if (!node || !eventName) {
return;
}
// if key codes set for eventSelector, then don't do anything if event
// doesn't include key
const keyCodes = eventSelector.keyCodes;
if (keyCodes && keyCodes.length) {
const matchingKeyCodes = keyCodes.filter((keyCode) => event.which === keyCode);
// if there are not matches (i.e. key entered NOT one of the key codes)
// then don't do anything
if (!matchingKeyCodes.length) {
return;
}
}
// if for a given set of events we are preventing default, do that
if (eventSelector.preventDefault) {
event.preventDefault();
}
// if an action handler passed in, use that
if (eventSelector.action) {
eventSelector.action(node, event);
}
// get the node key for a given node
const nodeKey = getNodeKeyForPreboot({ root: root, node: node });
// record active node
if (CARET_EVENTS.indexOf(eventName) >= 0) {
// if it's an caret node, get the selection for the active node
const isCaretNode = CARET_NODES.indexOf(node.tagName ? node.tagName : '') >= 0;
prebootData.activeNode = {
root: root,
node: node,
nodeKey: nodeKey,
selection: isCaretNode ? getSelection(node) : undefined,
};
}
else if (eventName !== 'change' && eventName !== 'focusout') {
prebootData.activeNode = undefined;
}
// if overlay is not disabled and we are freezing the UI
if (opts && !opts.disableOverlay && eventSelector.freeze) {
const overlay = root.overlay;
// show the overlay
overlay.style.display = 'block';
overlay.classList.add('is-loading');
// hide the overlay after 10 seconds just in case preboot.complete() never
// called
setTimeout(() => {
overlay.style.display = 'none';
}, 10000);
}
// we will record events for later replay unless explicitly marked as
// doNotReplay
if (eventSelector.replay) {
appData.events.push({
node,
nodeKey,
event,
name: eventName,
});
}
};
}
/**
* Get the selection data that is later used to set the cursor after client view
* is active
*/
export function getSelection(node) {
node = node || {};
const nodeValue = node.value || '';
const selection = {
start: nodeValue.length,
end: nodeValue.length,
direction: 'forward',
};
// if browser support selectionStart on node (Chrome, FireFox, IE9+)
try {
if (node.selectionStart || node.selectionStart === 0) {
selection.start = node.selectionStart;
selection.end = node.selectionEnd ? node.selectionEnd : 0;
selection.direction = node.selectionDirection ? node.selectionDirection : 'none';
}
}
catch (ex) { }
return selection;
}
/**
* Create buffer for a given node
*
* @param root All the data related to a particular app
* @returns Returns the root client node.
*/
export function createBuffer(root) {
const serverNode = root.serverNode;
// if no rootServerNode OR the selector is on the entire html doc or the body
// OR no parentNode, don't buffer
if (!serverNode || !serverNode.parentNode || serverNode === document.documentElement || serverNode === document.body) {
return serverNode;
}
// create shallow clone of server root
const rootClientNode = serverNode.cloneNode(false);
// we want the client to write to a hidden div until the time for switching
// the buffers
rootClientNode.style.display = 'none';
// insert the client node before the server and return it
serverNode.parentNode.insertBefore(rootClientNode, serverNode);
// mark server node as not to be touched by AngularJS - needed for ngUpgrade
serverNode.setAttribute('ng-non-bindable', '');
// return the rootClientNode
return rootClientNode;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event.recorder.js","sourceRoot":"../../src/lib/","sources":["api/event.recorder.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  EventSelector,\n  PrebootOptions,\n  PrebootAppData,\n  PrebootData,\n  DomEvent,\n  PrebootWindow,\n  ServerClientRoot,\n  PrebootSelection,\n  PrebootSelectionDirection,\n} from '../common/preboot.interfaces';\nimport { getNodeKeyForPreboot } from '../common/get-node-key';\n\n/**\n * Called right away to initialize preboot\n *\n * @param opts All the preboot options\n * @param win\n */\nexport function initAll(opts: PrebootOptions, win?: PrebootWindow) {\n  const theWindow = <PrebootWindow>(win || window);\n\n  // Add the preboot options to the preboot data and then add the data to\n  // the window so it can be used later by the client.\n  // Only set new options if they're not already set - we may have multiple app roots\n  // and each of them invokes the init function separately.\n  const data = (theWindow.prebootData = <PrebootData>{\n    opts: opts,\n    apps: [],\n    listeners: [],\n  });\n\n  return () => start(data, theWindow);\n}\n\n/**\n * Start up preboot by going through each app and assigning the appropriate\n * handlers. Normally this wouldn't be called directly, but we have set it up so\n * that it can for older versions of Universal.\n *\n * @param prebootData Global preboot data object that contains options and will\n * have events\n * @param win Optional param to pass in mock window for testing purposes\n */\nexport function start(prebootData: PrebootData, win?: PrebootWindow) {\n  const theWindow = <PrebootWindow>(win || window);\n  const _document = <Document>(theWindow.document || {});\n\n  // Remove the current script from the DOM so that child indexes match\n  // between the client & the server. The script is already running so it\n  // doesn't affect it.\n  const currentScript =\n    _document.currentScript ||\n    // Support: IE 9-11 only\n    // IE doesn't support document.currentScript. Since the script is invoked\n    // synchronously, though, the current running script is just the last one\n    // currently in the document.\n    [].slice.call(_document.getElementsByTagName('script'), -1)[0];\n\n  if (!currentScript) {\n    console.error('Preboot initialization failed, no currentScript has been detected.');\n    return;\n  }\n\n  let serverNode = currentScript.parentNode;\n  if (!serverNode) {\n    console.error('Preboot initialization failed, the script is detached');\n    return;\n  }\n\n  serverNode.removeChild(currentScript);\n\n  const opts = prebootData.opts || ({} as PrebootOptions);\n  let eventSelectors = opts.eventSelectors || [];\n\n  // get the root info\n  const appRoot = prebootData.opts ? getAppRoot(_document, prebootData.opts, serverNode) : null;\n\n  // we track all events for each app in the prebootData object which is on\n  // the global scope; each `start` invocation adds data for one app only.\n  const appData = <PrebootAppData>{ root: appRoot, events: [] };\n  if (prebootData.apps) {\n    prebootData.apps.push(appData);\n  }\n\n  eventSelectors = eventSelectors.map((eventSelector) => {\n    if (!eventSelector.hasOwnProperty('replay')) {\n      eventSelector.replay = true;\n    }\n    return eventSelector;\n  });\n\n  // loop through all the eventSelectors and create event handlers\n  eventSelectors.forEach((eventSelector) => handleEvents(_document, prebootData, appData, eventSelector));\n}\n\n/**\n * Create an overlay div and add it to the DOM so it can be used\n * if a freeze event occurs\n *\n * @param _document The global document object (passed in for testing purposes)\n * @returns Element The overlay node is returned\n */\nexport function createOverlay(_document: Document): HTMLElement | undefined {\n  let overlay = _document.createElement('div');\n  overlay.setAttribute('id', 'prebootOverlay');\n  overlay.setAttribute(\n    'style',\n    'display:none;position:absolute;left:0;' + 'top:0;width:100%;height:100%;z-index:999999;background:black;opacity:.3'\n  );\n  _document.documentElement.appendChild(overlay);\n\n  return overlay;\n}\n\n/**\n * Get references to the current app root node based on input options. Users can\n * initialize preboot either by specifying appRoot which is just one or more\n * selectors for apps. This section option is useful for people that are doing their own\n * buffering (i.e. they have their own client and server view)\n *\n * @param _document The global document object used to attach the overlay\n * @param opts Options passed in by the user to init()\n * @param serverNode The server node serving as application root\n * @returns ServerClientRoot An array of root info for the current app\n */\nexport function getAppRoot(_document: Document, opts: PrebootOptions, serverNode: HTMLElement): ServerClientRoot {\n  const root: ServerClientRoot = { serverNode };\n\n  // if we are doing buffering, we need to create the buffer for the client\n  // else the client root is the same as the server\n  root.clientNode = opts.buffer ? createBuffer(root) : root.serverNode;\n\n  // create an overlay if not disabled ,that can be used later if a freeze event occurs\n  if (!opts.disableOverlay) {\n    root.overlay = createOverlay(_document);\n  }\n\n  return root;\n}\n\n/**\n * Under given server root, for given selector, record events\n *\n * @param _document\n * @param prebootData\n * @param appData\n * @param eventSelector\n */\nexport function handleEvents(_document: Document, prebootData: PrebootData, appData: PrebootAppData, eventSelector: EventSelector) {\n  const serverRoot = appData.root.serverNode;\n\n  // don't do anything if no server root\n  if (!serverRoot) {\n    return;\n  }\n\n  // Attach delegated event listeners for each event selector.\n  // We need to use delegated events as only the top level server node\n  // exists at this point.\n  eventSelector.events.forEach((eventName: string) => {\n    // get the appropriate handler and add it as an event listener\n    const handler = createListenHandler(_document, prebootData, eventSelector, appData);\n    // attach the handler in the capture phase so that it fires even if\n    // one of the handlers below calls stopPropagation()\n    serverRoot.addEventListener(eventName, handler, true);\n\n    // need to keep track of listeners so we can do node.removeEventListener()\n    // when preboot done\n    if (prebootData.listeners) {\n      prebootData.listeners.push({\n        node: serverRoot,\n        eventName,\n        handler,\n      });\n    }\n  });\n}\n\n/**\n * Create handler for events that we will record\n */\nexport function createListenHandler(\n  _document: Document,\n  prebootData: PrebootData,\n  eventSelector: EventSelector,\n  appData: PrebootAppData\n): EventListener {\n  const CARET_EVENTS = ['keyup', 'keydown', 'focusin', 'mouseup', 'mousedown'];\n  const CARET_NODES = ['INPUT', 'TEXTAREA'];\n\n  // Support: IE 9-11 only\n  // IE uses a prefixed `matches` version\n  const matches = _document.documentElement.matches || (_document.documentElement as any).msMatchesSelector;\n  const opts = prebootData.opts;\n\n  return function (event: DomEvent) {\n    const node: Element = event.target;\n\n    // a delegated handlers on document is used so we need to check if\n    // event target matches a desired selector\n    if (!matches.call(node, eventSelector.selector)) {\n      return;\n    }\n\n    const root = appData.root;\n    const eventName = event.type;\n\n    // if no node or no event name, just return\n    if (!node || !eventName) {\n      return;\n    }\n\n    // if key codes set for eventSelector, then don't do anything if event\n    // doesn't include key\n    const keyCodes = eventSelector.keyCodes;\n    if (keyCodes && keyCodes.length) {\n      const matchingKeyCodes = keyCodes.filter((keyCode) => event.which === keyCode);\n\n      // if there are not matches (i.e. key entered NOT one of the key codes)\n      // then don't do anything\n      if (!matchingKeyCodes.length) {\n        return;\n      }\n    }\n\n    // if for a given set of events we are preventing default, do that\n    if (eventSelector.preventDefault) {\n      event.preventDefault();\n    }\n\n    // if an action handler passed in, use that\n    if (eventSelector.action) {\n      eventSelector.action(node, event);\n    }\n\n    // get the node key for a given node\n    const nodeKey = getNodeKeyForPreboot({ root: root, node: node });\n\n    // record active node\n    if (CARET_EVENTS.indexOf(eventName) >= 0) {\n      // if it's an caret node, get the selection for the active node\n      const isCaretNode = CARET_NODES.indexOf(node.tagName ? node.tagName : '') >= 0;\n\n      prebootData.activeNode = {\n        root: root,\n        node: node,\n        nodeKey: nodeKey,\n        selection: isCaretNode ? getSelection(node as HTMLInputElement) : undefined,\n      };\n    } else if (eventName !== 'change' && eventName !== 'focusout') {\n      prebootData.activeNode = undefined;\n    }\n\n    // if overlay is not disabled and we are freezing the UI\n    if (opts && !opts.disableOverlay && eventSelector.freeze) {\n      const overlay = root.overlay as HTMLElement;\n\n      // show the overlay\n      overlay.style.display = 'block';\n      overlay.classList.add('is-loading');\n\n      // hide the overlay after 10 seconds just in case preboot.complete() never\n      // called\n\n      setTimeout(() => {\n        overlay.style.display = 'none';\n      }, 10000);\n    }\n\n    // we will record events for later replay unless explicitly marked as\n    // doNotReplay\n    if (eventSelector.replay) {\n      appData.events.push({\n        node,\n        nodeKey,\n        event,\n        name: eventName,\n      });\n    }\n  };\n}\n\n/**\n * Get the selection data that is later used to set the cursor after client view\n * is active\n */\nexport function getSelection(node: HTMLInputElement): PrebootSelection {\n  node = node || ({} as HTMLInputElement);\n\n  const nodeValue = node.value || '';\n  const selection: PrebootSelection = {\n    start: nodeValue.length,\n    end: nodeValue.length,\n    direction: 'forward',\n  };\n\n  // if browser support selectionStart on node (Chrome, FireFox, IE9+)\n  try {\n    if (node.selectionStart || node.selectionStart === 0) {\n      selection.start = node.selectionStart;\n      selection.end = node.selectionEnd ? node.selectionEnd : 0;\n      selection.direction = node.selectionDirection ? (node.selectionDirection as PrebootSelectionDirection) : 'none';\n    }\n  } catch (ex) {}\n\n  return selection;\n}\n\n/**\n * Create buffer for a given node\n *\n * @param root All the data related to a particular app\n * @returns Returns the root client node.\n */\nexport function createBuffer(root: ServerClientRoot): HTMLElement {\n  const serverNode = root.serverNode;\n\n  // if no rootServerNode OR the selector is on the entire html doc or the body\n  // OR no parentNode, don't buffer\n  if (!serverNode || !serverNode.parentNode || serverNode === document.documentElement || serverNode === document.body) {\n    return serverNode as HTMLElement;\n  }\n\n  // create shallow clone of server root\n  const rootClientNode = serverNode.cloneNode(false) as HTMLElement;\n  // we want the client to write to a hidden div until the time for switching\n  // the buffers\n  rootClientNode.style.display = 'none';\n\n  // insert the client node before the server and return it\n  serverNode.parentNode.insertBefore(rootClientNode, serverNode);\n\n  // mark server node as not to be touched by AngularJS - needed for ngUpgrade\n  serverNode.setAttribute('ng-non-bindable', '');\n\n  // return the rootClientNode\n  return rootClientNode;\n}\n"]}