preboot

Variables

• defaultOptions
• initFunctionName
• ɵa
• ɵc
• PREBOOT_NONCE

Functions

• assign()
• createBuffer()
• createListenHandler()
• createOverlay()
• getAppRoot()
• getEventRecorderCode()
• getInlineDefinition()
• getInlineInvocation()
• getNodeKeyForPreboot()
• getSelection()
• handleEvents()
• initAll()
• ɵb()
• start()
• stringifyWithFunctions()
• validateOptions()

Classes

• EventReplayer

  • cleanup()
  • clientNodeCache
  • findClientNode()
  • getWindow()
  • replayAll()
  • replayEvent()
  • replayForApp()
  • replayStarted
  • setFocus()
  • setWindow()
  • switchBuffer()
  • win
• PrebootModule

  • withConfig()

Interfaces

• DomEvent

  • preventDefault()
  • target
  • type
  • which
• EventSelector

  • action
  • events
  • freeze
  • keyCodes
  • preventDefault
  • replay
  • selector
• NodeContext

  • node
  • nodeKey
  • root
  • selection
• PrebootAppData

  • events
  • root
• PrebootData

  • activeNode
  • apps
  • listeners
  • opts
• PrebootEvent

  • event
  • name
  • node
  • nodeKey
• PrebootEventListener

  • eventName
  • handler
  • node
• PrebootOptions

  • appRoot
  • buffer
  • disableOverlay
  • eventSelectors
  • replay
• PrebootSelection

  • direction
  • end
  • start
• PrebootWindow

  • document
  • getComputedStyle
  • prebootData
• ServerClientRoot

  • clientNode
  • overlay
  • serverNode

Type Aliases

• PrebootSelectionDirection

variable defaultOptions

const defaultOptions: PrebootOptions;

variable initFunctionName

const initFunctionName: string;

variable ɵa

const ɵa: InjectionToken<PrebootOptions>;

variable ɵc

const ɵc: {
    provide: InjectionToken<() => void>;
    useFactory: typeof PREBOOT_FACTORY;
    deps: (
        | typeof EventReplayer
        | InjectionToken<PrebootOptions>
        | Optional[]
        | typeof ApplicationRef
    )[];
    multi: boolean;
};

variable PREBOOT_NONCE

const PREBOOT_NONCE: InjectionToken<string>;

function assign

assign: (target: Object, ...optionSets: any[]) => Object;

• Object.assign() is not fully supporting in TypeScript, so this is just a simple implementation of it

  Parameter target

  The target object

  Parameter optionSets

  Any number of addition objects that are added on top of the target

  Returns

  A new object that contains all the merged values

function createBuffer

createBuffer: (root: ServerClientRoot) => HTMLElement;

• Create buffer for a given node

  Parameter root

  All the data related to a particular app

  Returns

  Returns the root client node.

function createListenHandler

createListenHandler: (
    _document: Document,
    prebootData: PrebootData,
    eventSelector: EventSelector,
    appData: PrebootAppData
) => EventListener;

• Create handler for events that we will record

function createOverlay

createOverlay: (_document: Document) => HTMLElement | undefined;

• Create an overlay div and add it to the DOM so it can be used if a freeze event occurs

  Parameter _document

  The global document object (passed in for testing purposes)

  Returns

  Element The overlay node is returned

function getAppRoot

getAppRoot: (
    _document: Document,
    opts: PrebootOptions,
    serverNode: HTMLElement
) => ServerClientRoot;

• 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)

  Parameter _document

  The global document object used to attach the overlay

  Parameter opts

  Options passed in by the user to init()

  Parameter serverNode

  The server node serving as application root

  Returns

  ServerClientRoot An array of root info for the current app

function getEventRecorderCode

getEventRecorderCode: () => string;

• Get the event recorder code based on all functions in event.recorder.ts and the getNodeKeyForPreboot function.

function getInlineDefinition

getInlineDefinition: (customOptions?: PrebootOptions) => string;

• 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.

  Parameter customOptions

  PrebootRecordOptions that override the defaults

  Returns

  Generated inline preboot code with just functions definitions to be used separately

function getInlineInvocation

getInlineInvocation: () => string;

• 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

function getNodeKeyForPreboot

getNodeKeyForPreboot: (nodeContext: NodeContext) => string;

• Attempt to generate key from node position in the DOM

function getSelection

getSelection: (node: HTMLInputElement) => PrebootSelection;

• Get the selection data that is later used to set the cursor after client view is active

function handleEvents

handleEvents: (
    _document: Document,
    prebootData: PrebootData,
    appData: PrebootAppData,
    eventSelector: EventSelector
) => void;

• Under given server root, for given selector, record events

  Parameter _document

  Parameter prebootData

  Parameter appData

  Parameter eventSelector

function initAll

initAll: (opts: PrebootOptions, win?: PrebootWindow) => () => void;

• Called right away to initialize preboot

  Parameter opts

  All the preboot options

  Parameter win

function ɵb

ɵb: (
    doc: Document,
    prebootOpts: PrebootOptions,
    nonce: string | null,
    platformId: Object,
    appRef: ApplicationRef,
    eventReplayer: EventReplayer
) => () => void;

function start

start: (prebootData: PrebootData, win?: PrebootWindow) => void;

• 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.

  Parameter prebootData

  Global preboot data object that contains options and will have events

  Parameter win

  Optional param to pass in mock window for testing purposes

function stringifyWithFunctions

stringifyWithFunctions: (obj: Object) => string;

• 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

  Parameter obj

  This is the object you want to stringify that includes some functions

  Returns

  The stringified version of an object

function validateOptions

validateOptions: (opts: PrebootOptions) => void;

• Throw an error if issues with any options

  Parameter opts

type PrebootSelectionDirection

type PrebootSelectionDirection = 'forward' | 'backward' | 'none';