@mpcore/simulator 0.4.2 → 0.4.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -0
- package/dist/index.d.mts +280 -272
- package/dist/index.mjs +64 -42
- package/package.json +1 -1
package/dist/index.d.mts
CHANGED
|
@@ -1,56 +1,56 @@
|
|
|
1
1
|
//#region src/host/globals.d.ts
|
|
2
|
-
interface HeadlessAppDefinition extends Record<string, any> {}
|
|
3
|
-
interface HeadlessPageDefinition extends Record<string, any> {}
|
|
4
|
-
interface HeadlessComponentDefinition extends Record<string, any> {}
|
|
5
|
-
interface HeadlessBehaviorDefinition extends Record<string, any> {
|
|
2
|
+
export interface HeadlessAppDefinition extends Record<string, any> {}
|
|
3
|
+
export interface HeadlessPageDefinition extends Record<string, any> {}
|
|
4
|
+
export interface HeadlessComponentDefinition extends Record<string, any> {}
|
|
5
|
+
export interface HeadlessBehaviorDefinition extends Record<string, any> {
|
|
6
6
|
__isHeadlessBehavior__?: boolean;
|
|
7
7
|
}
|
|
8
|
-
interface HeadlessHostLoadContext {
|
|
8
|
+
export interface HeadlessHostLoadContext {
|
|
9
9
|
kind: 'app' | 'page' | 'component';
|
|
10
10
|
componentDefinitions?: HeadlessComponentDefinition[];
|
|
11
11
|
route?: string;
|
|
12
12
|
}
|
|
13
|
-
interface HeadlessHostRegistries {
|
|
13
|
+
export interface HeadlessHostRegistries {
|
|
14
14
|
appDefinition: HeadlessAppDefinition | null;
|
|
15
15
|
components: Map<string, HeadlessComponentDefinition>;
|
|
16
16
|
currentLoadContext: HeadlessHostLoadContext | null;
|
|
17
17
|
pages: Map<string, HeadlessPageDefinition>;
|
|
18
18
|
}
|
|
19
|
-
declare function normalizeComponentPageDefinition(definition: HeadlessComponentDefinition): HeadlessPageDefinition;
|
|
20
|
-
declare function createHostRegistries(): HeadlessHostRegistries;
|
|
21
|
-
declare function registerAppDefinition(registries: HeadlessHostRegistries, definition: HeadlessAppDefinition): HeadlessAppDefinition;
|
|
22
|
-
declare function registerPageDefinition(registries: HeadlessHostRegistries, definition: HeadlessPageDefinition, explicitRoute?: string): HeadlessPageDefinition;
|
|
23
|
-
declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition): HeadlessPageDefinition;
|
|
24
|
-
declare function registerExportedComponentDefinition(registries: HeadlessHostRegistries, id: string, moduleExports: Record<string, any>, registeredDefinition?: HeadlessComponentDefinition): HeadlessComponentDefinition | null;
|
|
19
|
+
export declare function normalizeComponentPageDefinition(definition: HeadlessComponentDefinition): HeadlessPageDefinition;
|
|
20
|
+
export declare function createHostRegistries(): HeadlessHostRegistries;
|
|
21
|
+
export declare function registerAppDefinition(registries: HeadlessHostRegistries, definition: HeadlessAppDefinition): HeadlessAppDefinition;
|
|
22
|
+
export declare function registerPageDefinition(registries: HeadlessHostRegistries, definition: HeadlessPageDefinition, explicitRoute?: string): HeadlessPageDefinition;
|
|
23
|
+
export declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition): HeadlessPageDefinition;
|
|
24
|
+
export declare function registerExportedComponentDefinition(registries: HeadlessHostRegistries, id: string, moduleExports: Record<string, any>, registeredDefinition?: HeadlessComponentDefinition): HeadlessComponentDefinition | null;
|
|
25
25
|
//#endregion
|
|
26
26
|
//#region src/host/wx/core.d.ts
|
|
27
|
-
interface HeadlessWxCallbackOption<TResult = void> {
|
|
27
|
+
export interface HeadlessWxCallbackOption<TResult = void> {
|
|
28
28
|
complete?: (result?: TResult) => void;
|
|
29
29
|
fail?: (error: Error) => void;
|
|
30
30
|
success?: (result: TResult) => void;
|
|
31
31
|
}
|
|
32
|
-
interface HeadlessWxLoadFontFaceResult {
|
|
32
|
+
export interface HeadlessWxLoadFontFaceResult {
|
|
33
33
|
errMsg: string;
|
|
34
34
|
}
|
|
35
|
-
interface HeadlessWxLoadFontFaceOption extends HeadlessWxCallbackOption<HeadlessWxLoadFontFaceResult> {
|
|
35
|
+
export interface HeadlessWxLoadFontFaceOption extends HeadlessWxCallbackOption<HeadlessWxLoadFontFaceResult> {
|
|
36
36
|
descriptors?: Record<string, string>;
|
|
37
37
|
family: string;
|
|
38
38
|
global?: boolean;
|
|
39
39
|
scopes?: string[];
|
|
40
40
|
source: string;
|
|
41
41
|
}
|
|
42
|
-
interface HeadlessWxNavigateOption extends HeadlessWxCallbackOption {
|
|
42
|
+
export interface HeadlessWxNavigateOption extends HeadlessWxCallbackOption {
|
|
43
43
|
url: string;
|
|
44
44
|
}
|
|
45
|
-
interface HeadlessWxNavigateBackOption extends HeadlessWxCallbackOption {
|
|
45
|
+
export interface HeadlessWxNavigateBackOption extends HeadlessWxCallbackOption {
|
|
46
46
|
delta?: number;
|
|
47
47
|
}
|
|
48
|
-
interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
|
|
48
|
+
export interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
|
|
49
49
|
duration?: number;
|
|
50
50
|
scrollTop?: number;
|
|
51
51
|
selector?: string;
|
|
52
52
|
}
|
|
53
|
-
interface HeadlessWxVideoContext {
|
|
53
|
+
export interface HeadlessWxVideoContext {
|
|
54
54
|
exitFullScreen: () => void;
|
|
55
55
|
pause: () => void;
|
|
56
56
|
play: () => void;
|
|
@@ -58,23 +58,23 @@ interface HeadlessWxVideoContext {
|
|
|
58
58
|
seek: (position: number) => void;
|
|
59
59
|
stop: () => void;
|
|
60
60
|
}
|
|
61
|
-
interface HeadlessWxAnimationStepOption {
|
|
61
|
+
export interface HeadlessWxAnimationStepOption {
|
|
62
62
|
delay?: number;
|
|
63
63
|
duration?: number;
|
|
64
64
|
timingFunction?: 'ease' | 'ease-in' | 'ease-in-out' | 'ease-out' | 'linear' | 'step-end' | 'step-start';
|
|
65
65
|
transformOrigin?: string;
|
|
66
66
|
}
|
|
67
|
-
interface HeadlessWxAnimationAction {
|
|
67
|
+
export interface HeadlessWxAnimationAction {
|
|
68
68
|
args: unknown[];
|
|
69
69
|
type: string;
|
|
70
70
|
}
|
|
71
|
-
interface HeadlessWxAnimationExportResult {
|
|
71
|
+
export interface HeadlessWxAnimationExportResult {
|
|
72
72
|
actions: Array<{
|
|
73
73
|
animates: HeadlessWxAnimationAction[];
|
|
74
74
|
option: Required<HeadlessWxAnimationStepOption>;
|
|
75
75
|
}>;
|
|
76
76
|
}
|
|
77
|
-
interface HeadlessWxAnimation {
|
|
77
|
+
export interface HeadlessWxAnimation {
|
|
78
78
|
backgroundColor: (value: string) => HeadlessWxAnimation;
|
|
79
79
|
bottom: (value: number | string) => HeadlessWxAnimation;
|
|
80
80
|
export: () => HeadlessWxAnimationExportResult;
|
|
@@ -93,11 +93,11 @@ interface HeadlessWxAnimation {
|
|
|
93
93
|
translateZ: (translation: number) => HeadlessWxAnimation;
|
|
94
94
|
width: (value: number | string) => HeadlessWxAnimation;
|
|
95
95
|
}
|
|
96
|
-
interface HeadlessWxCanvasDrawCall {
|
|
96
|
+
export interface HeadlessWxCanvasDrawCall {
|
|
97
97
|
args: unknown[];
|
|
98
98
|
type: string;
|
|
99
99
|
}
|
|
100
|
-
interface HeadlessWxCanvasSnapshot {
|
|
100
|
+
export interface HeadlessWxCanvasSnapshot {
|
|
101
101
|
canvasId: string;
|
|
102
102
|
drawCalls: HeadlessWxCanvasDrawCall[];
|
|
103
103
|
fillStyle: string;
|
|
@@ -118,7 +118,7 @@ interface HeadlessWxCanvasSnapshot {
|
|
|
118
118
|
textAlign: string;
|
|
119
119
|
textBaseline: string;
|
|
120
120
|
}
|
|
121
|
-
interface HeadlessWxCanvasContext {
|
|
121
|
+
export interface HeadlessWxCanvasContext {
|
|
122
122
|
__getSnapshot: () => HeadlessWxCanvasSnapshot;
|
|
123
123
|
arc: (x: number, y: number, r: number, sAngle: number, eAngle: number, counterclockwise?: boolean) => void;
|
|
124
124
|
arcTo: (x1: number, y1: number, x2: number, y2: number, radius: number) => void;
|
|
@@ -160,29 +160,29 @@ interface HeadlessWxCanvasContext {
|
|
|
160
160
|
strokeText: (text: string, x: number, y: number, maxWidth?: number) => void;
|
|
161
161
|
translate: (x: number, y: number) => void;
|
|
162
162
|
}
|
|
163
|
-
interface HeadlessWxIntersectionObserverMargins {
|
|
163
|
+
export interface HeadlessWxIntersectionObserverMargins {
|
|
164
164
|
bottom?: number;
|
|
165
165
|
left?: number;
|
|
166
166
|
right?: number;
|
|
167
167
|
top?: number;
|
|
168
168
|
}
|
|
169
|
-
interface HeadlessWxIntersectionObserverObserveAllResult {
|
|
169
|
+
export interface HeadlessWxIntersectionObserverObserveAllResult {
|
|
170
170
|
boundingClientRect: HeadlessWxSelectorQueryBoundingClientRectResult;
|
|
171
171
|
id: string;
|
|
172
172
|
intersectionRatio: number;
|
|
173
173
|
intersectionRect: HeadlessWxSelectorQueryBoundingClientRectResult;
|
|
174
174
|
relativeRect: HeadlessWxSelectorQueryBoundingClientRectResult;
|
|
175
175
|
}
|
|
176
|
-
interface HeadlessWxIntersectionObserver {
|
|
176
|
+
export interface HeadlessWxIntersectionObserver {
|
|
177
177
|
disconnect: () => void;
|
|
178
178
|
observe: (selector: string, callback: (result: HeadlessWxIntersectionObserverObserveAllResult) => void) => void;
|
|
179
179
|
relativeTo: (selector: string, margins?: HeadlessWxIntersectionObserverMargins) => HeadlessWxIntersectionObserver;
|
|
180
180
|
relativeToViewport: (margins?: HeadlessWxIntersectionObserverMargins) => HeadlessWxIntersectionObserver;
|
|
181
181
|
}
|
|
182
|
-
interface HeadlessWxCreateIntersectionObserverOption {
|
|
182
|
+
export interface HeadlessWxCreateIntersectionObserverOption {
|
|
183
183
|
thresholds?: number[];
|
|
184
184
|
}
|
|
185
|
-
interface HeadlessWxObserveDescriptor {
|
|
185
|
+
export interface HeadlessWxObserveDescriptor {
|
|
186
186
|
height?: number;
|
|
187
187
|
maxHeight?: number;
|
|
188
188
|
maxWidth?: number;
|
|
@@ -191,14 +191,14 @@ interface HeadlessWxObserveDescriptor {
|
|
|
191
191
|
orientation?: string;
|
|
192
192
|
width?: number;
|
|
193
193
|
}
|
|
194
|
-
interface HeadlessWxMediaQueryObserverObserveCallbackResult {
|
|
194
|
+
export interface HeadlessWxMediaQueryObserverObserveCallbackResult {
|
|
195
195
|
matches: boolean;
|
|
196
196
|
}
|
|
197
|
-
interface HeadlessWxMediaQueryObserver {
|
|
197
|
+
export interface HeadlessWxMediaQueryObserver {
|
|
198
198
|
disconnect: () => void;
|
|
199
199
|
observe: (descriptor: HeadlessWxObserveDescriptor, callback: (result: HeadlessWxMediaQueryObserverObserveCallbackResult) => void) => void;
|
|
200
200
|
}
|
|
201
|
-
interface HeadlessWxSelectorQueryBoundingClientRectResult {
|
|
201
|
+
export interface HeadlessWxSelectorQueryBoundingClientRectResult {
|
|
202
202
|
bottom: number;
|
|
203
203
|
height: number;
|
|
204
204
|
left: number;
|
|
@@ -206,11 +206,11 @@ interface HeadlessWxSelectorQueryBoundingClientRectResult {
|
|
|
206
206
|
top: number;
|
|
207
207
|
width: number;
|
|
208
208
|
}
|
|
209
|
-
interface HeadlessWxSelectorQueryScrollOffsetResult {
|
|
209
|
+
export interface HeadlessWxSelectorQueryScrollOffsetResult {
|
|
210
210
|
scrollLeft: number;
|
|
211
211
|
scrollTop: number;
|
|
212
212
|
}
|
|
213
|
-
interface HeadlessWxSelectorQueryFieldsOption {
|
|
213
|
+
export interface HeadlessWxSelectorQueryFieldsOption {
|
|
214
214
|
computedStyle?: string[];
|
|
215
215
|
context?: boolean;
|
|
216
216
|
dataset?: boolean;
|
|
@@ -222,42 +222,42 @@ interface HeadlessWxSelectorQueryFieldsOption {
|
|
|
222
222
|
scrollOffset?: boolean;
|
|
223
223
|
size?: boolean;
|
|
224
224
|
}
|
|
225
|
-
interface HeadlessWxSelectorQueryRequest {
|
|
225
|
+
export interface HeadlessWxSelectorQueryRequest {
|
|
226
226
|
fields: HeadlessWxSelectorQueryFieldsOption;
|
|
227
227
|
selector?: string;
|
|
228
228
|
single: boolean;
|
|
229
229
|
target: 'selector' | 'viewport';
|
|
230
230
|
}
|
|
231
|
-
interface HeadlessWxSelectorQueryNode {
|
|
231
|
+
export interface HeadlessWxSelectorQueryNode {
|
|
232
232
|
boundingClientRect: (callback?: (result: HeadlessWxSelectorQueryBoundingClientRectResult | HeadlessWxSelectorQueryBoundingClientRectResult[] | null) => void) => HeadlessWxSelectorQuery;
|
|
233
233
|
fields: (fields: HeadlessWxSelectorQueryFieldsOption, callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
|
|
234
234
|
node: (callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
|
|
235
235
|
scrollOffset: (callback?: (result: HeadlessWxSelectorQueryScrollOffsetResult | HeadlessWxSelectorQueryScrollOffsetResult[] | null) => void) => HeadlessWxSelectorQuery;
|
|
236
236
|
}
|
|
237
|
-
interface HeadlessWxSelectorQuery {
|
|
237
|
+
export interface HeadlessWxSelectorQuery {
|
|
238
238
|
exec: (callback?: (result: unknown[]) => void) => unknown[];
|
|
239
239
|
in: (component: Record<string, any>) => HeadlessWxSelectorQuery;
|
|
240
240
|
select: (selector: string) => HeadlessWxSelectorQueryNode;
|
|
241
241
|
selectAll: (selector: string) => HeadlessWxSelectorQueryNode;
|
|
242
242
|
selectViewport: () => HeadlessWxSelectorQueryNode;
|
|
243
243
|
}
|
|
244
|
-
interface HeadlessWxStorageResult {
|
|
244
|
+
export interface HeadlessWxStorageResult {
|
|
245
245
|
errMsg: string;
|
|
246
246
|
}
|
|
247
|
-
interface HeadlessWxGetStorageResult extends HeadlessWxStorageResult {
|
|
247
|
+
export interface HeadlessWxGetStorageResult extends HeadlessWxStorageResult {
|
|
248
248
|
data: unknown;
|
|
249
249
|
}
|
|
250
|
-
interface HeadlessWxStorageInfoResult extends HeadlessWxStorageResult {
|
|
250
|
+
export interface HeadlessWxStorageInfoResult extends HeadlessWxStorageResult {
|
|
251
251
|
currentSize: number;
|
|
252
252
|
keys: string[];
|
|
253
253
|
limitSize: number;
|
|
254
254
|
}
|
|
255
|
-
type HeadlessWxNetworkType = '2g' | '3g' | '4g' | '5g' | 'none' | 'unknown' | 'wifi';
|
|
256
|
-
interface HeadlessWxGetNetworkTypeResult {
|
|
255
|
+
export type HeadlessWxNetworkType = '2g' | '3g' | '4g' | '5g' | 'none' | 'unknown' | 'wifi';
|
|
256
|
+
export interface HeadlessWxGetNetworkTypeResult {
|
|
257
257
|
errMsg: string;
|
|
258
258
|
networkType: HeadlessWxNetworkType;
|
|
259
259
|
}
|
|
260
|
-
interface HeadlessWxGetLocationResult {
|
|
260
|
+
export interface HeadlessWxGetLocationResult {
|
|
261
261
|
accuracy: number;
|
|
262
262
|
altitude: number;
|
|
263
263
|
errMsg: string;
|
|
@@ -267,12 +267,12 @@ interface HeadlessWxGetLocationResult {
|
|
|
267
267
|
speed: number;
|
|
268
268
|
verticalAccuracy: number;
|
|
269
269
|
}
|
|
270
|
-
interface HeadlessWxNetworkStatusChangeResult {
|
|
270
|
+
export interface HeadlessWxNetworkStatusChangeResult {
|
|
271
271
|
isConnected: boolean;
|
|
272
272
|
networkType: HeadlessWxNetworkType;
|
|
273
273
|
}
|
|
274
|
-
type HeadlessWxNetworkStatusChangeCallback = (result: HeadlessWxNetworkStatusChangeResult) => void;
|
|
275
|
-
interface HeadlessWxSystemInfoResult {
|
|
274
|
+
export type HeadlessWxNetworkStatusChangeCallback = (result: HeadlessWxNetworkStatusChangeResult) => void;
|
|
275
|
+
export interface HeadlessWxSystemInfoResult {
|
|
276
276
|
SDKVersion: string;
|
|
277
277
|
brand: string;
|
|
278
278
|
language: string;
|
|
@@ -288,7 +288,7 @@ interface HeadlessWxSystemInfoResult {
|
|
|
288
288
|
windowHeight: number;
|
|
289
289
|
windowWidth: number;
|
|
290
290
|
}
|
|
291
|
-
interface HeadlessWxSafeArea {
|
|
291
|
+
export interface HeadlessWxSafeArea {
|
|
292
292
|
bottom: number;
|
|
293
293
|
height: number;
|
|
294
294
|
left: number;
|
|
@@ -296,13 +296,13 @@ interface HeadlessWxSafeArea {
|
|
|
296
296
|
top: number;
|
|
297
297
|
width: number;
|
|
298
298
|
}
|
|
299
|
-
interface HeadlessWxSafeAreaInsets {
|
|
299
|
+
export interface HeadlessWxSafeAreaInsets {
|
|
300
300
|
bottom: number;
|
|
301
301
|
left: number;
|
|
302
302
|
right: number;
|
|
303
303
|
top: number;
|
|
304
304
|
}
|
|
305
|
-
interface HeadlessWxAppBaseInfoResult {
|
|
305
|
+
export interface HeadlessWxAppBaseInfoResult {
|
|
306
306
|
SDKVersion: string;
|
|
307
307
|
enableDebug: boolean;
|
|
308
308
|
host: {
|
|
@@ -312,7 +312,7 @@ interface HeadlessWxAppBaseInfoResult {
|
|
|
312
312
|
platform: string;
|
|
313
313
|
version: string;
|
|
314
314
|
}
|
|
315
|
-
interface HeadlessWxDeviceInfoResult {
|
|
315
|
+
export interface HeadlessWxDeviceInfoResult {
|
|
316
316
|
abi: string;
|
|
317
317
|
benchmarkLevel: number;
|
|
318
318
|
brand: string;
|
|
@@ -323,7 +323,7 @@ interface HeadlessWxDeviceInfoResult {
|
|
|
323
323
|
platform: string;
|
|
324
324
|
system: string;
|
|
325
325
|
}
|
|
326
|
-
interface HeadlessWxWindowInfoResult {
|
|
326
|
+
export interface HeadlessWxWindowInfoResult {
|
|
327
327
|
pixelRatio: number;
|
|
328
328
|
safeArea: HeadlessWxSafeArea;
|
|
329
329
|
safeAreaInsets: HeadlessWxSafeAreaInsets;
|
|
@@ -333,7 +333,7 @@ interface HeadlessWxWindowInfoResult {
|
|
|
333
333
|
windowHeight: number;
|
|
334
334
|
windowWidth: number;
|
|
335
335
|
}
|
|
336
|
-
interface HeadlessWxLaunchOptions {
|
|
336
|
+
export interface HeadlessWxLaunchOptions {
|
|
337
337
|
path: string;
|
|
338
338
|
query: Record<string, string>;
|
|
339
339
|
referrerInfo: {
|
|
@@ -342,7 +342,7 @@ interface HeadlessWxLaunchOptions {
|
|
|
342
342
|
};
|
|
343
343
|
scene: number;
|
|
344
344
|
}
|
|
345
|
-
interface HeadlessWxMenuButtonBoundingClientRectResult {
|
|
345
|
+
export interface HeadlessWxMenuButtonBoundingClientRectResult {
|
|
346
346
|
bottom: number;
|
|
347
347
|
height: number;
|
|
348
348
|
left: number;
|
|
@@ -350,110 +350,110 @@ interface HeadlessWxMenuButtonBoundingClientRectResult {
|
|
|
350
350
|
top: number;
|
|
351
351
|
width: number;
|
|
352
352
|
}
|
|
353
|
-
interface HeadlessWxSetStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
353
|
+
export interface HeadlessWxSetStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
354
354
|
data: unknown;
|
|
355
355
|
key: string;
|
|
356
356
|
}
|
|
357
|
-
interface HeadlessWxSetClipboardDataResult {
|
|
357
|
+
export interface HeadlessWxSetClipboardDataResult {
|
|
358
358
|
errMsg: string;
|
|
359
359
|
}
|
|
360
|
-
interface HeadlessWxSetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxSetClipboardDataResult> {
|
|
360
|
+
export interface HeadlessWxSetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxSetClipboardDataResult> {
|
|
361
361
|
data: string;
|
|
362
362
|
}
|
|
363
|
-
interface HeadlessWxGetClipboardDataResult {
|
|
363
|
+
export interface HeadlessWxGetClipboardDataResult {
|
|
364
364
|
data: string;
|
|
365
365
|
errMsg: string;
|
|
366
366
|
}
|
|
367
|
-
interface HeadlessWxGetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxGetClipboardDataResult> {}
|
|
368
|
-
interface HeadlessWxGetStorageOption extends HeadlessWxCallbackOption<HeadlessWxGetStorageResult> {
|
|
367
|
+
export interface HeadlessWxGetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxGetClipboardDataResult> {}
|
|
368
|
+
export interface HeadlessWxGetStorageOption extends HeadlessWxCallbackOption<HeadlessWxGetStorageResult> {
|
|
369
369
|
key: string;
|
|
370
370
|
}
|
|
371
|
-
interface HeadlessWxGetStorageInfoOption extends HeadlessWxCallbackOption<HeadlessWxStorageInfoResult> {}
|
|
372
|
-
interface HeadlessWxGetNetworkTypeOption extends HeadlessWxCallbackOption<HeadlessWxGetNetworkTypeResult> {}
|
|
373
|
-
interface HeadlessWxGetLocationOption extends HeadlessWxCallbackOption<HeadlessWxGetLocationResult> {
|
|
371
|
+
export interface HeadlessWxGetStorageInfoOption extends HeadlessWxCallbackOption<HeadlessWxStorageInfoResult> {}
|
|
372
|
+
export interface HeadlessWxGetNetworkTypeOption extends HeadlessWxCallbackOption<HeadlessWxGetNetworkTypeResult> {}
|
|
373
|
+
export interface HeadlessWxGetLocationOption extends HeadlessWxCallbackOption<HeadlessWxGetLocationResult> {
|
|
374
374
|
altitude?: boolean;
|
|
375
375
|
highAccuracyExpireTime?: number;
|
|
376
376
|
isHighAccuracy?: boolean;
|
|
377
377
|
type?: 'gcj02' | 'wgs84';
|
|
378
378
|
}
|
|
379
|
-
interface HeadlessWxGetSystemInfoOption extends HeadlessWxCallbackOption<HeadlessWxSystemInfoResult> {}
|
|
380
|
-
interface HeadlessWxGetWindowInfoOption extends HeadlessWxCallbackOption<HeadlessWxWindowInfoResult> {}
|
|
381
|
-
interface HeadlessWxGetAppBaseInfoOption extends HeadlessWxCallbackOption<HeadlessWxAppBaseInfoResult> {}
|
|
379
|
+
export interface HeadlessWxGetSystemInfoOption extends HeadlessWxCallbackOption<HeadlessWxSystemInfoResult> {}
|
|
380
|
+
export interface HeadlessWxGetWindowInfoOption extends HeadlessWxCallbackOption<HeadlessWxWindowInfoResult> {}
|
|
381
|
+
export interface HeadlessWxGetAppBaseInfoOption extends HeadlessWxCallbackOption<HeadlessWxAppBaseInfoResult> {}
|
|
382
382
|
//#endregion
|
|
383
383
|
//#region src/host/wx/eventBus.d.ts
|
|
384
|
-
type HeadlessUniEventHandler = (...args: any[]) => void;
|
|
385
|
-
interface HeadlessUniEventBus {
|
|
384
|
+
export type HeadlessUniEventHandler = (...args: any[]) => void;
|
|
385
|
+
export interface HeadlessUniEventBus {
|
|
386
386
|
$emit: (eventName: string, ...args: any[]) => void;
|
|
387
387
|
$off: (eventName?: string, handler?: HeadlessUniEventHandler) => void;
|
|
388
388
|
$on: (eventName: string, handler: HeadlessUniEventHandler) => void;
|
|
389
389
|
$once: (eventName: string, handler: HeadlessUniEventHandler) => void;
|
|
390
390
|
}
|
|
391
|
-
declare function createHeadlessUniEventBus(): HeadlessUniEventBus;
|
|
391
|
+
export declare function createHeadlessUniEventBus(): HeadlessUniEventBus;
|
|
392
392
|
//#endregion
|
|
393
393
|
//#region src/host/wx/fileSystem.d.ts
|
|
394
|
-
interface HeadlessWxFileSystemResult {
|
|
394
|
+
export interface HeadlessWxFileSystemResult {
|
|
395
395
|
errMsg: string;
|
|
396
396
|
}
|
|
397
|
-
interface HeadlessWxReadFileSuccessResult {
|
|
397
|
+
export interface HeadlessWxReadFileSuccessResult {
|
|
398
398
|
data: string;
|
|
399
399
|
errMsg: string;
|
|
400
400
|
}
|
|
401
|
-
interface HeadlessWxReadFileOption extends HeadlessWxCallbackOption<HeadlessWxReadFileSuccessResult> {
|
|
401
|
+
export interface HeadlessWxReadFileOption extends HeadlessWxCallbackOption<HeadlessWxReadFileSuccessResult> {
|
|
402
402
|
encoding?: string;
|
|
403
403
|
filePath: string;
|
|
404
404
|
}
|
|
405
|
-
interface HeadlessWxWriteFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
405
|
+
export interface HeadlessWxWriteFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
406
406
|
data: string;
|
|
407
407
|
encoding?: string;
|
|
408
408
|
filePath: string;
|
|
409
409
|
}
|
|
410
|
-
interface HeadlessWxAccessFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
410
|
+
export interface HeadlessWxAccessFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
411
411
|
path: string;
|
|
412
412
|
}
|
|
413
|
-
interface HeadlessWxAppendFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
413
|
+
export interface HeadlessWxAppendFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
414
414
|
data: string;
|
|
415
415
|
encoding?: string;
|
|
416
416
|
filePath: string;
|
|
417
417
|
}
|
|
418
|
-
interface HeadlessWxUnlinkOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
418
|
+
export interface HeadlessWxUnlinkOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
419
419
|
filePath: string;
|
|
420
420
|
}
|
|
421
|
-
interface HeadlessWxCopyFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
421
|
+
export interface HeadlessWxCopyFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
422
422
|
destPath: string;
|
|
423
423
|
srcPath: string;
|
|
424
424
|
}
|
|
425
|
-
interface HeadlessWxRenameOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
425
|
+
export interface HeadlessWxRenameOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
426
426
|
newPath: string;
|
|
427
427
|
oldPath: string;
|
|
428
428
|
}
|
|
429
|
-
interface HeadlessWxMkdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
429
|
+
export interface HeadlessWxMkdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
430
430
|
dirPath: string;
|
|
431
431
|
recursive?: boolean;
|
|
432
432
|
}
|
|
433
|
-
interface HeadlessWxRmdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
433
|
+
export interface HeadlessWxRmdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
434
434
|
dirPath: string;
|
|
435
435
|
recursive?: boolean;
|
|
436
436
|
}
|
|
437
|
-
interface HeadlessWxReadDirSuccessResult {
|
|
437
|
+
export interface HeadlessWxReadDirSuccessResult {
|
|
438
438
|
errMsg: string;
|
|
439
439
|
files: string[];
|
|
440
440
|
}
|
|
441
|
-
interface HeadlessWxReadDirOption extends HeadlessWxCallbackOption<HeadlessWxReadDirSuccessResult> {
|
|
441
|
+
export interface HeadlessWxReadDirOption extends HeadlessWxCallbackOption<HeadlessWxReadDirSuccessResult> {
|
|
442
442
|
dirPath: string;
|
|
443
443
|
}
|
|
444
|
-
interface HeadlessWxStats {
|
|
444
|
+
export interface HeadlessWxStats {
|
|
445
445
|
isDirectory: () => boolean;
|
|
446
446
|
isFile: () => boolean;
|
|
447
447
|
size: number;
|
|
448
448
|
}
|
|
449
|
-
interface HeadlessWxStatSuccessResult {
|
|
449
|
+
export interface HeadlessWxStatSuccessResult {
|
|
450
450
|
errMsg: string;
|
|
451
451
|
stats: HeadlessWxStats;
|
|
452
452
|
}
|
|
453
|
-
interface HeadlessWxStatOption extends HeadlessWxCallbackOption<HeadlessWxStatSuccessResult> {
|
|
453
|
+
export interface HeadlessWxStatOption extends HeadlessWxCallbackOption<HeadlessWxStatSuccessResult> {
|
|
454
454
|
path: string;
|
|
455
455
|
}
|
|
456
|
-
interface HeadlessWxFileSystemManager {
|
|
456
|
+
export interface HeadlessWxFileSystemManager {
|
|
457
457
|
access: (option: HeadlessWxAccessFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
458
458
|
accessSync: (path: string) => void;
|
|
459
459
|
appendFile: (option: HeadlessWxAppendFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
@@ -479,7 +479,7 @@ interface HeadlessWxFileSystemManager {
|
|
|
479
479
|
}
|
|
480
480
|
//#endregion
|
|
481
481
|
//#region src/host/wx/media.d.ts
|
|
482
|
-
interface HeadlessWxGetImageInfoResult {
|
|
482
|
+
export interface HeadlessWxGetImageInfoResult {
|
|
483
483
|
errMsg: string;
|
|
484
484
|
height: number;
|
|
485
485
|
orientation: 'up';
|
|
@@ -487,27 +487,27 @@ interface HeadlessWxGetImageInfoResult {
|
|
|
487
487
|
type: string;
|
|
488
488
|
width: number;
|
|
489
489
|
}
|
|
490
|
-
interface HeadlessWxGetImageInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetImageInfoResult> {
|
|
490
|
+
export interface HeadlessWxGetImageInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetImageInfoResult> {
|
|
491
491
|
src: string;
|
|
492
492
|
}
|
|
493
|
-
interface HeadlessWxGetFileInfoResult {
|
|
493
|
+
export interface HeadlessWxGetFileInfoResult {
|
|
494
494
|
digest: string;
|
|
495
495
|
errMsg: string;
|
|
496
496
|
size: number;
|
|
497
497
|
}
|
|
498
|
-
interface HeadlessWxGetFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetFileInfoResult> {
|
|
498
|
+
export interface HeadlessWxGetFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetFileInfoResult> {
|
|
499
499
|
digestAlgorithm?: 'md5' | 'sha1';
|
|
500
500
|
filePath: string;
|
|
501
501
|
}
|
|
502
|
-
interface HeadlessWxOpenDocumentResult {
|
|
502
|
+
export interface HeadlessWxOpenDocumentResult {
|
|
503
503
|
errMsg: string;
|
|
504
504
|
}
|
|
505
|
-
interface HeadlessWxOpenDocumentOption extends HeadlessWxCallbackOption<HeadlessWxOpenDocumentResult> {
|
|
505
|
+
export interface HeadlessWxOpenDocumentOption extends HeadlessWxCallbackOption<HeadlessWxOpenDocumentResult> {
|
|
506
506
|
filePath: string;
|
|
507
507
|
fileType?: string;
|
|
508
508
|
showMenu?: boolean;
|
|
509
509
|
}
|
|
510
|
-
interface HeadlessWxGetVideoInfoResult {
|
|
510
|
+
export interface HeadlessWxGetVideoInfoResult {
|
|
511
511
|
bitrate: number;
|
|
512
512
|
duration: number;
|
|
513
513
|
errMsg: string;
|
|
@@ -518,37 +518,37 @@ interface HeadlessWxGetVideoInfoResult {
|
|
|
518
518
|
type: string;
|
|
519
519
|
width: number;
|
|
520
520
|
}
|
|
521
|
-
interface HeadlessWxGetVideoInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetVideoInfoResult> {
|
|
521
|
+
export interface HeadlessWxGetVideoInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetVideoInfoResult> {
|
|
522
522
|
src: string;
|
|
523
523
|
}
|
|
524
|
-
interface HeadlessWxRemoveStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
524
|
+
export interface HeadlessWxRemoveStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
525
525
|
key: string;
|
|
526
526
|
}
|
|
527
|
-
interface HeadlessWxClearStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {}
|
|
528
|
-
interface HeadlessWxHideLoadingOption extends HeadlessWxCallbackOption<{
|
|
527
|
+
export interface HeadlessWxClearStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {}
|
|
528
|
+
export interface HeadlessWxHideLoadingOption extends HeadlessWxCallbackOption<{
|
|
529
529
|
errMsg: string;
|
|
530
530
|
}> {}
|
|
531
|
-
interface HeadlessWxStartPullDownRefreshOption extends HeadlessWxCallbackOption<{
|
|
531
|
+
export interface HeadlessWxStartPullDownRefreshOption extends HeadlessWxCallbackOption<{
|
|
532
532
|
errMsg: string;
|
|
533
533
|
}> {}
|
|
534
|
-
interface HeadlessWxSetBackgroundTextStyleOption extends HeadlessWxCallbackOption<{
|
|
534
|
+
export interface HeadlessWxSetBackgroundTextStyleOption extends HeadlessWxCallbackOption<{
|
|
535
535
|
errMsg: string;
|
|
536
536
|
}> {
|
|
537
537
|
textStyle: string;
|
|
538
538
|
}
|
|
539
|
-
interface HeadlessWxSetBackgroundColorOption extends HeadlessWxCallbackOption<{
|
|
539
|
+
export interface HeadlessWxSetBackgroundColorOption extends HeadlessWxCallbackOption<{
|
|
540
540
|
errMsg: string;
|
|
541
541
|
}> {
|
|
542
542
|
backgroundColor?: string;
|
|
543
543
|
backgroundColorBottom?: string;
|
|
544
544
|
backgroundColorTop?: string;
|
|
545
545
|
}
|
|
546
|
-
interface HeadlessWxSetNavigationBarTitleOption extends HeadlessWxCallbackOption<{
|
|
546
|
+
export interface HeadlessWxSetNavigationBarTitleOption extends HeadlessWxCallbackOption<{
|
|
547
547
|
errMsg: string;
|
|
548
548
|
}> {
|
|
549
549
|
title: string;
|
|
550
550
|
}
|
|
551
|
-
interface HeadlessWxSetNavigationBarColorOption extends HeadlessWxCallbackOption<{
|
|
551
|
+
export interface HeadlessWxSetNavigationBarColorOption extends HeadlessWxCallbackOption<{
|
|
552
552
|
errMsg: string;
|
|
553
553
|
}> {
|
|
554
554
|
animation?: {
|
|
@@ -558,43 +558,43 @@ interface HeadlessWxSetNavigationBarColorOption extends HeadlessWxCallbackOption
|
|
|
558
558
|
backgroundColor?: string;
|
|
559
559
|
frontColor?: string;
|
|
560
560
|
}
|
|
561
|
-
interface HeadlessWxShowNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
561
|
+
export interface HeadlessWxShowNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
562
562
|
errMsg: string;
|
|
563
563
|
}> {}
|
|
564
|
-
interface HeadlessWxHideNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
564
|
+
export interface HeadlessWxHideNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
565
565
|
errMsg: string;
|
|
566
566
|
}> {}
|
|
567
|
-
interface HeadlessWxShareMenuOption extends HeadlessWxCallbackOption<{
|
|
567
|
+
export interface HeadlessWxShareMenuOption extends HeadlessWxCallbackOption<{
|
|
568
568
|
errMsg: string;
|
|
569
569
|
}> {
|
|
570
570
|
isUpdatableMessage?: boolean;
|
|
571
571
|
menus?: string[];
|
|
572
572
|
withShareTicket?: boolean;
|
|
573
573
|
}
|
|
574
|
-
interface HeadlessWxTabBarOption extends HeadlessWxCallbackOption<{
|
|
574
|
+
export interface HeadlessWxTabBarOption extends HeadlessWxCallbackOption<{
|
|
575
575
|
errMsg: string;
|
|
576
576
|
}> {}
|
|
577
|
-
interface HeadlessWxTabBarItemOption extends HeadlessWxCallbackOption<{
|
|
577
|
+
export interface HeadlessWxTabBarItemOption extends HeadlessWxCallbackOption<{
|
|
578
578
|
errMsg: string;
|
|
579
579
|
}> {
|
|
580
580
|
index: number;
|
|
581
581
|
}
|
|
582
|
-
interface HeadlessWxSetTabBarBadgeOption extends HeadlessWxTabBarItemOption {
|
|
582
|
+
export interface HeadlessWxSetTabBarBadgeOption extends HeadlessWxTabBarItemOption {
|
|
583
583
|
text: string;
|
|
584
584
|
}
|
|
585
|
-
interface HeadlessWxShowActionSheetResult {
|
|
585
|
+
export interface HeadlessWxShowActionSheetResult {
|
|
586
586
|
errMsg: string;
|
|
587
587
|
tapIndex: number;
|
|
588
588
|
}
|
|
589
|
-
interface HeadlessWxShowActionSheetOption extends HeadlessWxCallbackOption<HeadlessWxShowActionSheetResult> {
|
|
589
|
+
export interface HeadlessWxShowActionSheetOption extends HeadlessWxCallbackOption<HeadlessWxShowActionSheetResult> {
|
|
590
590
|
itemList: string[];
|
|
591
591
|
}
|
|
592
|
-
interface HeadlessWxShowModalResult {
|
|
592
|
+
export interface HeadlessWxShowModalResult {
|
|
593
593
|
cancel: boolean;
|
|
594
594
|
confirm: boolean;
|
|
595
595
|
errMsg: string;
|
|
596
596
|
}
|
|
597
|
-
interface HeadlessWxShowModalOption extends HeadlessWxCallbackOption<HeadlessWxShowModalResult> {
|
|
597
|
+
export interface HeadlessWxShowModalOption extends HeadlessWxCallbackOption<HeadlessWxShowModalResult> {
|
|
598
598
|
cancelColor?: string;
|
|
599
599
|
cancelText?: string;
|
|
600
600
|
confirmColor?: string;
|
|
@@ -603,7 +603,7 @@ interface HeadlessWxShowModalOption extends HeadlessWxCallbackOption<HeadlessWxS
|
|
|
603
603
|
showCancel?: boolean;
|
|
604
604
|
title?: string;
|
|
605
605
|
}
|
|
606
|
-
interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
|
|
606
|
+
export interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
|
|
607
607
|
errMsg: string;
|
|
608
608
|
}> {
|
|
609
609
|
duration?: number;
|
|
@@ -611,44 +611,44 @@ interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
|
|
|
611
611
|
mask?: boolean;
|
|
612
612
|
title: string;
|
|
613
613
|
}
|
|
614
|
-
interface HeadlessWxShowLoadingOption extends HeadlessWxCallbackOption<{
|
|
614
|
+
export interface HeadlessWxShowLoadingOption extends HeadlessWxCallbackOption<{
|
|
615
615
|
errMsg: string;
|
|
616
616
|
}> {
|
|
617
617
|
mask?: boolean;
|
|
618
618
|
title: string;
|
|
619
619
|
}
|
|
620
|
-
interface HeadlessWxRequestSuccessResult {
|
|
620
|
+
export interface HeadlessWxRequestSuccessResult {
|
|
621
621
|
cookies: string[];
|
|
622
622
|
data: unknown;
|
|
623
623
|
errMsg: string;
|
|
624
624
|
header: Record<string, string>;
|
|
625
625
|
statusCode: number;
|
|
626
626
|
}
|
|
627
|
-
interface HeadlessWxRequestOption extends HeadlessWxCallbackOption<HeadlessWxRequestSuccessResult> {
|
|
627
|
+
export interface HeadlessWxRequestOption extends HeadlessWxCallbackOption<HeadlessWxRequestSuccessResult> {
|
|
628
628
|
data?: unknown;
|
|
629
629
|
header?: Record<string, string>;
|
|
630
630
|
method?: string;
|
|
631
631
|
url: string;
|
|
632
632
|
}
|
|
633
|
-
interface HeadlessWxRequestTask {
|
|
633
|
+
export interface HeadlessWxRequestTask {
|
|
634
634
|
abort: () => void;
|
|
635
635
|
}
|
|
636
|
-
interface HeadlessWxDownloadFileSuccessResult {
|
|
636
|
+
export interface HeadlessWxDownloadFileSuccessResult {
|
|
637
637
|
errMsg: string;
|
|
638
638
|
statusCode: number;
|
|
639
639
|
tempFilePath: string;
|
|
640
640
|
}
|
|
641
|
-
interface HeadlessWxDownloadFileOption extends HeadlessWxCallbackOption<HeadlessWxDownloadFileSuccessResult> {
|
|
641
|
+
export interface HeadlessWxDownloadFileOption extends HeadlessWxCallbackOption<HeadlessWxDownloadFileSuccessResult> {
|
|
642
642
|
filePath?: string;
|
|
643
643
|
header?: Record<string, string>;
|
|
644
644
|
url: string;
|
|
645
645
|
}
|
|
646
|
-
interface HeadlessWxUploadFileSuccessResult {
|
|
646
|
+
export interface HeadlessWxUploadFileSuccessResult {
|
|
647
647
|
data: string;
|
|
648
648
|
errMsg: string;
|
|
649
649
|
statusCode: number;
|
|
650
650
|
}
|
|
651
|
-
interface HeadlessWxUploadFileOption extends HeadlessWxCallbackOption<HeadlessWxUploadFileSuccessResult> {
|
|
651
|
+
export interface HeadlessWxUploadFileOption extends HeadlessWxCallbackOption<HeadlessWxUploadFileSuccessResult> {
|
|
652
652
|
fileName?: string;
|
|
653
653
|
filePath: string;
|
|
654
654
|
formData?: Record<string, unknown>;
|
|
@@ -656,19 +656,19 @@ interface HeadlessWxUploadFileOption extends HeadlessWxCallbackOption<HeadlessWx
|
|
|
656
656
|
name: string;
|
|
657
657
|
url: string;
|
|
658
658
|
}
|
|
659
|
-
interface HeadlessWxSaveFileSuccessResult {
|
|
659
|
+
export interface HeadlessWxSaveFileSuccessResult {
|
|
660
660
|
errMsg: string;
|
|
661
661
|
savedFilePath: string;
|
|
662
662
|
}
|
|
663
|
-
interface HeadlessWxSaveFileOption extends HeadlessWxCallbackOption<HeadlessWxSaveFileSuccessResult> {
|
|
663
|
+
export interface HeadlessWxSaveFileOption extends HeadlessWxCallbackOption<HeadlessWxSaveFileSuccessResult> {
|
|
664
664
|
filePath?: string;
|
|
665
665
|
tempFilePath: string;
|
|
666
666
|
}
|
|
667
|
-
interface HeadlessWxCanvasToTempFilePathSuccessResult {
|
|
667
|
+
export interface HeadlessWxCanvasToTempFilePathSuccessResult {
|
|
668
668
|
errMsg: string;
|
|
669
669
|
tempFilePath: string;
|
|
670
670
|
}
|
|
671
|
-
interface HeadlessWxCanvasToTempFilePathOption extends HeadlessWxCallbackOption<HeadlessWxCanvasToTempFilePathSuccessResult> {
|
|
671
|
+
export interface HeadlessWxCanvasToTempFilePathOption extends HeadlessWxCallbackOption<HeadlessWxCanvasToTempFilePathSuccessResult> {
|
|
672
672
|
canvasId: string;
|
|
673
673
|
component?: Record<string, any>;
|
|
674
674
|
destHeight?: number;
|
|
@@ -680,66 +680,66 @@ interface HeadlessWxCanvasToTempFilePathOption extends HeadlessWxCallbackOption<
|
|
|
680
680
|
x?: number;
|
|
681
681
|
y?: number;
|
|
682
682
|
}
|
|
683
|
-
interface HeadlessWxSaveImageToPhotosAlbumResult {
|
|
683
|
+
export interface HeadlessWxSaveImageToPhotosAlbumResult {
|
|
684
684
|
errMsg: string;
|
|
685
685
|
}
|
|
686
|
-
interface HeadlessWxSaveImageToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveImageToPhotosAlbumResult> {
|
|
686
|
+
export interface HeadlessWxSaveImageToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveImageToPhotosAlbumResult> {
|
|
687
687
|
filePath: string;
|
|
688
688
|
}
|
|
689
|
-
interface HeadlessWxSaveVideoToPhotosAlbumResult {
|
|
689
|
+
export interface HeadlessWxSaveVideoToPhotosAlbumResult {
|
|
690
690
|
errMsg: string;
|
|
691
691
|
}
|
|
692
|
-
interface HeadlessWxSaveVideoToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveVideoToPhotosAlbumResult> {
|
|
692
|
+
export interface HeadlessWxSaveVideoToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveVideoToPhotosAlbumResult> {
|
|
693
693
|
filePath: string;
|
|
694
694
|
}
|
|
695
|
-
interface HeadlessWxPreviewImageResult {
|
|
695
|
+
export interface HeadlessWxPreviewImageResult {
|
|
696
696
|
errMsg: string;
|
|
697
697
|
}
|
|
698
|
-
interface HeadlessWxPreviewImageOption extends HeadlessWxCallbackOption<HeadlessWxPreviewImageResult> {
|
|
698
|
+
export interface HeadlessWxPreviewImageOption extends HeadlessWxCallbackOption<HeadlessWxPreviewImageResult> {
|
|
699
699
|
current?: string;
|
|
700
700
|
urls: string[];
|
|
701
701
|
}
|
|
702
|
-
interface HeadlessWxChooseImageTempFile {
|
|
702
|
+
export interface HeadlessWxChooseImageTempFile {
|
|
703
703
|
path: string;
|
|
704
704
|
size: number;
|
|
705
705
|
}
|
|
706
|
-
interface HeadlessWxChooseImageResult {
|
|
706
|
+
export interface HeadlessWxChooseImageResult {
|
|
707
707
|
errMsg: string;
|
|
708
708
|
tempFilePaths: string[];
|
|
709
709
|
tempFiles: HeadlessWxChooseImageTempFile[];
|
|
710
710
|
}
|
|
711
|
-
interface HeadlessWxChooseImageOption extends HeadlessWxCallbackOption<HeadlessWxChooseImageResult> {
|
|
711
|
+
export interface HeadlessWxChooseImageOption extends HeadlessWxCallbackOption<HeadlessWxChooseImageResult> {
|
|
712
712
|
count?: number;
|
|
713
713
|
sizeType?: string[];
|
|
714
714
|
sourceType?: string[];
|
|
715
715
|
}
|
|
716
|
-
interface HeadlessWxChooseMessageFileTempFile {
|
|
716
|
+
export interface HeadlessWxChooseMessageFileTempFile {
|
|
717
717
|
name: string;
|
|
718
718
|
path: string;
|
|
719
719
|
size: number;
|
|
720
720
|
time: number;
|
|
721
721
|
type: string;
|
|
722
722
|
}
|
|
723
|
-
interface HeadlessWxChooseMessageFileResult {
|
|
723
|
+
export interface HeadlessWxChooseMessageFileResult {
|
|
724
724
|
errMsg: string;
|
|
725
725
|
tempFiles: HeadlessWxChooseMessageFileTempFile[];
|
|
726
726
|
}
|
|
727
|
-
interface HeadlessWxChooseMessageFileOption extends HeadlessWxCallbackOption<HeadlessWxChooseMessageFileResult> {
|
|
727
|
+
export interface HeadlessWxChooseMessageFileOption extends HeadlessWxCallbackOption<HeadlessWxChooseMessageFileResult> {
|
|
728
728
|
count?: number;
|
|
729
729
|
extension?: string[];
|
|
730
730
|
type?: 'all' | 'file' | 'image' | 'video';
|
|
731
731
|
}
|
|
732
|
-
interface HeadlessWxCompressImageResult {
|
|
732
|
+
export interface HeadlessWxCompressImageResult {
|
|
733
733
|
errMsg: string;
|
|
734
734
|
tempFilePath: string;
|
|
735
735
|
}
|
|
736
|
-
interface HeadlessWxCompressImageOption extends HeadlessWxCallbackOption<HeadlessWxCompressImageResult> {
|
|
736
|
+
export interface HeadlessWxCompressImageOption extends HeadlessWxCallbackOption<HeadlessWxCompressImageResult> {
|
|
737
737
|
compressedHeight?: number;
|
|
738
738
|
compressedWidth?: number;
|
|
739
739
|
quality?: number;
|
|
740
740
|
src: string;
|
|
741
741
|
}
|
|
742
|
-
interface HeadlessWxChooseVideoResult {
|
|
742
|
+
export interface HeadlessWxChooseVideoResult {
|
|
743
743
|
duration: number;
|
|
744
744
|
errMsg: string;
|
|
745
745
|
height: number;
|
|
@@ -747,13 +747,13 @@ interface HeadlessWxChooseVideoResult {
|
|
|
747
747
|
tempFilePath: string;
|
|
748
748
|
width: number;
|
|
749
749
|
}
|
|
750
|
-
interface HeadlessWxChooseVideoOption extends HeadlessWxCallbackOption<HeadlessWxChooseVideoResult> {
|
|
750
|
+
export interface HeadlessWxChooseVideoOption extends HeadlessWxCallbackOption<HeadlessWxChooseVideoResult> {
|
|
751
751
|
camera?: string[];
|
|
752
752
|
compressed?: boolean;
|
|
753
753
|
maxDuration?: number;
|
|
754
754
|
sourceType?: string[];
|
|
755
755
|
}
|
|
756
|
-
interface HeadlessWxChooseMediaTempFile {
|
|
756
|
+
export interface HeadlessWxChooseMediaTempFile {
|
|
757
757
|
duration?: number;
|
|
758
758
|
fileType: 'image' | 'video';
|
|
759
759
|
height: number;
|
|
@@ -762,12 +762,12 @@ interface HeadlessWxChooseMediaTempFile {
|
|
|
762
762
|
thumbTempFilePath?: string;
|
|
763
763
|
width: number;
|
|
764
764
|
}
|
|
765
|
-
interface HeadlessWxChooseMediaResult {
|
|
765
|
+
export interface HeadlessWxChooseMediaResult {
|
|
766
766
|
errMsg: string;
|
|
767
767
|
tempFiles: HeadlessWxChooseMediaTempFile[];
|
|
768
768
|
type: 'image' | 'mix' | 'video';
|
|
769
769
|
}
|
|
770
|
-
interface HeadlessWxChooseMediaOption extends HeadlessWxCallbackOption<HeadlessWxChooseMediaResult> {
|
|
770
|
+
export interface HeadlessWxChooseMediaOption extends HeadlessWxCallbackOption<HeadlessWxChooseMediaResult> {
|
|
771
771
|
camera?: string[];
|
|
772
772
|
count?: number;
|
|
773
773
|
maxDuration?: number;
|
|
@@ -775,30 +775,30 @@ interface HeadlessWxChooseMediaOption extends HeadlessWxCallbackOption<HeadlessW
|
|
|
775
775
|
sizeType?: string[];
|
|
776
776
|
sourceType?: string[];
|
|
777
777
|
}
|
|
778
|
-
interface HeadlessWxSavedFileInfo {
|
|
778
|
+
export interface HeadlessWxSavedFileInfo {
|
|
779
779
|
createTime: number;
|
|
780
780
|
filePath: string;
|
|
781
781
|
size: number;
|
|
782
782
|
}
|
|
783
|
-
interface HeadlessWxGetSavedFileListSuccessResult {
|
|
783
|
+
export interface HeadlessWxGetSavedFileListSuccessResult {
|
|
784
784
|
errMsg: string;
|
|
785
785
|
fileList: HeadlessWxSavedFileInfo[];
|
|
786
786
|
}
|
|
787
|
-
interface HeadlessWxGetSavedFileListOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileListSuccessResult> {}
|
|
788
|
-
interface HeadlessWxGetSavedFileInfoSuccessResult {
|
|
787
|
+
export interface HeadlessWxGetSavedFileListOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileListSuccessResult> {}
|
|
788
|
+
export interface HeadlessWxGetSavedFileInfoSuccessResult {
|
|
789
789
|
createTime: number;
|
|
790
790
|
errMsg: string;
|
|
791
791
|
size: number;
|
|
792
792
|
}
|
|
793
|
-
interface HeadlessWxGetSavedFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileInfoSuccessResult> {
|
|
793
|
+
export interface HeadlessWxGetSavedFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileInfoSuccessResult> {
|
|
794
794
|
filePath: string;
|
|
795
795
|
}
|
|
796
|
-
interface HeadlessWxRemoveSavedFileOption extends HeadlessWxCallbackOption<{
|
|
796
|
+
export interface HeadlessWxRemoveSavedFileOption extends HeadlessWxCallbackOption<{
|
|
797
797
|
errMsg: string;
|
|
798
798
|
}> {
|
|
799
799
|
filePath: string;
|
|
800
800
|
}
|
|
801
|
-
interface HeadlessWxDriverCapabilities {
|
|
801
|
+
export interface HeadlessWxDriverCapabilities {
|
|
802
802
|
clearStorageSync: () => void;
|
|
803
803
|
createAnimation: (option?: HeadlessWxAnimationStepOption) => HeadlessWxAnimation;
|
|
804
804
|
createCanvasContext: (canvasId: string, scope?: Record<string, any>) => HeadlessWxCanvasContext;
|
|
@@ -894,7 +894,7 @@ interface HeadlessWxDriverCapabilities {
|
|
|
894
894
|
}
|
|
895
895
|
//#endregion
|
|
896
896
|
//#region src/host/wx/api.d.ts
|
|
897
|
-
interface HeadlessWxDriver extends HeadlessWxDriverCapabilities {
|
|
897
|
+
export interface HeadlessWxDriver extends HeadlessWxDriverCapabilities {
|
|
898
898
|
chooseImage: (option: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult;
|
|
899
899
|
chooseMessageFile: (option: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult;
|
|
900
900
|
chooseMedia: (option: HeadlessWxChooseMediaOption) => HeadlessWxChooseMediaResult;
|
|
@@ -920,7 +920,7 @@ interface HeadlessWxDriver extends HeadlessWxDriverCapabilities {
|
|
|
920
920
|
canvasToTempFilePath: (option: HeadlessWxCanvasToTempFilePathOption) => HeadlessWxCanvasToTempFilePathSuccessResult;
|
|
921
921
|
uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
|
|
922
922
|
}
|
|
923
|
-
interface HeadlessWx extends HeadlessUniEventBus {
|
|
923
|
+
export interface HeadlessWx extends HeadlessUniEventBus {
|
|
924
924
|
canIUse: (schema: string) => boolean;
|
|
925
925
|
chooseImage: (option?: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult | undefined;
|
|
926
926
|
chooseMessageFile: (option?: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult | undefined;
|
|
@@ -1055,29 +1055,29 @@ interface HeadlessWx extends HeadlessUniEventBus {
|
|
|
1055
1055
|
}
|
|
1056
1056
|
//#endregion
|
|
1057
1057
|
//#region src/host/wx/index.d.ts
|
|
1058
|
-
declare function createHeadlessWx(driver: HeadlessWxDriver): HeadlessWx;
|
|
1058
|
+
export declare function createHeadlessWx(driver: HeadlessWxDriver): HeadlessWx;
|
|
1059
1059
|
//#endregion
|
|
1060
1060
|
//#region src/kernel/artifactSource.d.ts
|
|
1061
|
-
interface ArtifactSource {
|
|
1061
|
+
export interface ArtifactSource {
|
|
1062
1062
|
has: (filePath: string) => boolean;
|
|
1063
1063
|
readText: (filePath: string) => string | undefined;
|
|
1064
1064
|
}
|
|
1065
|
-
declare function createFileSystemArtifactSource(): ArtifactSource;
|
|
1066
|
-
declare function createMemoryArtifactSource(entries: Iterable<[string, string]>): ArtifactSource;
|
|
1067
|
-
declare function createOverlayArtifactSource(overlay: ArtifactSource, fallback: ArtifactSource): ArtifactSource;
|
|
1065
|
+
export declare function createFileSystemArtifactSource(): ArtifactSource;
|
|
1066
|
+
export declare function createMemoryArtifactSource(entries: Iterable<[string, string]>): ArtifactSource;
|
|
1067
|
+
export declare function createOverlayArtifactSource(overlay: ArtifactSource, fallback: ArtifactSource): ArtifactSource;
|
|
1068
1068
|
//#endregion
|
|
1069
1069
|
//#region src/kernel/diagnostics.d.ts
|
|
1070
|
-
type RuntimeDiagnosticLevel = 'error' | 'exception' | 'warn';
|
|
1071
|
-
interface RuntimeDiagnosticEntry {
|
|
1070
|
+
export type RuntimeDiagnosticLevel = 'error' | 'exception' | 'warn';
|
|
1071
|
+
export interface RuntimeDiagnosticEntry {
|
|
1072
1072
|
args: unknown[];
|
|
1073
1073
|
level: RuntimeDiagnosticLevel;
|
|
1074
1074
|
timestamp: number;
|
|
1075
1075
|
}
|
|
1076
|
-
interface RuntimeConsoleEntry {
|
|
1076
|
+
export interface RuntimeConsoleEntry {
|
|
1077
1077
|
args: unknown[];
|
|
1078
1078
|
level: 'debug' | 'error' | 'info' | 'log' | 'warn';
|
|
1079
1079
|
}
|
|
1080
|
-
declare class RuntimeDiagnostics {
|
|
1080
|
+
export declare class RuntimeDiagnostics {
|
|
1081
1081
|
private readonly entries;
|
|
1082
1082
|
clear(): void;
|
|
1083
1083
|
getEntries(): {
|
|
@@ -1090,15 +1090,15 @@ declare class RuntimeDiagnostics {
|
|
|
1090
1090
|
}
|
|
1091
1091
|
//#endregion
|
|
1092
1092
|
//#region src/kernel/platform.d.ts
|
|
1093
|
-
interface PlatformAdapter {
|
|
1093
|
+
export interface PlatformAdapter {
|
|
1094
1094
|
readonly name: string;
|
|
1095
1095
|
}
|
|
1096
|
-
declare function wechat(): PlatformAdapter;
|
|
1096
|
+
export declare function wechat(): PlatformAdapter;
|
|
1097
1097
|
//#endregion
|
|
1098
1098
|
//#region src/kernel/scheduler.d.ts
|
|
1099
1099
|
type TimeoutHandle = ReturnType<typeof setTimeout>;
|
|
1100
1100
|
type IntervalHandle = ReturnType<typeof setInterval>;
|
|
1101
|
-
declare class RuntimeScheduler {
|
|
1101
|
+
export declare class RuntimeScheduler {
|
|
1102
1102
|
private readonly intervals;
|
|
1103
1103
|
private readonly timeouts;
|
|
1104
1104
|
private closed;
|
|
@@ -1113,7 +1113,7 @@ declare class RuntimeScheduler {
|
|
|
1113
1113
|
}
|
|
1114
1114
|
//#endregion
|
|
1115
1115
|
//#region src/kernel/runtimeKernel.d.ts
|
|
1116
|
-
declare class RuntimeKernel {
|
|
1116
|
+
export declare class RuntimeKernel {
|
|
1117
1117
|
readonly diagnostics: RuntimeDiagnostics;
|
|
1118
1118
|
readonly scheduler: RuntimeScheduler;
|
|
1119
1119
|
private closed;
|
|
@@ -1123,38 +1123,38 @@ declare class RuntimeKernel {
|
|
|
1123
1123
|
}
|
|
1124
1124
|
//#endregion
|
|
1125
1125
|
//#region src/project/plugins.d.ts
|
|
1126
|
-
declare const HEADLESS_PLUGIN_VIRTUAL_ROOT = "__plugins__";
|
|
1127
|
-
interface HeadlessPluginDescriptor {
|
|
1126
|
+
export declare const HEADLESS_PLUGIN_VIRTUAL_ROOT = "__plugins__";
|
|
1127
|
+
export interface HeadlessPluginDescriptor {
|
|
1128
1128
|
alias: string;
|
|
1129
1129
|
config: Record<string, any>;
|
|
1130
1130
|
provider: string;
|
|
1131
1131
|
rootPath: string;
|
|
1132
1132
|
virtualRoot: string;
|
|
1133
1133
|
}
|
|
1134
|
-
declare function createPluginVirtualRoot(alias: string): string;
|
|
1135
|
-
declare function resolvePluginRequest(plugins: HeadlessPluginDescriptor[], request: string, kind: 'page' | 'publicComponent'): {
|
|
1134
|
+
export declare function createPluginVirtualRoot(alias: string): string;
|
|
1135
|
+
export declare function resolvePluginRequest(plugins: HeadlessPluginDescriptor[], request: string, kind: 'page' | 'publicComponent'): {
|
|
1136
1136
|
plugin: HeadlessPluginDescriptor;
|
|
1137
1137
|
publicName: string;
|
|
1138
1138
|
resourcePath: string;
|
|
1139
1139
|
} | undefined;
|
|
1140
|
-
declare function createPluginArtifactSource(fallback: ArtifactSource, miniprogramRootPath: string, plugins: HeadlessPluginDescriptor[]): ArtifactSource;
|
|
1140
|
+
export declare function createPluginArtifactSource(fallback: ArtifactSource, miniprogramRootPath: string, plugins: HeadlessPluginDescriptor[]): ArtifactSource;
|
|
1141
1141
|
//#endregion
|
|
1142
1142
|
//#region src/project/resolveRoutes.d.ts
|
|
1143
|
-
interface HeadlessRouteRecord {
|
|
1143
|
+
export interface HeadlessRouteRecord {
|
|
1144
1144
|
kind: 'page';
|
|
1145
1145
|
route: string;
|
|
1146
1146
|
source: 'pages' | 'plugin' | 'subPackages';
|
|
1147
1147
|
resourcePath?: string;
|
|
1148
1148
|
subpackageRoot?: string;
|
|
1149
1149
|
}
|
|
1150
|
-
declare function resolveRoutesFromAppConfig(config: Record<string, any>, plugins?: HeadlessPluginDescriptor[]): HeadlessRouteRecord[];
|
|
1150
|
+
export declare function resolveRoutesFromAppConfig(config: Record<string, any>, plugins?: HeadlessPluginDescriptor[]): HeadlessRouteRecord[];
|
|
1151
1151
|
//#endregion
|
|
1152
1152
|
//#region src/project/createProjectDescriptor.d.ts
|
|
1153
|
-
interface HeadlessProjectConfigFile {
|
|
1153
|
+
export interface HeadlessProjectConfigFile {
|
|
1154
1154
|
filePath: string;
|
|
1155
1155
|
value: Record<string, any>;
|
|
1156
1156
|
}
|
|
1157
|
-
interface HeadlessProjectDescriptor {
|
|
1157
|
+
export interface HeadlessProjectDescriptor {
|
|
1158
1158
|
artifactSource: ArtifactSource;
|
|
1159
1159
|
appConfig: Record<string, any>;
|
|
1160
1160
|
appConfigPath: string;
|
|
@@ -1165,7 +1165,7 @@ interface HeadlessProjectDescriptor {
|
|
|
1165
1165
|
projectConfigFiles: HeadlessProjectConfigFile[];
|
|
1166
1166
|
routes: HeadlessRouteRecord[];
|
|
1167
1167
|
}
|
|
1168
|
-
interface CreateProjectDescriptorOptions {
|
|
1168
|
+
export interface CreateProjectDescriptorOptions {
|
|
1169
1169
|
artifactSource?: ArtifactSource;
|
|
1170
1170
|
appConfig: Record<string, any>;
|
|
1171
1171
|
appConfigPath: string;
|
|
@@ -1175,42 +1175,42 @@ interface CreateProjectDescriptorOptions {
|
|
|
1175
1175
|
projectPath: string;
|
|
1176
1176
|
projectConfigFiles?: HeadlessProjectConfigFile[];
|
|
1177
1177
|
}
|
|
1178
|
-
declare function createProjectDescriptor(options: CreateProjectDescriptorOptions): HeadlessProjectDescriptor;
|
|
1178
|
+
export declare function createProjectDescriptor(options: CreateProjectDescriptorOptions): HeadlessProjectDescriptor;
|
|
1179
1179
|
//#endregion
|
|
1180
1180
|
//#region src/project/createArtifactProject.d.ts
|
|
1181
|
-
interface CreateArtifactProjectOptions {
|
|
1181
|
+
export interface CreateArtifactProjectOptions {
|
|
1182
1182
|
appConfigPath?: string;
|
|
1183
1183
|
artifactSource?: ArtifactSource;
|
|
1184
1184
|
miniprogramRootPath: string;
|
|
1185
1185
|
projectPath?: string;
|
|
1186
1186
|
}
|
|
1187
|
-
declare function createArtifactProject(options: CreateArtifactProjectOptions): HeadlessProjectDescriptor;
|
|
1187
|
+
export declare function createArtifactProject(options: CreateArtifactProjectOptions): HeadlessProjectDescriptor;
|
|
1188
1188
|
//#endregion
|
|
1189
1189
|
//#region src/project/loadProject.d.ts
|
|
1190
|
-
declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
|
|
1190
|
+
export declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
|
|
1191
1191
|
//#endregion
|
|
1192
1192
|
//#region src/browser/virtualFiles.d.ts
|
|
1193
|
-
interface BrowserDirectoryFileLike {
|
|
1193
|
+
export interface BrowserDirectoryFileLike {
|
|
1194
1194
|
name: string;
|
|
1195
1195
|
text: () => Promise<string>;
|
|
1196
1196
|
webkitRelativePath?: string;
|
|
1197
1197
|
}
|
|
1198
|
-
type BrowserVirtualFiles = Map<string, string>;
|
|
1199
|
-
declare function normalizeBrowserFilePath(filePath: string): string;
|
|
1200
|
-
declare function createBrowserVirtualFiles(entries: Iterable<[string, string]>): BrowserVirtualFiles;
|
|
1201
|
-
declare function createBrowserVirtualFilesFromDirectory(files: BrowserDirectoryFileLike[]): Promise<BrowserVirtualFiles>;
|
|
1202
|
-
declare function readBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): string | undefined;
|
|
1203
|
-
declare function hasBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): boolean;
|
|
1198
|
+
export type BrowserVirtualFiles = Map<string, string>;
|
|
1199
|
+
export declare function normalizeBrowserFilePath(filePath: string): string;
|
|
1200
|
+
export declare function createBrowserVirtualFiles(entries: Iterable<[string, string]>): BrowserVirtualFiles;
|
|
1201
|
+
export declare function createBrowserVirtualFilesFromDirectory(files: BrowserDirectoryFileLike[]): Promise<BrowserVirtualFiles>;
|
|
1202
|
+
export declare function readBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): string | undefined;
|
|
1203
|
+
export declare function hasBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): boolean;
|
|
1204
1204
|
//#endregion
|
|
1205
1205
|
//#region src/browser/moduleLoader.d.ts
|
|
1206
|
-
interface BrowserModuleLoader {
|
|
1206
|
+
export interface BrowserModuleLoader {
|
|
1207
1207
|
close: () => void;
|
|
1208
1208
|
executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
|
|
1209
1209
|
executeAppModule: (filePath: string) => HeadlessAppDefinition;
|
|
1210
1210
|
executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
|
|
1211
1211
|
wx: HeadlessWx;
|
|
1212
1212
|
}
|
|
1213
|
-
declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0], options: {
|
|
1213
|
+
export declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0], options: {
|
|
1214
1214
|
globals?: Record<string, unknown>;
|
|
1215
1215
|
kernel: RuntimeKernel;
|
|
1216
1216
|
miniprogramRootPath: string;
|
|
@@ -1218,14 +1218,14 @@ declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registrie
|
|
|
1218
1218
|
}): BrowserModuleLoader;
|
|
1219
1219
|
//#endregion
|
|
1220
1220
|
//#region src/browser/project.d.ts
|
|
1221
|
-
interface CreateBrowserProjectOptions {
|
|
1221
|
+
export interface CreateBrowserProjectOptions {
|
|
1222
1222
|
appConfigPath?: string;
|
|
1223
1223
|
miniprogramRoot?: string;
|
|
1224
1224
|
miniprogramRootPath?: string;
|
|
1225
1225
|
plugins?: HeadlessPluginDescriptor[];
|
|
1226
1226
|
projectPath?: string;
|
|
1227
1227
|
}
|
|
1228
|
-
declare function createBrowserProject(files: BrowserVirtualFiles, options?: CreateBrowserProjectOptions): HeadlessProjectDescriptor;
|
|
1228
|
+
export declare function createBrowserProject(files: BrowserVirtualFiles, options?: CreateBrowserProjectOptions): HeadlessProjectDescriptor;
|
|
1229
1229
|
//#endregion
|
|
1230
1230
|
//#region src/project/pageConfig.d.ts
|
|
1231
1231
|
interface HeadlessNavigationBarSnapshot {
|
|
@@ -1247,7 +1247,7 @@ interface HeadlessBackgroundSnapshot {
|
|
|
1247
1247
|
}
|
|
1248
1248
|
//#endregion
|
|
1249
1249
|
//#region src/runtime/pageInstance.d.ts
|
|
1250
|
-
interface HeadlessPageInstance extends Record<string, any> {
|
|
1250
|
+
export interface HeadlessPageInstance extends Record<string, any> {
|
|
1251
1251
|
__background__?: HeadlessBackgroundSnapshot;
|
|
1252
1252
|
__backgroundTextStyle__?: HeadlessBackgroundTextStyle;
|
|
1253
1253
|
__lastChangedKeys__?: string[];
|
|
@@ -1264,7 +1264,7 @@ interface HeadlessPageInstance extends Record<string, any> {
|
|
|
1264
1264
|
selectComponent?: (selector: string) => any;
|
|
1265
1265
|
setData: (patch: Record<string, any>, callback?: () => void) => void;
|
|
1266
1266
|
}
|
|
1267
|
-
declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>, pageState?: {
|
|
1267
|
+
export declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>, pageState?: {
|
|
1268
1268
|
background?: HeadlessBackgroundSnapshot;
|
|
1269
1269
|
backgroundTextStyle?: HeadlessBackgroundTextStyle;
|
|
1270
1270
|
navigationBar?: HeadlessNavigationBarSnapshot;
|
|
@@ -1294,20 +1294,20 @@ interface CreateComponentInstanceOptions {
|
|
|
1294
1294
|
}
|
|
1295
1295
|
//#endregion
|
|
1296
1296
|
//#region src/runtime/componentInstance/observers.d.ts
|
|
1297
|
-
declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
|
|
1297
|
+
export declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
|
|
1298
1298
|
//#endregion
|
|
1299
1299
|
//#region src/runtime/componentInstance/properties.d.ts
|
|
1300
|
-
declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
|
|
1301
|
-
declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): any;
|
|
1300
|
+
export declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
|
|
1301
|
+
export declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): any;
|
|
1302
1302
|
//#endregion
|
|
1303
1303
|
//#region src/runtime/componentInstance/shared.d.ts
|
|
1304
|
-
declare function cloneValue<T>(value: T): T;
|
|
1305
|
-
declare function hasComponentPropertyValueChanged(currentValue: unknown, previousSnapshot: unknown, nextValue: unknown, bindingAffected: boolean): boolean;
|
|
1304
|
+
export declare function cloneValue<T>(value: T): T;
|
|
1305
|
+
export declare function hasComponentPropertyValueChanged(currentValue: unknown, previousSnapshot: unknown, nextValue: unknown, bindingAffected: boolean): boolean;
|
|
1306
1306
|
//#endregion
|
|
1307
1307
|
//#region src/runtime/componentInstance/index.d.ts
|
|
1308
|
-
declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
|
|
1309
|
-
declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
|
|
1310
|
-
declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
|
|
1308
|
+
export declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
|
|
1309
|
+
export declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
|
|
1310
|
+
export declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
|
|
1311
1311
|
//#endregion
|
|
1312
1312
|
//#region src/view/templateRuntime.d.ts
|
|
1313
1313
|
interface TemplateNodeLike {
|
|
@@ -1378,13 +1378,13 @@ interface BrowserRendererContext {
|
|
|
1378
1378
|
}
|
|
1379
1379
|
//#endregion
|
|
1380
1380
|
//#region src/browser/render/index.d.ts
|
|
1381
|
-
declare function renderBrowserPageTree(context: BrowserRendererContext, page: HeadlessPageInstance): BrowserRenderedPageTree;
|
|
1381
|
+
export declare function renderBrowserPageTree(context: BrowserRendererContext, page: HeadlessPageInstance): BrowserRenderedPageTree;
|
|
1382
1382
|
//#endregion
|
|
1383
1383
|
//#region src/runtime/appInstance.d.ts
|
|
1384
|
-
interface HeadlessAppInstance extends Record<string, any> {
|
|
1384
|
+
export interface HeadlessAppInstance extends Record<string, any> {
|
|
1385
1385
|
globalData: Record<string, any>;
|
|
1386
1386
|
}
|
|
1387
|
-
declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
|
|
1387
|
+
export declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
|
|
1388
1388
|
//#endregion
|
|
1389
1389
|
//#region src/runtime/moduleLoader.d.ts
|
|
1390
1390
|
interface HeadlessModuleLoader {
|
|
@@ -1452,53 +1452,53 @@ interface RuntimeRendererContext {
|
|
|
1452
1452
|
}
|
|
1453
1453
|
//#endregion
|
|
1454
1454
|
//#region src/runtime/render/index.d.ts
|
|
1455
|
-
declare function renderRuntimePageTree(context: RuntimeRendererContext, page: HeadlessPageInstance): RuntimeRenderedPageTree;
|
|
1455
|
+
export declare function renderRuntimePageTree(context: RuntimeRendererContext, page: HeadlessPageInstance): RuntimeRenderedPageTree;
|
|
1456
1456
|
//#endregion
|
|
1457
1457
|
//#region src/runtime/wxState.d.ts
|
|
1458
|
-
interface HeadlessWxLoadingSnapshot {
|
|
1458
|
+
export interface HeadlessWxLoadingSnapshot {
|
|
1459
1459
|
mask: boolean;
|
|
1460
1460
|
title: string;
|
|
1461
1461
|
}
|
|
1462
|
-
interface HeadlessWxToastSnapshot {
|
|
1462
|
+
export interface HeadlessWxToastSnapshot {
|
|
1463
1463
|
duration: number;
|
|
1464
1464
|
icon: string;
|
|
1465
1465
|
mask: boolean;
|
|
1466
1466
|
title: string;
|
|
1467
1467
|
}
|
|
1468
|
-
interface HeadlessWxPreviewImageSnapshot {
|
|
1468
|
+
export interface HeadlessWxPreviewImageSnapshot {
|
|
1469
1469
|
current: string;
|
|
1470
1470
|
urls: string[];
|
|
1471
1471
|
visible: boolean;
|
|
1472
1472
|
}
|
|
1473
|
-
interface HeadlessWxOpenDocumentSnapshot {
|
|
1473
|
+
export interface HeadlessWxOpenDocumentSnapshot {
|
|
1474
1474
|
filePath: string;
|
|
1475
1475
|
fileType: string;
|
|
1476
1476
|
showMenu: boolean;
|
|
1477
1477
|
visible: boolean;
|
|
1478
1478
|
}
|
|
1479
|
-
interface HeadlessWxNetworkSnapshot extends HeadlessWxNetworkStatusChangeResult {}
|
|
1480
|
-
interface HeadlessWxShareMenuSnapshot {
|
|
1479
|
+
export interface HeadlessWxNetworkSnapshot extends HeadlessWxNetworkStatusChangeResult {}
|
|
1480
|
+
export interface HeadlessWxShareMenuSnapshot {
|
|
1481
1481
|
isUpdatableMessage: boolean;
|
|
1482
1482
|
menus: string[];
|
|
1483
1483
|
visible: boolean;
|
|
1484
1484
|
withShareTicket: boolean;
|
|
1485
1485
|
}
|
|
1486
|
-
interface HeadlessWxClipboardSnapshot {
|
|
1486
|
+
export interface HeadlessWxClipboardSnapshot {
|
|
1487
1487
|
data: string;
|
|
1488
1488
|
}
|
|
1489
|
-
interface HeadlessWxActionSheetMockDefinition {
|
|
1489
|
+
export interface HeadlessWxActionSheetMockDefinition {
|
|
1490
1490
|
cancel?: boolean;
|
|
1491
1491
|
tapIndex?: number;
|
|
1492
1492
|
}
|
|
1493
|
-
interface HeadlessWxActionSheetLogEntry {
|
|
1493
|
+
export interface HeadlessWxActionSheetLogEntry {
|
|
1494
1494
|
itemList: string[];
|
|
1495
1495
|
result?: HeadlessWxShowActionSheetResult;
|
|
1496
1496
|
}
|
|
1497
|
-
interface HeadlessWxModalMockDefinition {
|
|
1497
|
+
export interface HeadlessWxModalMockDefinition {
|
|
1498
1498
|
cancel?: boolean;
|
|
1499
1499
|
confirm?: boolean;
|
|
1500
1500
|
}
|
|
1501
|
-
interface HeadlessWxModalLogEntry {
|
|
1501
|
+
export interface HeadlessWxModalLogEntry {
|
|
1502
1502
|
cancelColor: string;
|
|
1503
1503
|
cancelText: string;
|
|
1504
1504
|
confirmColor: string;
|
|
@@ -1508,7 +1508,7 @@ interface HeadlessWxModalLogEntry {
|
|
|
1508
1508
|
showCancel: boolean;
|
|
1509
1509
|
title: string;
|
|
1510
1510
|
}
|
|
1511
|
-
interface HeadlessWxRequestMockDefinition {
|
|
1511
|
+
export interface HeadlessWxRequestMockDefinition {
|
|
1512
1512
|
delay?: number;
|
|
1513
1513
|
header?: Record<string, string>;
|
|
1514
1514
|
method?: string;
|
|
@@ -1516,7 +1516,7 @@ interface HeadlessWxRequestMockDefinition {
|
|
|
1516
1516
|
statusCode?: number;
|
|
1517
1517
|
url: RegExp | string;
|
|
1518
1518
|
}
|
|
1519
|
-
interface HeadlessWxRequestLogEntry {
|
|
1519
|
+
export interface HeadlessWxRequestLogEntry {
|
|
1520
1520
|
data: unknown;
|
|
1521
1521
|
header: Record<string, string>;
|
|
1522
1522
|
matched: boolean;
|
|
@@ -1524,21 +1524,21 @@ interface HeadlessWxRequestLogEntry {
|
|
|
1524
1524
|
response?: HeadlessWxRequestSuccessResult;
|
|
1525
1525
|
url: string;
|
|
1526
1526
|
}
|
|
1527
|
-
interface HeadlessWxDownloadFileMockDefinition {
|
|
1527
|
+
export interface HeadlessWxDownloadFileMockDefinition {
|
|
1528
1528
|
delay?: number;
|
|
1529
1529
|
fileContent: string | ((option: HeadlessWxDownloadFileOption) => string);
|
|
1530
1530
|
header?: Record<string, string>;
|
|
1531
1531
|
statusCode?: number;
|
|
1532
1532
|
url: RegExp | string;
|
|
1533
1533
|
}
|
|
1534
|
-
interface HeadlessWxDownloadFileLogEntry {
|
|
1534
|
+
export interface HeadlessWxDownloadFileLogEntry {
|
|
1535
1535
|
header: Record<string, string>;
|
|
1536
1536
|
matched: boolean;
|
|
1537
1537
|
response?: HeadlessWxDownloadFileSuccessResult;
|
|
1538
1538
|
tempFilePath?: string;
|
|
1539
1539
|
url: string;
|
|
1540
1540
|
}
|
|
1541
|
-
interface HeadlessWxUploadFileMockDefinition {
|
|
1541
|
+
export interface HeadlessWxUploadFileMockDefinition {
|
|
1542
1542
|
delay?: number;
|
|
1543
1543
|
header?: Record<string, string>;
|
|
1544
1544
|
method?: string;
|
|
@@ -1548,7 +1548,7 @@ interface HeadlessWxUploadFileMockDefinition {
|
|
|
1548
1548
|
statusCode?: number;
|
|
1549
1549
|
url: RegExp | string;
|
|
1550
1550
|
}
|
|
1551
|
-
interface HeadlessWxUploadFileLogEntry {
|
|
1551
|
+
export interface HeadlessWxUploadFileLogEntry {
|
|
1552
1552
|
fileContent: string;
|
|
1553
1553
|
fileName?: string;
|
|
1554
1554
|
filePath: string;
|
|
@@ -1559,10 +1559,10 @@ interface HeadlessWxUploadFileLogEntry {
|
|
|
1559
1559
|
response?: HeadlessWxUploadFileSuccessResult;
|
|
1560
1560
|
url: string;
|
|
1561
1561
|
}
|
|
1562
|
-
interface HeadlessWxStateOptions {
|
|
1562
|
+
export interface HeadlessWxStateOptions {
|
|
1563
1563
|
strictMocks?: boolean;
|
|
1564
1564
|
}
|
|
1565
|
-
declare function createHeadlessWxState(scheduler?: Pick<RuntimeScheduler, 'clearTimeout' | 'setTimeout'>, options?: HeadlessWxStateOptions): {
|
|
1565
|
+
export declare function createHeadlessWxState(scheduler?: Pick<RuntimeScheduler, 'clearTimeout' | 'setTimeout'>, options?: HeadlessWxStateOptions): {
|
|
1566
1566
|
close(): void;
|
|
1567
1567
|
clearStorageSync(): void;
|
|
1568
1568
|
downloadFile(option: HeadlessWxDownloadFileOption): HeadlessWxRequestTask;
|
|
@@ -1835,13 +1835,13 @@ declare function createHeadlessWxState(scheduler?: Pick<RuntimeScheduler, 'clear
|
|
|
1835
1835
|
};
|
|
1836
1836
|
//#endregion
|
|
1837
1837
|
//#region src/runtime/session.d.ts
|
|
1838
|
-
interface HeadlessSessionOptions {
|
|
1838
|
+
export interface HeadlessSessionOptions {
|
|
1839
1839
|
globals?: Record<string, unknown>;
|
|
1840
1840
|
project?: HeadlessProjectDescriptor;
|
|
1841
1841
|
projectPath?: string;
|
|
1842
1842
|
strictHostMocks?: boolean;
|
|
1843
1843
|
}
|
|
1844
|
-
declare class HeadlessSession {
|
|
1844
|
+
export declare class HeadlessSession {
|
|
1845
1845
|
readonly project: HeadlessProjectDescriptor;
|
|
1846
1846
|
private readonly kernel;
|
|
1847
1847
|
private appDefinition;
|
|
@@ -2161,7 +2161,9 @@ declare class HeadlessSession {
|
|
|
2161
2161
|
navigateTo(url: string): HeadlessPageInstance;
|
|
2162
2162
|
redirectTo(url: string): HeadlessPageInstance;
|
|
2163
2163
|
navigateBack(delta?: number): HeadlessPageInstance | null;
|
|
2164
|
-
switchTab(url: string): HeadlessPageInstance;
|
|
2164
|
+
switchTab(url: string): HeadlessPageInstance | null;
|
|
2165
|
+
private prepareSwitchTab;
|
|
2166
|
+
private commitSwitchTab;
|
|
2165
2167
|
pageScrollTo(option: {
|
|
2166
2168
|
scrollTop?: number;
|
|
2167
2169
|
duration?: number;
|
|
@@ -2202,17 +2204,17 @@ declare class HeadlessSession {
|
|
|
2202
2204
|
private createIntersectionObserver;
|
|
2203
2205
|
private createMediaQueryObserver;
|
|
2204
2206
|
}
|
|
2205
|
-
declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
|
|
2207
|
+
export declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
|
|
2206
2208
|
//#endregion
|
|
2207
2209
|
//#region src/browser/session.d.ts
|
|
2208
|
-
interface BrowserHeadlessSessionOptions {
|
|
2210
|
+
export interface BrowserHeadlessSessionOptions {
|
|
2209
2211
|
files: BrowserVirtualFiles;
|
|
2210
2212
|
globals?: Record<string, unknown>;
|
|
2211
2213
|
onRender?: () => void;
|
|
2212
2214
|
project?: HeadlessProjectDescriptor;
|
|
2213
2215
|
strictHostMocks?: boolean;
|
|
2214
2216
|
}
|
|
2215
|
-
declare class BrowserHeadlessSession {
|
|
2217
|
+
export declare class BrowserHeadlessSession {
|
|
2216
2218
|
readonly files: BrowserVirtualFiles;
|
|
2217
2219
|
readonly project: HeadlessProjectDescriptor;
|
|
2218
2220
|
private appDefinition;
|
|
@@ -2542,7 +2544,9 @@ declare class BrowserHeadlessSession {
|
|
|
2542
2544
|
navigateTo(url: string): HeadlessPageInstance;
|
|
2543
2545
|
redirectTo(url: string): HeadlessPageInstance;
|
|
2544
2546
|
navigateBack(delta?: number): HeadlessPageInstance | null;
|
|
2545
|
-
switchTab(url: string): HeadlessPageInstance;
|
|
2547
|
+
switchTab(url: string): HeadlessPageInstance | null;
|
|
2548
|
+
private prepareSwitchTab;
|
|
2549
|
+
private commitSwitchTab;
|
|
2546
2550
|
pageScrollTo(option: {
|
|
2547
2551
|
duration?: number;
|
|
2548
2552
|
selector?: string;
|
|
@@ -2579,18 +2583,18 @@ declare class BrowserHeadlessSession {
|
|
|
2579
2583
|
private createIntersectionObserver;
|
|
2580
2584
|
private createMediaQueryObserver;
|
|
2581
2585
|
}
|
|
2582
|
-
declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
|
|
2586
|
+
export declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
|
|
2583
2587
|
//#endregion
|
|
2584
2588
|
//#region src/testing/pageWait.d.ts
|
|
2585
|
-
interface HeadlessTestingWaitOptions {
|
|
2589
|
+
export interface HeadlessTestingWaitOptions {
|
|
2586
2590
|
interval?: number;
|
|
2587
2591
|
timeout?: number;
|
|
2588
2592
|
}
|
|
2589
|
-
type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
|
|
2590
|
-
interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
|
|
2593
|
+
export type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
|
|
2594
|
+
export interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
|
|
2591
2595
|
state?: 'attached' | 'detached';
|
|
2592
2596
|
}
|
|
2593
|
-
interface HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle> {
|
|
2597
|
+
export interface HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle> {
|
|
2594
2598
|
data: (path?: string) => Promise<unknown>;
|
|
2595
2599
|
findOne: (selector: string) => Promise<NodeHandle | null>;
|
|
2596
2600
|
selectComponent: (selector: string) => Promise<ScopeHandle | null>;
|
|
@@ -2598,20 +2602,20 @@ interface HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle> {
|
|
|
2598
2602
|
waitFor: (ms?: number) => Promise<void>;
|
|
2599
2603
|
wxml: () => Promise<string>;
|
|
2600
2604
|
}
|
|
2601
|
-
declare function waitForPageSelector<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<NonNullable<Awaited<NodeHandle>> | null>;
|
|
2602
|
-
declare function waitForPageComponent<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitOptions): Promise<NonNullable<Awaited<ScopeHandle>>>;
|
|
2603
|
-
declare function waitForPageComponents<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<ScopeHandle[]>;
|
|
2604
|
-
declare function waitForPageText<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
|
|
2605
|
-
declare function waitForPageTextGone<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
|
|
2606
|
-
declare function waitForPageData<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, path: string, matcher: HeadlessTestingDataMatcher, hasMatcher: boolean, options?: HeadlessTestingWaitOptions): Promise<{}>;
|
|
2605
|
+
export declare function waitForPageSelector<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<NonNullable<Awaited<NodeHandle>> | null>;
|
|
2606
|
+
export declare function waitForPageComponent<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitOptions): Promise<NonNullable<Awaited<ScopeHandle>>>;
|
|
2607
|
+
export declare function waitForPageComponents<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<ScopeHandle[]>;
|
|
2608
|
+
export declare function waitForPageText<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
|
|
2609
|
+
export declare function waitForPageTextGone<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
|
|
2610
|
+
export declare function waitForPageData<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, path: string, matcher: HeadlessTestingDataMatcher, hasMatcher: boolean, options?: HeadlessTestingWaitOptions): Promise<{}>;
|
|
2607
2611
|
//#endregion
|
|
2608
2612
|
//#region src/view/eventBinding.d.ts
|
|
2609
|
-
interface MiniProgramEventBinding {
|
|
2613
|
+
export interface MiniProgramEventBinding {
|
|
2610
2614
|
method: string;
|
|
2611
2615
|
stopAfter: boolean;
|
|
2612
2616
|
}
|
|
2613
|
-
declare function collectMiniProgramEventBindings(attributes?: Record<string, string>): Map<string, MiniProgramEventBinding>;
|
|
2614
|
-
declare function resolveMiniProgramEventBinding(attributes: Record<string, string> | undefined, eventName: string): MiniProgramEventBinding | null;
|
|
2617
|
+
export declare function collectMiniProgramEventBindings(attributes?: Record<string, string>): Map<string, MiniProgramEventBinding>;
|
|
2618
|
+
export declare function resolveMiniProgramEventBinding(attributes: Record<string, string> | undefined, eventName: string): MiniProgramEventBinding | null;
|
|
2615
2619
|
//#endregion
|
|
2616
2620
|
//#region src/view/nodeHandle.d.ts
|
|
2617
2621
|
interface DomNodeLike$3 {
|
|
@@ -2654,7 +2658,7 @@ interface HeadlessTestingNodeInteractionHandlers {
|
|
|
2654
2658
|
};
|
|
2655
2659
|
ownerScopeId: (scopeId: string | null) => string | null;
|
|
2656
2660
|
}
|
|
2657
|
-
declare class HeadlessTestingNodeHandle {
|
|
2661
|
+
export declare class HeadlessTestingNodeHandle {
|
|
2658
2662
|
private readonly node;
|
|
2659
2663
|
private readonly interactions?;
|
|
2660
2664
|
constructor(node: DomNodeLike$3, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
|
|
@@ -2701,11 +2705,11 @@ interface DomNodeLike$2 {
|
|
|
2701
2705
|
parent?: DomNodeLike$2 | null;
|
|
2702
2706
|
type?: string;
|
|
2703
2707
|
}
|
|
2704
|
-
interface RenderedPageTree {
|
|
2708
|
+
export interface RenderedPageTree {
|
|
2705
2709
|
root: DomNodeLike$2;
|
|
2706
2710
|
wxml: string;
|
|
2707
2711
|
}
|
|
2708
|
-
declare function renderPageTree(project: HeadlessProjectDescriptor, page: HeadlessPageInstance): RenderedPageTree;
|
|
2712
|
+
export declare function renderPageTree(project: HeadlessProjectDescriptor, page: HeadlessPageInstance): RenderedPageTree;
|
|
2709
2713
|
//#endregion
|
|
2710
2714
|
//#region src/view/selectorQuery.d.ts
|
|
2711
2715
|
interface DomNodeLike$1 {
|
|
@@ -2716,15 +2720,15 @@ interface DomNodeLike$1 {
|
|
|
2716
2720
|
parent?: DomNodeLike$1 | null;
|
|
2717
2721
|
type?: string;
|
|
2718
2722
|
}
|
|
2719
|
-
interface HeadlessSelectorQueryResolverOptions {
|
|
2723
|
+
export interface HeadlessSelectorQueryResolverOptions {
|
|
2720
2724
|
page: HeadlessPageInstance;
|
|
2721
2725
|
resolveContext?: (node: DomNodeLike$1) => unknown;
|
|
2722
2726
|
root: DomNodeLike$1;
|
|
2723
2727
|
windowInfo: HeadlessWxWindowInfoResult;
|
|
2724
2728
|
}
|
|
2725
|
-
declare function resolveSelectorScrollTop(root: DomNodeLike$1, selector?: string | null): number | null;
|
|
2726
|
-
declare function executeSelectorQueryRequests(requests: HeadlessWxSelectorQueryRequest[], options: HeadlessSelectorQueryResolverOptions): (Record<string, any> | Record<string, any>[] | null)[];
|
|
2727
|
-
declare function resolveSelectorQueryScopeRoot(root: DomNodeLike$1, scopeId?: string | null): DomNodeLike$1;
|
|
2729
|
+
export declare function resolveSelectorScrollTop(root: DomNodeLike$1, selector?: string | null): number | null;
|
|
2730
|
+
export declare function executeSelectorQueryRequests(requests: HeadlessWxSelectorQueryRequest[], options: HeadlessSelectorQueryResolverOptions): (Record<string, any> | Record<string, any>[] | null)[];
|
|
2731
|
+
export declare function resolveSelectorQueryScopeRoot(root: DomNodeLike$1, scopeId?: string | null): DomNodeLike$1;
|
|
2728
2732
|
//#endregion
|
|
2729
2733
|
//#region src/view/selectors.d.ts
|
|
2730
2734
|
interface DomNodeLike {
|
|
@@ -2735,22 +2739,22 @@ interface DomNodeLike {
|
|
|
2735
2739
|
parent?: DomNodeLike | null;
|
|
2736
2740
|
type?: string;
|
|
2737
2741
|
}
|
|
2738
|
-
declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
|
|
2742
|
+
export declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
|
|
2739
2743
|
//#endregion
|
|
2740
2744
|
//#region src/testing/rendered.d.ts
|
|
2741
|
-
interface HeadlessTestingPageQueryOptions extends HeadlessTestingWaitOptions {
|
|
2745
|
+
export interface HeadlessTestingPageQueryOptions extends HeadlessTestingWaitOptions {
|
|
2742
2746
|
componentSelectors?: string[];
|
|
2743
2747
|
fallback?: boolean;
|
|
2744
2748
|
routeOnly?: boolean;
|
|
2745
2749
|
}
|
|
2746
|
-
interface HeadlessTestingRenderedOptions extends HeadlessTestingWaitOptions {
|
|
2750
|
+
export interface HeadlessTestingRenderedOptions extends HeadlessTestingWaitOptions {
|
|
2747
2751
|
componentSelectors?: string[];
|
|
2748
2752
|
dataset?: Record<string, boolean | number | string>;
|
|
2749
2753
|
predicate?: (wxml: string) => boolean;
|
|
2750
2754
|
selector?: string;
|
|
2751
2755
|
text?: string;
|
|
2752
2756
|
}
|
|
2753
|
-
interface HeadlessTestingRenderedNodeSnapshot {
|
|
2757
|
+
export interface HeadlessTestingRenderedNodeSnapshot {
|
|
2754
2758
|
bottom?: number;
|
|
2755
2759
|
dataset?: Record<string, unknown>;
|
|
2756
2760
|
height?: number;
|
|
@@ -2760,19 +2764,19 @@ interface HeadlessTestingRenderedNodeSnapshot {
|
|
|
2760
2764
|
top?: number;
|
|
2761
2765
|
width?: number;
|
|
2762
2766
|
}
|
|
2763
|
-
type HeadlessTestingRenderedSelectorNodesSnapshot = Record<string, HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2764
|
-
interface HeadlessTestingRenderedPageAccess {
|
|
2767
|
+
export type HeadlessTestingRenderedSelectorNodesSnapshot = Record<string, HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2768
|
+
export interface HeadlessTestingRenderedPageAccess {
|
|
2765
2769
|
assertActive: () => void;
|
|
2766
2770
|
findAll: (selector: string) => Promise<HeadlessTestingNodeHandle[]>;
|
|
2767
2771
|
waitFor: (ms?: number) => Promise<void>;
|
|
2768
2772
|
wxml: () => Promise<string>;
|
|
2769
2773
|
}
|
|
2770
|
-
declare function readRenderedNodes(access: HeadlessTestingRenderedPageAccess, selector: string, _options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2771
|
-
declare function readRenderedSelectorNodes(access: HeadlessTestingRenderedPageAccess, selectors: string[], options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedSelectorNodesSnapshot>;
|
|
2772
|
-
declare function waitForRenderedPage(access: HeadlessTestingRenderedPageAccess, options?: HeadlessTestingRenderedOptions): Promise<string>;
|
|
2774
|
+
export declare function readRenderedNodes(access: HeadlessTestingRenderedPageAccess, selector: string, _options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2775
|
+
export declare function readRenderedSelectorNodes(access: HeadlessTestingRenderedPageAccess, selectors: string[], options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedSelectorNodesSnapshot>;
|
|
2776
|
+
export declare function waitForRenderedPage(access: HeadlessTestingRenderedPageAccess, options?: HeadlessTestingRenderedOptions): Promise<string>;
|
|
2773
2777
|
//#endregion
|
|
2774
2778
|
//#region src/testing/logicalSnapshot.d.ts
|
|
2775
|
-
interface HeadlessTestingLogicalNode {
|
|
2779
|
+
export interface HeadlessTestingLogicalNode {
|
|
2776
2780
|
attrs: Record<string, string>;
|
|
2777
2781
|
children: HeadlessTestingLogicalNode[];
|
|
2778
2782
|
nodeId?: string;
|
|
@@ -2780,22 +2784,22 @@ interface HeadlessTestingLogicalNode {
|
|
|
2780
2784
|
text: string;
|
|
2781
2785
|
type: 'element' | 'text';
|
|
2782
2786
|
}
|
|
2783
|
-
interface HeadlessTestingPageSnapshot {
|
|
2787
|
+
export interface HeadlessTestingPageSnapshot {
|
|
2784
2788
|
data: Record<string, any>;
|
|
2785
2789
|
path: string;
|
|
2786
2790
|
query: Record<string, string>;
|
|
2787
2791
|
root: HeadlessTestingLogicalNode;
|
|
2788
2792
|
wxml: string;
|
|
2789
2793
|
}
|
|
2790
|
-
declare function createLogicalNode(node: any): HeadlessTestingLogicalNode;
|
|
2794
|
+
export declare function createLogicalNode(node: any): HeadlessTestingLogicalNode;
|
|
2791
2795
|
//#endregion
|
|
2792
2796
|
//#region src/testing/pageHandle.d.ts
|
|
2793
|
-
interface HeadlessTestingPageCallMethodOptions {
|
|
2797
|
+
export interface HeadlessTestingPageCallMethodOptions {
|
|
2794
2798
|
fallback?: boolean;
|
|
2795
2799
|
routeOnly?: boolean;
|
|
2796
2800
|
timeout?: number;
|
|
2797
2801
|
}
|
|
2798
|
-
declare class HeadlessTestingPageHandle {
|
|
2802
|
+
export declare class HeadlessTestingPageHandle {
|
|
2799
2803
|
private readonly project;
|
|
2800
2804
|
private readonly page;
|
|
2801
2805
|
private readonly session?;
|
|
@@ -2831,7 +2835,7 @@ declare class HeadlessTestingPageHandle {
|
|
|
2831
2835
|
}
|
|
2832
2836
|
//#endregion
|
|
2833
2837
|
//#region src/testing/sessionHandle/scope.d.ts
|
|
2834
|
-
declare class HeadlessTestingScopeHandle {
|
|
2838
|
+
export declare class HeadlessTestingScopeHandle {
|
|
2835
2839
|
readonly scopeId: string;
|
|
2836
2840
|
private readonly project;
|
|
2837
2841
|
private readonly session;
|
|
@@ -2881,11 +2885,15 @@ interface HeadlessTestingProtocolOptions {
|
|
|
2881
2885
|
timeout?: number;
|
|
2882
2886
|
}
|
|
2883
2887
|
type HeadlessTestingEvaluator<T = unknown> = ((...args: any[]) => T | PromiseLike<T>) | string;
|
|
2884
|
-
|
|
2888
|
+
interface HeadlessTestingToolInfo {
|
|
2889
|
+
version: 'mpcore-simulator';
|
|
2890
|
+
}
|
|
2891
|
+
export declare class HeadlessTestingSessionHandle {
|
|
2885
2892
|
private readonly project;
|
|
2886
2893
|
private readonly session;
|
|
2887
2894
|
constructor(project: HeadlessProjectDescriptor, session: HeadlessSession);
|
|
2888
2895
|
close(): Promise<void>;
|
|
2896
|
+
toolInfo(): Promise<HeadlessTestingToolInfo>;
|
|
2889
2897
|
on(eventName: string, handler: (...args: any[]) => void): this;
|
|
2890
2898
|
removeListener(eventName: string, handler: (...args: any[]) => void): this;
|
|
2891
2899
|
off(eventName: string, handler: (...args: any[]) => void): this;
|
|
@@ -2934,9 +2942,9 @@ declare class HeadlessTestingSessionHandle {
|
|
|
2934
2942
|
}
|
|
2935
2943
|
//#endregion
|
|
2936
2944
|
//#region src/testing/launch.d.ts
|
|
2937
|
-
interface HeadlessTestingLaunchOptions {
|
|
2945
|
+
export interface HeadlessTestingLaunchOptions {
|
|
2938
2946
|
projectPath: string;
|
|
2939
2947
|
}
|
|
2940
|
-
declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
|
|
2948
|
+
export declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
|
|
2941
2949
|
//#endregion
|
|
2942
|
-
export {
|
|
2950
|
+
export type { BrowserRenderedPageTree, BrowserRendererContext, CreateComponentInstanceOptions, HeadlessComponentInstance, HeadlessTestingToolInfo, RuntimeRenderedPageTree, RuntimeRendererContext };
|