angular2-platform-node

  • Version 2.1.0-rc.1
  • Published
  • 3 dependencies
  • MIT license

Install

npm i angular2-platform-node
yarn add angular2-platform-node
pnpm add angular2-platform-node

Overview

Universal (isomorphic) javascript support for Angular2

Index

Variables

Functions

Classes

Interfaces

Variables

variable ATTRIBUTES

const ATTRIBUTES: {
textarea: string[];
script: string[];
button: string[];
fieldset: string[];
a: string[];
img: string[];
input: string[];
output: string[];
progress: string[];
label: string[];
option: string[];
select: string[];
optgroup: string[];
form: string[];
};

    variable COMPONENT_VARIABLE

    const COMPONENT_VARIABLE: string;

      variable CONTENT_ATTR

      const CONTENT_ATTR: string;
        const COOKIE_KEY: any;

          variable HOST_ATTR

          const HOST_ATTR: string;

            variable IGNORE_ATTRIBUTES

            const IGNORE_ATTRIBUTES: { innerHTML: boolean; hidden: boolean };

              variable INTERNAL_NODE_PLATFORM_PROVIDERS

              const INTERNAL_NODE_PLATFORM_PROVIDERS: any[];

                variable NODE_APP_ID

                const NODE_APP_ID: any;

                  variable NODE_HTTP_PROVIDERS

                  const NODE_HTTP_PROVIDERS: any[];

                    variable NODE_HTTP_PROVIDERS_COMMON

                    const NODE_HTTP_PROVIDERS_COMMON: any[];

                      variable NODE_JSONP_PROVIDERS

                      const NODE_JSONP_PROVIDERS: any[];

                        variable NODE_LOCATION_PROVIDERS

                        const NODE_LOCATION_PROVIDERS: any[];

                          variable ORIGIN_URL

                          const ORIGIN_URL: any;

                            variable PRIME_CACHE

                            const PRIME_CACHE: any;

                              variable REQUEST_URL

                              const REQUEST_URL: any;

                                Functions

                                function arrayFlattenTree

                                arrayFlattenTree: (children: any[], arr: any[]) => any[];

                                  function camelCaseToDashCase

                                  camelCaseToDashCase: (input: string) => string;

                                    function createUrlProviders

                                    createUrlProviders: (
                                    config: any
                                    ) => { provide: OpaqueToken; useValue: string }[];

                                      function cssHyphenate

                                      cssHyphenate: (propertyName: string) => string;

                                        function dashCaseToCamelCase

                                        dashCaseToCamelCase: (input: string) => string;

                                          function getDOM

                                          getDOM: () => any;

                                            function getPlatformRef

                                            getPlatformRef: () => any;

                                              function getUrlConfig

                                              getUrlConfig: () => { provide: OpaqueToken; useValue: string }[];

                                                function httpFactory

                                                httpFactory: (xhrBackend: any, requestOptions: any) => PreloadHttp;

                                                  function isBlank

                                                  isBlank: (obj: any) => boolean;

                                                    function isPresent

                                                    isPresent: (obj: any) => boolean;

                                                      function isString

                                                      isString: (str: any) => boolean;

                                                        function isSuccess

                                                        isSuccess: (status: number) => boolean;

                                                          function isTag

                                                          isTag: (tagName: any, node: any) => boolean;

                                                            function joinWithSlash

                                                            joinWithSlash: (start: string, end: string) => string;

                                                              function jsonpFactory

                                                              jsonpFactory: (jsonpBackend: any, requestOptions: any) => PreloadHttp;

                                                                function listContains

                                                                listContains: (list: any[], el: any) => boolean;

                                                                  function parseDocument

                                                                  parseDocument: (documentHtml: string) => any;

                                                                    function parseFragment

                                                                    parseFragment: (el: string) => any;

                                                                      function platformNodeDynamic

                                                                      platformNodeDynamic: (extraProviders?: any[], platform?: any) => NodePlatform;

                                                                        function regExFirstMatch

                                                                        regExFirstMatch: (regExp: RegExp, input: string) => RegExpExecArray;

                                                                          function removePlatformRef

                                                                          removePlatformRef: () => void;

                                                                            function serializeDocument

                                                                            serializeDocument: (document: Object, pretty?: boolean) => string;

                                                                              function setPlatformRef

                                                                              setPlatformRef: (platformRef: any) => void;

                                                                                function setValueOnPath

                                                                                setValueOnPath: (context: any, path: string, value: any) => void;

                                                                                  function stringify

                                                                                  stringify: (token: any) => string;

                                                                                    function stringMapForEach

                                                                                    stringMapForEach: (
                                                                                    map: { [key: string]: any },
                                                                                    callback: (V: any, K: any) => void
                                                                                    ) => void;

                                                                                      Classes

                                                                                      class DomRenderer

                                                                                      class DomRenderer implements Renderer {}

                                                                                        constructor

                                                                                        constructor(
                                                                                        _rootRenderer: NodeDomRootRenderer,
                                                                                        componentProto: any,
                                                                                        _animationDriver: any
                                                                                        );

                                                                                          method animate

                                                                                          animate: (
                                                                                          element: any,
                                                                                          startingStyles: any,
                                                                                          keyframes: any[],
                                                                                          duration: number,
                                                                                          delay: number,
                                                                                          easing: string
                                                                                          ) => any;

                                                                                            method attachViewAfter

                                                                                            attachViewAfter: (node: any, viewRootNodes: any[]) => void;

                                                                                              method createElement

                                                                                              createElement: (parent: any, name: string, _debugInfo: any) => any;

                                                                                                method createTemplateAnchor

                                                                                                createTemplateAnchor: (parentElement: any, _debugInfo: any) => any;

                                                                                                  method createText

                                                                                                  createText: (parentElement: any, value: string, _debugInfo: any) => any;

                                                                                                    method createViewRoot

                                                                                                    createViewRoot: (hostElement: any) => any;

                                                                                                      method destroyView

                                                                                                      destroyView: (hostElement: any, _viewAllNodes: any[]) => void;

                                                                                                        method detachView

                                                                                                        detachView: (viewRootNodes: any[]) => void;

                                                                                                          method invokeElementMethod

                                                                                                          invokeElementMethod: (
                                                                                                          renderElement: any,
                                                                                                          methodName: string,
                                                                                                          args: any[]
                                                                                                          ) => void;

                                                                                                            method listen

                                                                                                            listen: (renderElement: any, name: string, callback: Function) => Function;

                                                                                                              method listenGlobal

                                                                                                              listenGlobal: (target: string, name: string, callback: Function) => Function;

                                                                                                                method projectNodes

                                                                                                                projectNodes: (parentElement: any, nodes: any[]) => void;

                                                                                                                  method selectRootElement

                                                                                                                  selectRootElement: (_selectorOrNode: string | any, _debugInfo: any) => any;

                                                                                                                    method setBindingDebugInfo

                                                                                                                    setBindingDebugInfo: (
                                                                                                                    renderElement: any,
                                                                                                                    propertyName: string,
                                                                                                                    propertyValue: string
                                                                                                                    ) => void;

                                                                                                                      method setElementAttribute

                                                                                                                      setElementAttribute: (
                                                                                                                      renderElement: any,
                                                                                                                      attributeName: string,
                                                                                                                      attributeValue: string
                                                                                                                      ) => void;

                                                                                                                        method setElementClass

                                                                                                                        setElementClass: (renderElement: any, className: string, isAdd: boolean) => void;

                                                                                                                          method setElementProperty

                                                                                                                          setElementProperty: (
                                                                                                                          renderElement: any,
                                                                                                                          propertyName: string,
                                                                                                                          propertyValue: any
                                                                                                                          ) => void;

                                                                                                                            method setElementStyle

                                                                                                                            setElementStyle: (
                                                                                                                            renderElement: any,
                                                                                                                            styleName: string,
                                                                                                                            styleValue: string
                                                                                                                            ) => void;

                                                                                                                              method setText

                                                                                                                              setText: (renderNode: any, text: string) => void;

                                                                                                                                class ListWrapper

                                                                                                                                class ListWrapper {}

                                                                                                                                  method contains

                                                                                                                                  static contains: <T>(list: T[], el: T) => boolean;

                                                                                                                                    method remove

                                                                                                                                    static remove: <T>(list: T[], el: T) => boolean;

                                                                                                                                      class MockTestabilityRegistry

                                                                                                                                      class MockTestabilityRegistry extends TestabilityRegistry {}

                                                                                                                                        method registerApplication

                                                                                                                                        registerApplication: () => any;

                                                                                                                                          class NodeBackend

                                                                                                                                          class NodeBackend extends XHRBackend {}

                                                                                                                                            constructor

                                                                                                                                            constructor(
                                                                                                                                            baseResponseOptions: any,
                                                                                                                                            _browserXHR: any,
                                                                                                                                            _xsrfStrategy: any,
                                                                                                                                            _ngZone: any,
                                                                                                                                            _baseUrl: string,
                                                                                                                                            _originUrl: string
                                                                                                                                            );

                                                                                                                                              method createConnection

                                                                                                                                              createConnection: (request: any) => NodeConnection;

                                                                                                                                                class NodeConnection

                                                                                                                                                class NodeConnection implements XHRConnection {}

                                                                                                                                                  constructor

                                                                                                                                                  constructor(
                                                                                                                                                  req: any,
                                                                                                                                                  baseResponseOptions: any,
                                                                                                                                                  originUrl?: string,
                                                                                                                                                  baseUrl?: string
                                                                                                                                                  );

                                                                                                                                                    property readyState

                                                                                                                                                    readyState: any;

                                                                                                                                                      property request

                                                                                                                                                      request: any;

                                                                                                                                                        property response

                                                                                                                                                        response: any;

                                                                                                                                                          property setDetectedContentType

                                                                                                                                                          setDetectedContentType: (req: any, _xhr: any) => void;

                                                                                                                                                            class NodeDomEventsPlugin

                                                                                                                                                            class NodeDomEventsPlugin {}

                                                                                                                                                              property manager

                                                                                                                                                              manager: NodeEventManager;

                                                                                                                                                                method addEventListener

                                                                                                                                                                addEventListener: (
                                                                                                                                                                element: any,
                                                                                                                                                                eventName: string,
                                                                                                                                                                handler: Function
                                                                                                                                                                ) => Function;

                                                                                                                                                                  method addGlobalEventListener

                                                                                                                                                                  addGlobalEventListener: (
                                                                                                                                                                  target: string,
                                                                                                                                                                  eventName: string,
                                                                                                                                                                  handler: Function
                                                                                                                                                                  ) => Function;

                                                                                                                                                                    method supports

                                                                                                                                                                    supports: (_eventName: string) => boolean;

                                                                                                                                                                      class NodeDomRenderer

                                                                                                                                                                      class NodeDomRenderer extends DomRenderer {}

                                                                                                                                                                        constructor

                                                                                                                                                                        constructor(
                                                                                                                                                                        _rootRenderer: NodeDomRootRenderer,
                                                                                                                                                                        _componentProto: any,
                                                                                                                                                                        _animationDriver: any
                                                                                                                                                                        );

                                                                                                                                                                          method invokeElementMethod

                                                                                                                                                                          invokeElementMethod: (
                                                                                                                                                                          renderElement: any,
                                                                                                                                                                          methodName: string,
                                                                                                                                                                          args: any[]
                                                                                                                                                                          ) => void;

                                                                                                                                                                            method selectRootElement

                                                                                                                                                                            selectRootElement: (selectorOrNode: string | any, _debugInfo: any) => any;

                                                                                                                                                                              method setElementProperty

                                                                                                                                                                              setElementProperty: (
                                                                                                                                                                              renderElement: any,
                                                                                                                                                                              propertyName: string,
                                                                                                                                                                              propertyValue: any
                                                                                                                                                                              ) => void;

                                                                                                                                                                                method setElementStyle

                                                                                                                                                                                setElementStyle: (
                                                                                                                                                                                renderElement: any,
                                                                                                                                                                                styleName: string,
                                                                                                                                                                                styleValue: string
                                                                                                                                                                                ) => void;

                                                                                                                                                                                  class NodeDomRootRenderer

                                                                                                                                                                                  class NodeDomRootRenderer implements RootRenderer {}

                                                                                                                                                                                    constructor

                                                                                                                                                                                    constructor(
                                                                                                                                                                                    document: any,
                                                                                                                                                                                    eventManager: any,
                                                                                                                                                                                    sharedStylesHost: NodeSharedStylesHost,
                                                                                                                                                                                    _animationDriver: any
                                                                                                                                                                                    );

                                                                                                                                                                                      property document

                                                                                                                                                                                      document: any;

                                                                                                                                                                                        property eventManager

                                                                                                                                                                                        eventManager: any;

                                                                                                                                                                                          property registeredComponents

                                                                                                                                                                                          protected registeredComponents: Map<string, DomRenderer>;

                                                                                                                                                                                            property sharedStylesHost

                                                                                                                                                                                            sharedStylesHost: NodeSharedStylesHost;

                                                                                                                                                                                              method renderComponent

                                                                                                                                                                                              renderComponent: (componentProto: any) => any;

                                                                                                                                                                                                class NodeEventManager

                                                                                                                                                                                                class NodeEventManager {}

                                                                                                                                                                                                  constructor

                                                                                                                                                                                                  constructor(plugins: EventManagerPlugin[], _document: any, _zone: any);

                                                                                                                                                                                                    method addEventListener

                                                                                                                                                                                                    addEventListener: (
                                                                                                                                                                                                    element: any,
                                                                                                                                                                                                    eventName: string,
                                                                                                                                                                                                    handler: Function
                                                                                                                                                                                                    ) => Function;

                                                                                                                                                                                                      method addGlobalEventListener

                                                                                                                                                                                                      addGlobalEventListener: (
                                                                                                                                                                                                      target: string,
                                                                                                                                                                                                      eventName: string,
                                                                                                                                                                                                      handler: Function
                                                                                                                                                                                                      ) => Function;

                                                                                                                                                                                                        method getDocument

                                                                                                                                                                                                        getDocument: () => any;

                                                                                                                                                                                                          method getWindow

                                                                                                                                                                                                          getWindow: () => any;

                                                                                                                                                                                                            method getZone

                                                                                                                                                                                                            getZone: () => any;

                                                                                                                                                                                                              class NodeHttpModule

                                                                                                                                                                                                              class NodeHttpModule {}

                                                                                                                                                                                                                method forRoot

                                                                                                                                                                                                                static forRoot: (
                                                                                                                                                                                                                config?: any
                                                                                                                                                                                                                ) => { ngModule: typeof NodeHttpModule; providers: any[] };

                                                                                                                                                                                                                  method withConfig

                                                                                                                                                                                                                  static withConfig: (
                                                                                                                                                                                                                  config?: any
                                                                                                                                                                                                                  ) => { ngModule: typeof NodeHttpModule; providers: any[] };

                                                                                                                                                                                                                    class NodeJsonpBackend

                                                                                                                                                                                                                    abstract class NodeJsonpBackend extends ConnectionBackend {}

                                                                                                                                                                                                                      class NodeJsonpBackend_

                                                                                                                                                                                                                      class NodeJsonpBackend_ extends NodeJsonpBackend {}

                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                        _baseResponseOptions: any,
                                                                                                                                                                                                                        _ngZone: any,
                                                                                                                                                                                                                        _baseUrl: string,
                                                                                                                                                                                                                        _originUrl: string
                                                                                                                                                                                                                        );

                                                                                                                                                                                                                          method createConnection

                                                                                                                                                                                                                          createConnection: (request: any) => NodeJSONPConnection;

                                                                                                                                                                                                                            class NodeJSONPConnection

                                                                                                                                                                                                                            class NodeJSONPConnection {}

                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                              req: any,
                                                                                                                                                                                                                              baseResponseOptions: any,
                                                                                                                                                                                                                              ngZone: any,
                                                                                                                                                                                                                              originUrl?: string,
                                                                                                                                                                                                                              baseUrl?: string
                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                property readyState

                                                                                                                                                                                                                                readyState: any;

                                                                                                                                                                                                                                  property request

                                                                                                                                                                                                                                  request: any;

                                                                                                                                                                                                                                    property response

                                                                                                                                                                                                                                    response: any;

                                                                                                                                                                                                                                      class NodeJsonpModule

                                                                                                                                                                                                                                      class NodeJsonpModule {}

                                                                                                                                                                                                                                        method forRoot

                                                                                                                                                                                                                                        static forRoot: (
                                                                                                                                                                                                                                        config?: any
                                                                                                                                                                                                                                        ) => { ngModule: typeof NodeJsonpModule; providers: any[] };

                                                                                                                                                                                                                                          method withConfig

                                                                                                                                                                                                                                          static withConfig: (
                                                                                                                                                                                                                                          config?: any
                                                                                                                                                                                                                                          ) => { ngModule: typeof NodeJsonpModule; providers: any[] };

                                                                                                                                                                                                                                            class NodeLocation

                                                                                                                                                                                                                                            class NodeLocation implements LocationConfig {}

                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                              constructor(config: NodeLocationConfig & LocationConfig);

                                                                                                                                                                                                                                                property hash

                                                                                                                                                                                                                                                hash: string;

                                                                                                                                                                                                                                                  property host

                                                                                                                                                                                                                                                  host: string;

                                                                                                                                                                                                                                                    property hostname

                                                                                                                                                                                                                                                    hostname: string;

                                                                                                                                                                                                                                                      property href

                                                                                                                                                                                                                                                      href: string;

                                                                                                                                                                                                                                                        property origin

                                                                                                                                                                                                                                                        readonly origin: string;

                                                                                                                                                                                                                                                          property pathname

                                                                                                                                                                                                                                                          pathname: string;

                                                                                                                                                                                                                                                            property port

                                                                                                                                                                                                                                                            port: string;

                                                                                                                                                                                                                                                              property protocol

                                                                                                                                                                                                                                                              protocol: string;

                                                                                                                                                                                                                                                                property search

                                                                                                                                                                                                                                                                search: string;

                                                                                                                                                                                                                                                                  method assign

                                                                                                                                                                                                                                                                  assign: (parsed: NodeLocationConfig) => this;

                                                                                                                                                                                                                                                                    method format

                                                                                                                                                                                                                                                                    format: (obj: NodeLocationConfig) => string;

                                                                                                                                                                                                                                                                      method parse

                                                                                                                                                                                                                                                                      parse: (url: string) => any;

                                                                                                                                                                                                                                                                        method toJSON

                                                                                                                                                                                                                                                                        toJSON: () => NodeLocationConfig;

                                                                                                                                                                                                                                                                          class NodeModule

                                                                                                                                                                                                                                                                          class NodeModule {}

                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                            constructor(parentModule: NodeModule);

                                                                                                                                                                                                                                                                              method forRoot

                                                                                                                                                                                                                                                                              static forRoot: (document: string, config?: any) => any;

                                                                                                                                                                                                                                                                                method withConfig

                                                                                                                                                                                                                                                                                static withConfig: (config?: any) => any;

                                                                                                                                                                                                                                                                                  class NodePlatform

                                                                                                                                                                                                                                                                                  class NodePlatform {}

                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                    constructor(_platformRef: any);

                                                                                                                                                                                                                                                                                      property destroyed

                                                                                                                                                                                                                                                                                      readonly destroyed: boolean;

                                                                                                                                                                                                                                                                                        property disposed

                                                                                                                                                                                                                                                                                        readonly disposed: boolean;

                                                                                                                                                                                                                                                                                          property injector

                                                                                                                                                                                                                                                                                          readonly injector: any;

                                                                                                                                                                                                                                                                                            property platformRef

                                                                                                                                                                                                                                                                                            readonly platformRef: any;

                                                                                                                                                                                                                                                                                              method bootstrapModule

                                                                                                                                                                                                                                                                                              bootstrapModule: <T>(
                                                                                                                                                                                                                                                                                              moduleType: any,
                                                                                                                                                                                                                                                                                              compilerOptions?: any
                                                                                                                                                                                                                                                                                              ) => Promise<NgModuleRef<T>>;

                                                                                                                                                                                                                                                                                                method bootstrapModuleFactory

                                                                                                                                                                                                                                                                                                bootstrapModuleFactory: <T>(moduleFactory: any) => Promise<NgModuleRef<T>>;

                                                                                                                                                                                                                                                                                                  method cacheModuleFactory

                                                                                                                                                                                                                                                                                                  cacheModuleFactory: <T>(
                                                                                                                                                                                                                                                                                                  moduleType: any,
                                                                                                                                                                                                                                                                                                  compilerOptions?: any
                                                                                                                                                                                                                                                                                                  ) => Promise<NgModuleRef<T>>;

                                                                                                                                                                                                                                                                                                    method destroy

                                                                                                                                                                                                                                                                                                    destroy: () => void;

                                                                                                                                                                                                                                                                                                      method dispose

                                                                                                                                                                                                                                                                                                      dispose: () => void;

                                                                                                                                                                                                                                                                                                        method onDestroy

                                                                                                                                                                                                                                                                                                        onDestroy: (callback: () => void) => void;

                                                                                                                                                                                                                                                                                                          method registerDisposeListener

                                                                                                                                                                                                                                                                                                          registerDisposeListener: (dispose: () => void) => void;

                                                                                                                                                                                                                                                                                                            method serialize

                                                                                                                                                                                                                                                                                                            serialize: <T>(moduleRef: any, config?: any) => Promise<T>;

                                                                                                                                                                                                                                                                                                              method serializeModule

                                                                                                                                                                                                                                                                                                              serializeModule: <T>(ModuleType: any, config?: any) => Promise<T>;

                                                                                                                                                                                                                                                                                                                method serializeModuleFactory

                                                                                                                                                                                                                                                                                                                serializeModuleFactory: <T>(ModuleType: any, config?: any) => Promise<T> | T;

                                                                                                                                                                                                                                                                                                                  class NodePlatformLocation

                                                                                                                                                                                                                                                                                                                  class NodePlatformLocation extends PlatformLocation {}

                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                    constructor(originUrl: string, requestUrl: string, baseUrl?: string);

                                                                                                                                                                                                                                                                                                                      property hash

                                                                                                                                                                                                                                                                                                                      readonly hash: string;

                                                                                                                                                                                                                                                                                                                        property pathname

                                                                                                                                                                                                                                                                                                                        pathname: string;

                                                                                                                                                                                                                                                                                                                          property search

                                                                                                                                                                                                                                                                                                                          readonly search: string;

                                                                                                                                                                                                                                                                                                                            method back

                                                                                                                                                                                                                                                                                                                            back: () => void;

                                                                                                                                                                                                                                                                                                                              method forward

                                                                                                                                                                                                                                                                                                                              forward: () => void;

                                                                                                                                                                                                                                                                                                                                method getBaseHref

                                                                                                                                                                                                                                                                                                                                getBaseHref: () => string;

                                                                                                                                                                                                                                                                                                                                  method getBaseHrefFromDOM

                                                                                                                                                                                                                                                                                                                                  getBaseHrefFromDOM: () => string;

                                                                                                                                                                                                                                                                                                                                    method onHashChange

                                                                                                                                                                                                                                                                                                                                    onHashChange: (_fn: any) => void;

                                                                                                                                                                                                                                                                                                                                      method onPopState

                                                                                                                                                                                                                                                                                                                                      onPopState: (fn: any) => void;

                                                                                                                                                                                                                                                                                                                                        method path

                                                                                                                                                                                                                                                                                                                                        path: () => string;

                                                                                                                                                                                                                                                                                                                                          method prepareExternalUrl

                                                                                                                                                                                                                                                                                                                                          prepareExternalUrl: (internal: string) => string;

                                                                                                                                                                                                                                                                                                                                            method pushState

                                                                                                                                                                                                                                                                                                                                            pushState: (state: any, title: string, url: string) => void;

                                                                                                                                                                                                                                                                                                                                              method replaceState

                                                                                                                                                                                                                                                                                                                                              replaceState: (state: any, title: string, url: string) => void;

                                                                                                                                                                                                                                                                                                                                                method toJSON

                                                                                                                                                                                                                                                                                                                                                toJSON: () => any;

                                                                                                                                                                                                                                                                                                                                                  method updateUrl

                                                                                                                                                                                                                                                                                                                                                  updateUrl: (originUrl: any, baseUrl?: string) => void;

                                                                                                                                                                                                                                                                                                                                                    class NodeSharedStylesHost

                                                                                                                                                                                                                                                                                                                                                    class NodeSharedStylesHost extends SharedStylesHost {}

                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                      constructor();

                                                                                                                                                                                                                                                                                                                                                        method addHost

                                                                                                                                                                                                                                                                                                                                                        addHost: (hostNode: Node) => void;

                                                                                                                                                                                                                                                                                                                                                          method onStylesAdded

                                                                                                                                                                                                                                                                                                                                                          onStylesAdded: (additions: string[]) => void;

                                                                                                                                                                                                                                                                                                                                                            method removeHost

                                                                                                                                                                                                                                                                                                                                                            removeHost: (hostNode: Node) => void;

                                                                                                                                                                                                                                                                                                                                                              class PopStateEvent

                                                                                                                                                                                                                                                                                                                                                              class PopStateEvent {}

                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                constructor(state: any);

                                                                                                                                                                                                                                                                                                                                                                  property state

                                                                                                                                                                                                                                                                                                                                                                  state: any;

                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                                                      toJSON: () => { state: any };

                                                                                                                                                                                                                                                                                                                                                                        class PreloadHttp

                                                                                                                                                                                                                                                                                                                                                                        class PreloadHttp extends Http {}

                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                          constructor(_backend: any, _defaultOptions: any);

                                                                                                                                                                                                                                                                                                                                                                            method delete

                                                                                                                                                                                                                                                                                                                                                                            delete: (url: string, options?: any) => Observable<Response> | EventEmitter<any>;

                                                                                                                                                                                                                                                                                                                                                                              method get

                                                                                                                                                                                                                                                                                                                                                                              get: (url: string, options?: any) => Observable<Response> | EventEmitter<any>;

                                                                                                                                                                                                                                                                                                                                                                                method head

                                                                                                                                                                                                                                                                                                                                                                                head: (url: string, options?: any) => Observable<Response> | EventEmitter<any>;

                                                                                                                                                                                                                                                                                                                                                                                  method patch

                                                                                                                                                                                                                                                                                                                                                                                  patch: (
                                                                                                                                                                                                                                                                                                                                                                                  url: string,
                                                                                                                                                                                                                                                                                                                                                                                  body: string,
                                                                                                                                                                                                                                                                                                                                                                                  options?: any
                                                                                                                                                                                                                                                                                                                                                                                  ) => Observable<Response> | EventEmitter<any>;

                                                                                                                                                                                                                                                                                                                                                                                    method post

                                                                                                                                                                                                                                                                                                                                                                                    post: (
                                                                                                                                                                                                                                                                                                                                                                                    url: string,
                                                                                                                                                                                                                                                                                                                                                                                    body: string,
                                                                                                                                                                                                                                                                                                                                                                                    options?: any
                                                                                                                                                                                                                                                                                                                                                                                    ) => Observable<Response> | EventEmitter<any>;

                                                                                                                                                                                                                                                                                                                                                                                      method preload

                                                                                                                                                                                                                                                                                                                                                                                      preload: (_url: any, factory: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                        method put

                                                                                                                                                                                                                                                                                                                                                                                        put: (
                                                                                                                                                                                                                                                                                                                                                                                        url: string,
                                                                                                                                                                                                                                                                                                                                                                                        body: string,
                                                                                                                                                                                                                                                                                                                                                                                        options?: any
                                                                                                                                                                                                                                                                                                                                                                                        ) => Observable<Response> | EventEmitter<any>;

                                                                                                                                                                                                                                                                                                                                                                                          method request

                                                                                                                                                                                                                                                                                                                                                                                          request: (
                                                                                                                                                                                                                                                                                                                                                                                          url: string | Request,
                                                                                                                                                                                                                                                                                                                                                                                          options?: any
                                                                                                                                                                                                                                                                                                                                                                                          ) => Observable<Response> | EventEmitter<any>;

                                                                                                                                                                                                                                                                                                                                                                                            class SharedStylesHost

                                                                                                                                                                                                                                                                                                                                                                                            class SharedStylesHost {}

                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                              constructor();

                                                                                                                                                                                                                                                                                                                                                                                                method addStyles

                                                                                                                                                                                                                                                                                                                                                                                                addStyles: (styles: string[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                  method getAllStyles

                                                                                                                                                                                                                                                                                                                                                                                                  getAllStyles: () => string[];

                                                                                                                                                                                                                                                                                                                                                                                                    method onStylesAdded

                                                                                                                                                                                                                                                                                                                                                                                                    onStylesAdded: (_additions: string[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                      class State

                                                                                                                                                                                                                                                                                                                                                                                                      class State {}

                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                        constructor(state: any, title: string, url: string);

                                                                                                                                                                                                                                                                                                                                                                                                          property state

                                                                                                                                                                                                                                                                                                                                                                                                          state: any;

                                                                                                                                                                                                                                                                                                                                                                                                            property title

                                                                                                                                                                                                                                                                                                                                                                                                            title: string;

                                                                                                                                                                                                                                                                                                                                                                                                              property url

                                                                                                                                                                                                                                                                                                                                                                                                              url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                toJSON: () => { state: any; title: string; url: string };

                                                                                                                                                                                                                                                                                                                                                                                                                  class StringMapWrapper

                                                                                                                                                                                                                                                                                                                                                                                                                  class StringMapWrapper {}

                                                                                                                                                                                                                                                                                                                                                                                                                    method contains

                                                                                                                                                                                                                                                                                                                                                                                                                    static contains: (map: { [key: string]: any }, key: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                                                                                                      static create: () => { [k: string]: any };

                                                                                                                                                                                                                                                                                                                                                                                                                        method delete

                                                                                                                                                                                                                                                                                                                                                                                                                        static delete: (map: { [key: string]: any }, key: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          method equals

                                                                                                                                                                                                                                                                                                                                                                                                                          static equals: <V>(
                                                                                                                                                                                                                                                                                                                                                                                                                          m1: { [key: string]: V },
                                                                                                                                                                                                                                                                                                                                                                                                                          m2: { [key: string]: V }
                                                                                                                                                                                                                                                                                                                                                                                                                          ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                            method forEach

                                                                                                                                                                                                                                                                                                                                                                                                                            static forEach: <V>(
                                                                                                                                                                                                                                                                                                                                                                                                                            map: { [key: string]: V },
                                                                                                                                                                                                                                                                                                                                                                                                                            callback: (v: V, key: string) => void
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              method get

                                                                                                                                                                                                                                                                                                                                                                                                                              static get: <V>(map: { [key: string]: V }, key: string) => V;

                                                                                                                                                                                                                                                                                                                                                                                                                                method isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                static isEmpty: (map: { [key: string]: any }) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method keys

                                                                                                                                                                                                                                                                                                                                                                                                                                  static keys: (map: { [key: string]: any }) => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                    method merge

                                                                                                                                                                                                                                                                                                                                                                                                                                    static merge: <V>(
                                                                                                                                                                                                                                                                                                                                                                                                                                    m1: { [key: string]: V },
                                                                                                                                                                                                                                                                                                                                                                                                                                    m2: { [key: string]: V }
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => { [key: string]: V };

                                                                                                                                                                                                                                                                                                                                                                                                                                      method set

                                                                                                                                                                                                                                                                                                                                                                                                                                      static set: <V>(map: { [key: string]: V }, key: string, value: V) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method values

                                                                                                                                                                                                                                                                                                                                                                                                                                        static values: <T>(map: { [key: string]: T }) => T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                          Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EventManagerPlugin

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EventManagerPlugin {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            property manager

                                                                                                                                                                                                                                                                                                                                                                                                                                            manager: EventManager | NodeEventManager;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method addEventListener

                                                                                                                                                                                                                                                                                                                                                                                                                                              addEventListener: (element: any, eventName: string, handler: Function) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method addGlobalEventListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                addGlobalEventListener: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                element: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                eventName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                handler: Function
                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method supports

                                                                                                                                                                                                                                                                                                                                                                                                                                                  supports: (eventName: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LocationConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LocationConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                      hash?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property pathname

                                                                                                                                                                                                                                                                                                                                                                                                                                                        pathname?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property search

                                                                                                                                                                                                                                                                                                                                                                                                                                                          search?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NodeLocationConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NodeLocationConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                              hash?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                host?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hostname

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hostname?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property href

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    href?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property pathname

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pathname?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        port?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property protocol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protocol?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property search

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            search?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (10)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (3)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/angular2-platform-node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/angular2-platform-node)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/angular2-platform-node"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>