-
Notifications
You must be signed in to change notification settings - Fork 0
/
blazor.d.ts
162 lines (139 loc) · 5.89 KB
/
blazor.d.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
import { HubConnection, HubConnectionBuilder } from '@microsoft/signalr';
interface NavigationOptions {
forceLoad: boolean;
replaceHistoryEntry: boolean;
historyEntryState?: string;
}
interface EventTypeOptions {
browserEventName?: string;
createEventArgs?: (event: Event) => unknown;
}
interface BlazorEvent {
type: keyof BlazorEventMap;
}
interface BlazorEventMap {
'enhancedload': BlazorEvent;
}
declare enum LogLevel {
Trace = 0,
Debug = 1,
Information = 2,
Warning = 3,
Error = 4,
Critical = 5,
None = 6
}
interface WebStartOptions {
logLevel?: LogLevel;
}
type ComponentParameters = Map<string, any> | null;
declare interface DynamicRootComponent {
setParameters(parameters?: ComponentParameters): any;
dispose(): Promise<void>;
}
interface IBlazorWeb {
navigateTo(uri: string, options: NavigationOptions): void;
registerCustomEventType(eventName: string, options: EventTypeOptions): void;
addEventListener<K extends keyof BlazorEventMap>(type: K, listener: (ev: BlazorEventMap[K]) => void): void;
removeEventListener<K extends keyof BlazorEventMap>(type: K, listener: (ev: BlazorEventMap[K]) => void): void;
rootComponents: {
add(toElement: Element, componentIdentifier: string, initialParameters?: ComponentParameters): Promise<DynamicRootComponent>;
}
start<TOptions extends WebStartOptions>(options?: TOptions): Promise<void>;
}
type WebAssemblyBootResourceType = 'assembly' | 'pdb' | 'dotnetjs' | 'dotnetwasm' | 'globalization' | 'manifest' | 'configuration';
type SingleAssetBehaviors = "dotnetwasm" | "js-module-dotnet" | "js-module-threads" | "js-module-runtime" | "js-module-native" | "manifest";
type AssetBehaviors = SingleAssetBehaviors | "resource" | "assembly" | "pdb" | "heap" | "icu" | "vfs" | "js-module-library-initializer" | "symbols";
type BeforeBlazorWebAssemblyStartedCallback = (options: Partial<WebAssemblyStartOptions>) => Promise<void>;
type AfterBlazorWebAssemblyStartedCallback = (blazor: IBlazorWebWebAssembly) => Promise<void>;
type WebAssemblyInitializers = {
beforeStart: BeforeBlazorWebAssemblyStartedCallback[];
afterStarted: AfterBlazorWebAssemblyStartedCallback[];
};
interface WebAssemblyStartOptions {
/**
* Overrides the built-in boot resource loading mechanism so that boot resources can be fetched
* from a custom source, such as an external CDN.
* @param type The type of the resource to be loaded.
* @param name The name of the resource to be loaded.
* @param defaultUri The URI from which the framework would fetch the resource by default. The URI may be relative or absolute.
* @param integrity The integrity string representing the expected content in the response.
* @param behavior The detailed behavior/type of the resource to be loaded.
* @returns A URI string or a Response promise to override the loading process, or null/undefined to allow the default loading behavior.
* When returned string is not qualified with `./` or absolute URL, it will be resolved against document.baseURI.
*/
loadBootResource(type: WebAssemblyBootResourceType, name: string, defaultUri: string, integrity: string, behavior: AssetBehaviors): string | Promise<Response> | null | undefined;
/** Override built-in environment setting on start. */
environment?: string;
/** Gets the application culture. This is a name specified in the BCP 47 format. See https://tools.ietf.org/html/bcp47 */
applicationCulture?: string;
initializers?: WebAssemblyInitializers;
/** Allows to override .NET runtime configuration. */
configureRuntime: InternalAPI;
}
interface WebAssemblyWebStartOptions extends WebStartOptions {
webAssembly?: WebAssemblyStartOptions;
}
interface IBlazorWebWebAssembly extends IBlazorWeb {
start(options?: WebAssemblyWebStartOptions): Promise<void>;
}
interface ReconnectionOptions {
maxRetries: number;
retryIntervalMilliseconds: number;
dialogId: string;
}
interface ReconnectionHandler {
onConnectionDown(options: ReconnectionOptions, error?: Error): void;
onConnectionUp(): void;
}
type BeforeBlazorServerStartedCallback = (options: Partial<CircuitStartOptions>) => Promise<void>;
type AfterBlazorServerStartedCallback = (blazor: IBlazorWebServer) => Promise<void>;
type ServerInitializers = {
beforeStart: BeforeBlazorServerStartedCallback[];
afterStarted: AfterBlazorServerStartedCallback[];
};
interface CircuitHandler {
onCircuitOpened?: () => void;
onCircuitClosed?: () => void;
}
interface CircuitStartOptions {
configureSignalR?: (builder: HubConnectionBuilder) => void;
logLevel?: LogLevel;
reconnectionOptions?: ReconnectionOptions;
reconnectionHandler?: ReconnectionHandler;
initializers?: ServerInitializers;
circuitHandlers?: CircuitHandler[];
}
interface ServerWebStartOptions extends WebStartOptions {
circuit?: CircuitStartOptions;
}
interface IBlazorWebServer extends IBlazorWeb {
start(options?: ServerWebStartOptions): Promise<void>;
disconnect(): void;
reconnect(existingConnection?: HubConnection): Promise<boolean>;
defaultReconnectionHandler: ReconnectionHandler;
}
interface SsrStartOptions {
/**
* If true, does not attempt to preserve DOM nodes when performing dynamic updates to SSR content
* (for example, during enhanced navigation or streaming rendering).
*/
disableDomPreservation?: boolean;
/**
* Configures how long to wait after all Blazor Server components have been removed from the document
* before closing the circuit.
*/
circuitInactivityTimeoutMs?: number;
}
interface SsrWebStartOptions extends WebStartOptions {
ssr?: SsrStartOptions;
}
interface IBlazorWebSsr extends IBlazorWeb {
start(options?: SsrWebStartOptions): Promise<void>;
}
type InternalAPI = unknown;
interface IBlazorInternal {
platform?: InternalAPI;
runtime: InternalAPI;
_internal: InternalAPI;
}