getTypeName(): string

getMethod(): string

createResponse()

public constructor(init?:Partial<ResponseStatus>) { Object.assign(this, init) }

errorCode?: string

message?: string

stackTrace?: string

errors?: ResponseError[]

meta?: { [index: string]: string }

public constructor(init?:Partial<ResponseError>) { Object.assign(this, init) }

errorCode?: string

fieldName?: string

message?: string

meta?: { [index: string]: string }

public constructor(init?:Partial<ErrorResponse>) { Object.assign(this, init) }

type?: ErrorResponseType

responseStatus?: ResponseStatus

public label: string

public href: string

public exact?: boolean

public id: string

public className?: string

public iconClass?: string

public show?: string

public hide?: string

public children?: NavItem[]

public meta?: { [index:string]: string }

public constructor(init?:Partial<NavItem>) { (Object as any).assign(this, init) }

public constructor(init?:Partial<GetNavItems>) { (Object as any).assign(this, init) }

public createResponse() { return new GetNavItemsResponse() }

public getTypeName() { return 'GetNavItems' }

public getMethod() { return 'GET' }

public baseUrl: string

public results: NavItem[]

public navItemsMap: { [index:string]: NavItem[] }

public meta: { [index:string]: string }

public responseStatus: ResponseStatus

public constructor(init?:Partial<GetNavItemsResponse>) { (Object as any).assign(this, init) }

public baseUrl?: string

public defaultNamespaces?: string[]

public defaultImports?: string[]

public includeTypes?: string[]

public excludeTypes?: string[]

public treatTypesAsStrings?: string[]

public globalNamespace?: string

public ignoreTypes?: string[]

public exportTypes?: string[]

public exportAttributes?: string[]

public ignoreTypesInNamespaces?: string[]

public constructor(init?: Partial<MetadataTypesConfig>) { (Object as any).assign(this, init) }

public path?: string

public verbs?: string

public notes?: string

public summary?: string

public constructor(init?: Partial<MetadataRoute>) { (Object as any).assign(this, init) }

public request?: MetadataType

public response?: MetadataType

public actions?: string[]

public returnsVoid?: boolean

public returnType?: MetadataTypeName

public routes?: MetadataRoute[]

public dataModel?: MetadataTypeName

public viewModel?: MetadataTypeName

public requiresAuth?: boolean

public requiredRoles?: string[]

public requiresAnyRole?: string[]

public requiredPermissions?: string[]

public requiresAnyPermission?: string[]

public tags?: string[]

public constructor(init?: Partial<MetadataOperationType>) { (Object as any).assign(this, init) }

public config?: MetadataTypesConfig

public namespaces?: string[]

public types?: MetadataType[]

public operations?: MetadataOperationType[]

public constructor(init?: Partial<MetadataTypes>) { (Object as any).assign(this, init) }

public name?: string

public namespace?: string

public genericArgs?: string[]

public constructor(init?: Partial<MetadataTypeName>) { (Object as any).assign(this, init) }

public name?: string

public namespace?: string

public constructor(init?: Partial<MetadataDataContract>) { (Object as any).assign(this, init) }

public name?: string

public order?: number

public isRequired?: boolean

public emitDefaultValue?: boolean

public constructor(init?: Partial<MetadataDataMember>) { (Object as any).assign(this, init) }

public name?: string

public constructorArgs?: MetadataPropertyType[]

public args?: MetadataPropertyType[]

public constructor(init?: Partial<MetadataAttribute>) { (Object as any).assign(this, init) }

public name?: string

public type?: string

public isValueType?: boolean

public isSystemType?: boolean

public isEnum?: boolean

public isPrimaryKey?: boolean

public typeNamespace?: string

public genericArgs?: string[]

public value?: string

public description?: string

public dataMember?: MetadataDataMember

public readOnly?: boolean

public paramType?: string

public displayType?: string

public isRequired?: boolean

public allowableValues?: string[]

public allowableMin?: number

