preboot/esm2015/api/event.recorder.js

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';
            // 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 = _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 =>\n    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;' +\n    '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(\n  _document: Document,\n  opts: PrebootOptions,\n  serverNode: HTMLElement\n): 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,\n                             prebootData: PrebootData,\n                             appData: PrebootAppData,\n                             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 ||\n    (_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\n      // hide the overlay after 10 seconds just in case preboot.complete() never\n      // called\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 ?\n        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 ||\n    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"]}