angular2-platform-node

angular2-platform-node

Version 2.1.0-rc.1
Published 7 years ago
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

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;

variable COOKIE_KEY

const COOKIE_KEY: OpaqueToken;

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: OpaqueToken;

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: OpaqueToken;

variable PRIME_CACHE

const PRIME_CACHE: OpaqueToken;

variable REQUEST_URL

const REQUEST_URL: OpaqueToken;

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: () => PlatformRef;

function getUrlConfig

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

function httpFactory

httpFactory: (
    xhrBackend: XHRBackend,
    requestOptions: RequestOptions
) => 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: JSONPBackend,
    requestOptions: RequestOptions
) => 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: RenderComponentType,
    _animationDriver: AnimationDriver
);

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: ResponseOptions,
    _browserXHR: BrowserXhr,
    _xsrfStrategy: XSRFStrategy,
    _ngZone: NgZone,
    _baseUrl: string,
    _originUrl: string
);

method createConnection

createConnection: (request: Request) => NodeConnection;

class NodeConnection

class NodeConnection implements XHRConnection {}

constructor

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

property readyState

readyState: ReadyState;

property request

request: Request;

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: RenderComponentType,
    _animationDriver: AnimationDriver
);

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: EventManager,
    sharedStylesHost: NodeSharedStylesHost,
    _animationDriver: AnimationDriver
);

property document

document: any;

property eventManager

eventManager: EventManager;

property registeredComponents

protected registeredComponents: Map<string, DomRenderer>;

property sharedStylesHost

sharedStylesHost: NodeSharedStylesHost;

method renderComponent

renderComponent: (componentProto: RenderComponentType) => Renderer;

class NodeEventManager

class NodeEventManager {}

constructor

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

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: () => NgZone;

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: ResponseOptions,
    _ngZone: NgZone,
    _baseUrl: string,
    _originUrl: string
);

method createConnection

createConnection: (request: Request) => NodeJSONPConnection;

class NodeJSONPConnection

class NodeJSONPConnection {}

constructor

constructor(
    req: Request,
    baseResponseOptions: ResponseOptions,
    ngZone: NgZone,
    originUrl?: string,
    baseUrl?: string
);

property readyState

readyState: ReadyState;

property request

request: Request;

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) => nodeUrl.Url;

method toJSON

toJSON: () => NodeLocationConfig;

class NodeModule

class NodeModule {}

constructor

constructor(parentModule: NodeModule);

method forRoot

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

method withConfig

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

class NodePlatform

class NodePlatform {}

constructor

constructor(_platformRef: PlatformRef);

property destroyed

readonly destroyed: boolean;

property disposed

readonly disposed: boolean;

property injector

readonly injector: Injector;

property platformRef

readonly platformRef: PlatformRef;

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: NgModuleRef<T>, 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: ConnectionBackend, _defaultOptions: RequestOptions);

method delete

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

method get

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

method head

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

method patch

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

method post

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

method preload

preload: (_url: any, factory: any) => EventEmitter<{}>;

method put

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

method request

request: (
    url: string | Request,
    options?: RequestOptionsArgs
) => 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 oneto 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>

Updated 1 year ago.
Package analyzed in 2569 ms.
Missing or incorrect documentation? Open an issue for this package.