public allowableMax?: number

public attributes?: MetadataAttribute[]

uploadTo?: string;

input?: InputInfo;

format?: FormatInfo;

ref?: RefInfo;

public constructor(init?: Partial<MetadataPropertyType>) { (Object as any).assign(this, init) }

public name?: string

public namespace?: string

public genericArgs?: string[]

public inherits?: MetadataTypeName

public implements?: MetadataTypeName[]

public displayType?: string

public description?: string

public notes?: string;

public icon?: ImageInfo;

public isNested?: boolean

public isEnum?: boolean

public isEnumInt?: boolean

public isInterface?: boolean

public isAbstract?: boolean

public dataContract?: MetadataDataContract

public properties?: MetadataPropertyType[]

public attributes?: MetadataAttribute[]

public innerTypes?: MetadataTypeName[]

public enumNames?: string[]

public enumValues?: string[]

public enumMemberValues?: string[]

public enumDescriptions?: string[]

public meta?: { [index: string]: string }

public constructor(init?: Partial<MetadataType>) { (Object as any).assign(this, init) }

svg?: string;

uri?: string;

alt?: string;

cls?: string;

id: string;

name?: string;

type: string;

value?: string;

placeholder?: string;

help?: string;

label?: string;

title?: string;

size?: string;

pattern?: string;

readOnly?: boolean;

required?: boolean;

disabled?: boolean;

autocomplete?: string;

autofocus?: string;

min?: string;

max?: string;

step?: number;

minLength?: number;

maxLength?: number;

accept?: string;

capture?: string;

multiple?: boolean;

allowableValues?: string[];

allowableEntries?: KeyValuePair<string, string>[];

options?: string;

ignore?: boolean;

css?: FieldCss;

meta?: {

[index: string]: string;

};

method: string;

options?: string;

locale?: string;

model: string;

selfId: string;

refId: string;

refLabel: string;

field: string;

input: string;

label: string;

userName: string

displayName: string

userId?: string

roles?: string[]

permissions?: string[]

profileUrl?: string

tryResolve(ctor:ObjectConstructor): any {

return new ctor()

}

tryResolve(ctor:ObjectConstructor): any {

return (ctor as any).instance

|| ((ctor as any).instance = new ctor())

}

type: "ServerEventConnect" | "ServerEventHeartbeat" | "ServerEventJoin" | "ServerEventLeave" | "ServerEventUpdate" | "ServerEventMessage"

eventId: number

channel: string

data: string

selector: string

json: string

op: string

target: string

cssSelector: string

body: any

meta: { [index:string]: string }

userId: string

displayName: string

channels: string

profileUrl: string

id: string

unRegisterUrl: string

heartbeatUrl: string

updateSubscriberUrl: string

heartbeatIntervalMs: number

idleTimeoutMs: number

switch (evt) {

case 'onConnect':

return 'ServerEventConnect'

case 'onHeartbeat':

return 'ServerEventHeartbeat'

case 'onJoin':

return 'ServerEventJoin'

case 'onLeave':

return 'ServerEventLeave'

case 'onUpdate':

return 'ServerEventUpdate'

}

return null

url?: string

onerror?: (...args: any[]) => void

onmessage?: (...args: any[]) => void

error?: Error

new (url: string, eventSourceInitDict?: IEventSourceInit): IEventSourceStatic

url: string

withCredentials: boolean

CONNECTING: ReadyState // constant, always 0

OPEN: ReadyState // constant, always 1

CLOSED: ReadyState // constant, always 2

readyState: ReadyState

onopen: Function

onmessage: (event: IOnMessageEvent) => void

onerror: Function

close: () => void

channels?: string

handlers?: any

receivers?: any

onException?: Function

onReconnect?: Function

onTick?: Function

resolver?: IResolver

validate?: (request:ServerEventMessage) => boolean

heartbeatUrl?: string

unRegisterUrl?: string

updateSubscriberUrl?: string

