preboot
Version:
Record server view events and play back to Angular client view
186 lines • 22.1 kB
JavaScript
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"]}