preboot/esm2015/api/inline.preboot.code.js

import { getNodeKeyForPreboot } from '../common/get-node-key';
import { initAll, start, createOverlay, getAppRoot, handleEvents, createListenHandler, getSelection, createBuffer } from './event.recorder';
const eventRecorder = {
    start,
    createOverlay,
    getAppRoot,
    handleEvents,
    createListenHandler,
    getSelection,
    createBuffer
};
export const initFunctionName = 'prebootInitFn';
// exporting default options in case developer wants to use these + custom on
// top
export const defaultOptions = {
    buffer: true,
    replay: true,
    disableOverlay: false,
    // these are the default events are are listening for an transferring from
    // server view to client view
    eventSelectors: [
        // for recording changes in form elements
        {
            selector: 'input,textarea',
            events: ['keypress', 'keyup', 'keydown', 'input', 'change']
        },
        { selector: 'select,option', events: ['change'] },
        // when user hits return button in an input box
        {
            selector: 'input',
            events: ['keyup'],
            preventDefault: true,
            keyCodes: [13],
            freeze: true
        },
        // when user submit form (press enter, click on button/input[type="submit"])
        {
            selector: 'form',
            events: ['submit'],
            preventDefault: true,
            freeze: true
        },
        // for tracking focus (no need to replay)
        {
            selector: 'input,textarea',
            events: ['focusin', 'focusout', 'mousedown', 'mouseup'],
            replay: false
        },
        // user clicks on a button
        {
            selector: 'button',
            events: ['click'],
            preventDefault: true,
            freeze: true
        }
    ]
};
/**
 * Get the event recorder code based on all functions in event.recorder.ts
 * and the getNodeKeyForPreboot function.
 */
export function getEventRecorderCode() {
    const eventRecorderFunctions = [];
    for (const funcName in eventRecorder) {
        if (eventRecorder.hasOwnProperty(funcName)) {
            const fn = eventRecorder[funcName].toString();
            const fnCleaned = fn.replace('common_1.', '');
            eventRecorderFunctions.push(fnCleaned);
        }
    }
    // this is common function used to get the node key
    eventRecorderFunctions.push(getNodeKeyForPreboot.toString());
    // add new line characters for readability
    return '\n\n' + eventRecorderFunctions.join('\n\n') + '\n\n';
}
/**
 * Used by the server side version of preboot. The main purpose is to get the
 * inline code that can be inserted into the server view.
 * Returns the definitions of the prebootInit function called in code returned by
 * getInlineInvocation for each server node separately.
 *
 * @param customOptions PrebootRecordOptions that override the defaults
 * @returns Generated inline preboot code with just functions definitions
 * to be used separately
 */
export function getInlineDefinition(customOptions) {
    const opts = assign({}, defaultOptions, customOptions);
    // safety check to make sure options passed in are valid
    validateOptions(opts);
    const scriptCode = getEventRecorderCode();
    const optsStr = stringifyWithFunctions(opts);
    // wrap inline preboot code with a self executing function in order to create scope
    const initAllStr = initAll.toString();
    return `var ${initFunctionName} = (function() {
      ${scriptCode}
      return (${initAllStr.replace('common_1.', '')})(${optsStr});
    })();`;
}
/**
 * Used by the server side version of preboot. The main purpose is to get the
 * inline code that can be inserted into the server view.
 * Invokes the prebootInit function defined in getInlineDefinition with proper
 * parameters. Each appRoot should get a separate inlined code from a separate
 * call to getInlineInvocation but only one inlined code from getInlineDefinition.
 *
 * @returns Generated inline preboot code with just invocations of functions from
 * getInlineDefinition
 */
export function getInlineInvocation() {
    return `${initFunctionName}();`;
}
/**
 * Throw an error if issues with any options
 * @param opts
 */
export function validateOptions(opts) {
    if (!opts.appRoot || !opts.appRoot.length) {
        throw new Error('The appRoot is missing from preboot options. ' +
            'This is needed to find the root of your application. ' +
            'Set this value in the preboot options to be a selector for the root element of your app.');
    }
}
/**
 * Object.assign() is not fully supporting in TypeScript, so
 * this is just a simple implementation of it
 *
 * @param target The target object
 * @param optionSets Any number of addition objects that are added on top of the
 * target
 * @returns A new object that contains all the merged values
 */