heartbeatIntervalMs?: number

heartbeat?: number

resolveStreamUrl?: (url:string) => string

static UnknownChannel = "*"

eventStreamUri: string

updateSubscriberUrl: string

connectionInfo: ServerEventConnect

serviceClient: JsonServiceClient

stopped: boolean

resolver: IResolver

listeners: { [index:string]: ((e:ServerEventMessage) => void)[] }

EventSource: IEventSourceStatic

withCredentials: boolean

constructor(

baseUrl: string,

public channels: string[],

public options: IEventSourceOptions = {},

public eventSource: IEventSourceStatic = null) {

if (this.channels.length === 0)

throw "at least 1 channel is required"

this.resolver = this.options.resolver || new NewInstanceResolver()

this.eventStreamUri = combinePaths(baseUrl, "event-stream") + "?"

this.updateChannels(channels)

this.serviceClient = new JsonServiceClient(baseUrl)

this.listeners = {}

this.withCredentials = true

if (!this.options.handlers)

this.options.handlers = {}

}

onMessage = (e: IOnMessageEvent) => {

if (typeof document == "undefined") { //node

//latest node-fetch + eventsource doesn't split SSE messages properly

let requireSplitPos = e.data ? e.data.indexOf('\n') : -1

if (requireSplitPos >= 0) {

let data = e.data

let lastEventId = (e as any).lastEventId

let e1 = Object.assign({}, { lastEventId, data:data.substring(0,requireSplitPos) }),

e2 = Object.assign({}, { lastEventId, data:data.substring(requireSplitPos+1) })

this._onMessage(e1)

this._onMessage(e2)

return

}

}

this._onMessage(e)

}

_onMessage = (e: IOnMessageEvent) => {

if (this.stopped) return

let opt = this.options

if (typeof document == "undefined") {

var document:any = { //var hoisting required (node)

querySelectorAll: sel => []

}

}

let parts = splitOnFirst(e.data, " ")

let channel = null

let selector = parts[0]

let selParts = splitOnFirst(selector, "@")

if (selParts.length > 1) {

channel = selParts[0]

selector = selParts[1]

}

const json = parts[1]

let body = null

try {

body = json ? JSON.parse(json) : null

} catch(ignore){}

parts = splitOnFirst(selector, ".")

if (parts.length <= 1)

throw "invalid selector format: " + selector

let op = parts[0],

target = parts[1].replace(new RegExp("%20", "g"), " ")

const tokens = splitOnFirst(target, "$")

const [cmd, cssSelector] = tokens

const els = cssSelector && $$(cssSelector)

const el = els && els[0]

const eventId = parseInt((e as any).lastEventId)

const data = e.data

const type = eventMessageType(cmd) || "ServerEventMessage"

const request:ServerEventMessage = { eventId, data, type,

channel, selector, json, body, op, target:tokens[0], cssSelector, meta:{} }

const mergedBody = typeof body == "object"

? Object.assign({}, request, body)

: request

if (opt.validate && opt.validate(request) === false)

return

let headers = new Headers()

headers.set("Content-Type", "text/plain")

if (op === "cmd") {

if (cmd === "onConnect") {

this.connectionInfo = mergedBody

if (typeof body.heartbeatIntervalMs == "string")

this.connectionInfo.heartbeatIntervalMs = parseInt(body.heartbeatIntervalMs)

if (typeof body.idleTimeoutMs == "string")

this.connectionInfo.idleTimeoutMs = parseInt(body.idleTimeoutMs)

Object.assign(opt, body)

let fn = opt.handlers["onConnect"]

if (fn){

fn.call(el || document.body, this.connectionInfo, request)

if (this.stopped)

return

}

if (opt.heartbeatUrl) {

if (opt.heartbeat) {

clearInterval(opt.heartbeat)

}

opt.heartbeat = setInterval(async () => {

if (this.eventSource.readyState === EventSource.CLOSED)

{

clearInterval(opt.heartbeat)

const stopFn = opt.handlers["onStop"]

if (stopFn != null)

stopFn.apply(this.eventSource)

this.reconnectServerEvents({ error: new Error("EventSource is CLOSED") })

return

}

const reqHeartbeat = new Request(opt.heartbeatUrl, {

method: "POST", mode: "cors", headers: headers, credentials: this.serviceClient.credentials

})

try {

let res = await fetch(reqHeartbeat)

if (!res.ok) {

const error = new Error(`${res.status} - ${res.statusText}`)

this.reconnectServerEvents({ error })

}

else {

await res.text()

}

}

catch (error) {

this.reconnectServerEvents({ error })

}

}, (this.connectionInfo && this.connectionInfo.heartbeatIntervalMs) || opt.heartbeatIntervalMs || 10000) as any

}

if (opt.unRegisterUrl) {

if (typeof window != "undefined") {

window.onunload = () => {

if (navigator.sendBeacon) { // Chrome https://developers.google.com/web/updates/2019/12/chrome-80-deps-rems

this.stopped = true

if (this.eventSource) this.eventSource.close()

navigator.sendBeacon(opt.unRegisterUrl)

}

else {

this.stop()

}

}

}

}

this.updateSubscriberUrl = opt.updateSubscriberUrl

this.updateChannels((opt.channels || "").split(","))

} else {

let isCmdMsg = cmd == "onJoin" || cmd == "onLeave" || cmd == "onUpdate"

let fn = opt.handlers[cmd]

if (fn) {

if (isCmdMsg) {

fn.call(el || document.body, mergedBody)

} else {

fn.call(el || document.body, body, request)

}

} else {

if (!isCmdMsg) { //global receiver

let r = opt.receivers && opt.receivers["cmd"]

this.invokeReceiver(r, cmd, el, request, "cmd")

}

}

if (isCmdMsg) {

fn = opt.handlers["onCommand"]

if (fn) {

fn.call(el || document.body, mergedBody)

}

}

}

}

else if (op === "trigger") {

this.raiseEvent(target, request)

}

else if (op === "css") {

css(els || $$("body"), cmd, body)

}

//Named Receiver

let r = opt.receivers && opt.receivers[op]

this.invokeReceiver(r, cmd, el, request, op)

if (!eventMessageType(cmd))

{

let fn = opt.handlers["onMessage"]

if (fn) {

fn.call(el || document.body, mergedBody)

}

}

if (opt.onTick)

opt.onTick()

}

onError = (error?:any):void => {

if (this.stopped) return

if (!error)

error = event

let fn = this.options.onException

if (fn != null)

fn.call(this.eventSource, error)

if (this.options.onTick)

this.options.onTick()

}

getEventSourceOptions() {

return { withCredentials: this.withCredentials }

}

reconnectServerEvents(opt:IReconnectServerEventsOptions = {}) {

if (this.stopped) return

if (opt.error)

this.onError(opt.error)

const hold = this.eventSource

let url = opt.url || this.eventStreamUri || hold.url

if (this.options.resolveStreamUrl != null) {

url = this.options.resolveStreamUrl(url)

}

const es = this.EventSource

? new this.EventSource(url, this.getEventSourceOptions())

: new EventSource(url, this.getEventSourceOptions())

es.addEventListener('error', e => (opt.onerror || hold.onerror || this.onError)(e))

es.addEventListener('message', opt.onmessage || hold.onmessage || this.onMessage)

let fn = this.options.onReconnect

if (fn != null)

fn.call(es, opt.error)

if (hold.removeEventListener) {

hold.removeEventListener('error', this.onError)

hold.removeEventListener('message', this.onMessage as any)

}

hold.close()

return this.eventSource = es

}