export function assign(target, ...optionSets) {
    if (target === undefined || target === null) {
        throw new TypeError('Cannot convert undefined or null to object');
    }
    const output = Object(target);
    for (let index = 0; index < optionSets.length; index++) {
        const source = optionSets[index];
        if (source !== undefined && source !== null) {
            for (const nextKey in source) {
                if (source.hasOwnProperty && source.hasOwnProperty(nextKey)) {
                    output[nextKey] = source[nextKey];
                }
            }
        }
    }
    return output;
}
/**
 * Stringify an object and include functions. This is needed since we are
 * letting users pass in options that include custom functions for things like
 * the freeze handler or action when an event occurs
 *
 * @param obj This is the object you want to stringify that includes some
 * functions
 * @returns The stringified version of an object
 */
export function stringifyWithFunctions(obj) {
    const FUNC_START = 'START_FUNCTION_HERE';
    const FUNC_STOP = 'STOP_FUNCTION_HERE';
    // first stringify except mark off functions with markers
    let str = JSON.stringify(obj, function (_key, value) {
        // if the value is a function, we want to wrap it with markers
        if (!!(value && value.constructor && value.call && value.apply)) {
            return FUNC_START + value.toString() + FUNC_STOP;
        }
        else {
            return value;
        }
    });
    // now we use the markers to replace function strings with actual functions
    let startFuncIdx = str.indexOf(FUNC_START);
    let stopFuncIdx;
    let fn;
    while (startFuncIdx >= 0) {
        stopFuncIdx = str.indexOf(FUNC_STOP);
        // pull string out
        fn = str.substring(startFuncIdx + FUNC_START.length, stopFuncIdx);
        fn = fn.replace(/\\n/g, '\n');
        str = str.substring(0, startFuncIdx - 1) + fn +
            str.substring(stopFuncIdx + FUNC_STOP.length + 1);
        startFuncIdx = str.indexOf(FUNC_START);
    }
    return str;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inline.preboot.code.js","sourceRoot":"../../src/lib/","sources":["api/inline.preboot.code.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 {PrebootOptions} from '../common/preboot.interfaces';\nimport {getNodeKeyForPreboot} from '../common/get-node-key';\n\nimport {\n  initAll,\n  start,\n  createOverlay,\n  getAppRoot,\n  handleEvents,\n  createListenHandler,\n  getSelection,\n  createBuffer\n} from './event.recorder';\n\nconst eventRecorder = {\n  start,\n  createOverlay,\n  getAppRoot,\n  handleEvents,\n  createListenHandler,\n  getSelection,\n  createBuffer\n};\n\nexport const initFunctionName = 'prebootInitFn';\n\n// exporting default options in case developer wants to use these + custom on\n// top\nexport const defaultOptions = <PrebootOptions>{\n  buffer: true,\n  replay: true,\n  disableOverlay: false,\n\n  // these are the default events are are listening for an transferring from\n  // server view to client view\n  eventSelectors: [\n    // for recording changes in form elements\n    {\n      selector: 'input,textarea',\n      events: ['keypress', 'keyup', 'keydown', 'input', 'change']\n    },\n    { selector: 'select,option', events: ['change'] },\n\n    // when user hits return button in an input box\n    {\n      selector: 'input',\n      events: ['keyup'],\n      preventDefault: true,\n      keyCodes: [13],\n      freeze: true\n    },\n\n    // when user submit form (press enter, click on button/input[type=\"submit\"])\n    {\n      selector: 'form',\n      events: ['submit'],\n      preventDefault: true,\n      freeze: true\n    },\n\n    // for tracking focus (no need to replay)\n    {\n      selector: 'input,textarea',\n      events: ['focusin', 'focusout', 'mousedown', 'mouseup'],\n      replay: false\n    },\n\n    // user clicks on a button\n    {\n      selector: 'button',\n      events: ['click'],\n      preventDefault: true,\n      freeze: true\n    }\n  ]\n};\n\n/**\n * Get the event recorder code based on all functions in event.recorder.ts\n * and the getNodeKeyForPreboot function.\n */\nexport function getEventRecorderCode(): string {\n  const eventRecorderFunctions: string[] = [];\n\n  for (const funcName in eventRecorder) {\n    if (eventRecorder.hasOwnProperty(funcName)) {\n      const fn = (<any>eventRecorder)[funcName].toString();\n      const fnCleaned = fn.replace('common_1.', '');\n      eventRecorderFunctions.push(fnCleaned);\n    }\n  }\n\n  // this is common function used to get the node key\n  eventRecorderFunctions.push(getNodeKeyForPreboot.toString());\n\n  // add new line characters for readability\n  return '\\n\\n' + eventRecorderFunctions.join('\\n\\n') + '\\n\\n';\n}\n\n/**\n * Used by the server side version of preboot. The main purpose is to get the\n * inline code that can be inserted into the server view.\n * Returns the definitions of the prebootInit function called in code returned by\n * getInlineInvocation for each server node separately.\n *\n * @param customOptions PrebootRecordOptions that override the defaults\n * @returns Generated inline preboot code with just functions definitions\n * to be used separately\n */\nexport function getInlineDefinition(customOptions?: PrebootOptions): string {\n  const opts = <PrebootOptions>assign({}, defaultOptions, customOptions);\n\n  // safety check to make sure options passed in are valid\n  validateOptions(opts);\n\n  const scriptCode = getEventRecorderCode();\n  const optsStr = stringifyWithFunctions(opts);\n\n  // wrap inline preboot code with a self executing function in order to create scope\n  const initAllStr = initAll.toString();\n  return `var ${initFunctionName} = (function() {\n      ${scriptCode}\n      return (${initAllStr.replace('common_1.', '')})(${optsStr});\n    })();`;\n}\n\n\n/**\n * Used by the server side version of preboot. The main purpose is to get the\n * inline code that can be inserted into the server view.\n * Invokes the prebootInit function defined in getInlineDefinition with proper\n * parameters. Each appRoot should get a separate inlined code from a separate\n * call to getInlineInvocation but only one inlined code from getInlineDefinition.\n *\n * @returns Generated inline preboot code with just invocations of functions from\n * getInlineDefinition\n */\nexport function getInlineInvocation(): string {\n  return `${initFunctionName}();`;\n}\n\n/**\n * Throw an error if issues with any options\n * @param opts\n */\nexport function validateOptions(opts: PrebootOptions) {\n  if (!opts.appRoot || !opts.appRoot.length) {\n    throw new Error(\n      'The appRoot is missing from preboot options. ' +\n        'This is needed to find the root of your application. ' +\n        'Set this value in the preboot options to be a selector for the root element of your app.'\n    );\n  }\n}\n\n/**\n * Object.assign() is not fully supporting in TypeScript, so\n * this is just a simple implementation of it\n *\n * @param target The target object\n * @param optionSets Any number of addition objects that are added on top of the\n * target\n * @returns A new object that contains all the merged values\n */\nexport function assign(target: Object, ...optionSets: any[]): Object {\n  if (target === undefined || target === null) {\n    throw new TypeError('Cannot convert undefined or null to object');\n  }\n\n  const output = Object(target);\n  for (let index = 0; index < optionSets.length; index++) {\n    const source = optionSets[index];\n    if (source !== undefined && source !== null) {\n      for (const nextKey in source) {\n        if (source.hasOwnProperty && source.hasOwnProperty(nextKey)) {\n          output[nextKey] = source[nextKey];\n        }\n      }\n    }\n  }\n\n  return output;\n}\n\n/**\n * Stringify an object and include functions. This is needed since we are\n * letting users pass in options that include custom functions for things like\n * the freeze handler or action when an event occurs\n *\n * @param obj This is the object you want to stringify that includes some\n * functions\n * @returns The stringified version of an object\n */\nexport function stringifyWithFunctions(obj: Object): string {\n  const FUNC_START = 'START_FUNCTION_HERE';\n  const FUNC_STOP = 'STOP_FUNCTION_HERE';\n\n  // first stringify except mark off functions with markers\n  let str = JSON.stringify(obj, function(_key, value) {\n    // if the value is a function, we want to wrap it with markers\n    if (!!(value && value.constructor && value.call && value.apply)) {\n      return FUNC_START + value.toString() + FUNC_STOP;\n    } else {\n      return value;\n    }\n  });\n\n  // now we use the markers to replace function strings with actual functions\n  let startFuncIdx = str.indexOf(FUNC_START);\n  let stopFuncIdx: number;\n  let fn: string;\n  while (startFuncIdx >= 0) {\n    stopFuncIdx = str.indexOf(FUNC_STOP);\n\n    // pull string out\n    fn = str.substring(startFuncIdx + FUNC_START.length, stopFuncIdx);\n    fn = fn.replace(/\\\\n/g, '\\n');\n\n    str = str.substring(0, startFuncIdx - 1) + fn +\n      str.substring(stopFuncIdx + FUNC_STOP.length + 1);\n    startFuncIdx = str.indexOf(FUNC_START);\n  }\n\n  return str;\n}\n"]}