start() {

this.stopped = false

if (this.eventSource == null || this.eventSource.readyState === EventSource.CLOSED) {

let url = this.eventStreamUri

if (this.options.resolveStreamUrl != null) {

url = this.options.resolveStreamUrl(url)

}

this.eventSource = this.EventSource

? new this.EventSource(url, this.getEventSourceOptions())

: new EventSource(url, this.getEventSourceOptions())

this.eventSource.addEventListener('error', this.onError)

this.eventSource.addEventListener('message', e => this.onMessage(e as any))

}

return this

}

stop() : Promise<void> {

this.stopped = true

if (this.eventSource) {

this.eventSource.close()

}

let opt = this.options

if (opt && opt.heartbeat) {

clearInterval(opt.heartbeat)

}

let hold = this.connectionInfo

if (hold == null || hold.unRegisterUrl == null)

return new Promise<void>((resolve, reject) => resolve())

this.connectionInfo = null

return fetch(new Request(hold.unRegisterUrl, { method: "POST", mode: "cors", credentials: this.serviceClient.credentials }))

.then(res => { if (!res.ok) throw new Error(`${res.status} - ${res.statusText}`) })

.catch(this.onError)

}

invokeReceiver(r:any, cmd:string, el:Element, request:ServerEventMessage, name:string) {

if (r) {

if (typeof r == "function") {

r = this.resolver.tryResolve(r)

}

cmd = cmd.replace("-","")

r.client = this

r.request = request

if (typeof (r[cmd]) == "function") {

r[cmd].call(el || r, request.body, request)

} else if (cmd in r) {

r[cmd] = request.body

} else {

let metaProp = Object.getOwnPropertyDescriptor(r, cmd)

if (metaProp != null) {

if (metaProp.set) {

metaProp.set(request.body)

} else if (metaProp.writable) {

r[cmd] = request.body

}

return

}

let cmdLower = cmd.toLowerCase()

getAllMembers(r).forEach(k => {

if (k.toLowerCase() == cmdLower) {

if (typeof r[k] == "function") {

r[k].call(el || r, request.body, request)

} else {

r[k] = request.body

}

return

}

})

let noSuchMethod = r["noSuchMethod"]

if (typeof noSuchMethod == "function") {

noSuchMethod.call(el || r, request.target, request)

}

}

}

}

hasConnected() {

return this.connectionInfo != null

}

registerHandler(name:string, fn:Function) {

if (!this.options.handlers)

this.options.handlers = {}

this.options.handlers[name] = fn

return this

}

setResolver(resolver:IResolver) {

this.options.resolver = resolver

return this

}

registerReceiver(receiver:any){

return this.registerNamedReceiver("cmd", receiver)

}

registerNamedReceiver(name:string, receiver:any) {

if (!this.options.receivers)

this.options.receivers = {}

this.options.receivers[name] = receiver

return this

}

unregisterReceiver(name:string = "cmd") {

if (this.options.receivers) {

delete this.options.receivers[name]

}

return this

}

updateChannels(channels:string[]) {

this.channels = channels

const url = this.eventSource != null

? this.eventSource.url

: this.eventStreamUri

this.eventStreamUri = url.substring(0, Math.min(url.indexOf("?"), url.length)) + "?channels=" + channels.join(",") + "&t=" + new Date().getTime()

}

update(subscribe:string|string[], unsubscribe:string|string[]) {

let sub = typeof subscribe == "string" ? subscribe.split(',') : subscribe

let unsub = typeof unsubscribe == "string" ? unsubscribe.split(',') : unsubscribe

let channels = []

for (let i in this.channels) {

let c = this.channels[i]

if (unsub == null || unsub.indexOf(c) === -1) {

channels.push(c)

}

}

if (sub) {

for (let i in sub) {

let c = sub[i]

if (channels.indexOf(c) === -1) {

channels.push(c)

}

}

}

this.updateChannels(channels)

}

addListener(eventName:string, handler:((e:ServerEventMessage) => void)) {

let handlers = this.listeners[eventName] || (this.listeners[eventName] = [])

handlers.push(handler)

return this

}

removeListener(eventName:string, handler:((e:ServerEventMessage) => void)) {