@mpcore/simulator 0.0.1 → 0.0.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 +3 -0
- package/dist/index.d.mts +1152 -91
- package/dist/index.mjs +2808 -422
- package/package.json +6 -3
package/dist/index.d.mts
CHANGED
|
@@ -37,6 +37,209 @@ interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
|
|
|
37
37
|
scrollTop?: number;
|
|
38
38
|
selector?: string;
|
|
39
39
|
}
|
|
40
|
+
interface HeadlessWxSelectorQueryBoundingClientRectResult {
|
|
41
|
+
bottom: number;
|
|
42
|
+
height: number;
|
|
43
|
+
left: number;
|
|
44
|
+
right: number;
|
|
45
|
+
top: number;
|
|
46
|
+
width: number;
|
|
47
|
+
}
|
|
48
|
+
interface HeadlessWxSelectorQueryScrollOffsetResult {
|
|
49
|
+
scrollLeft: number;
|
|
50
|
+
scrollTop: number;
|
|
51
|
+
}
|
|
52
|
+
interface HeadlessWxSelectorQueryFieldsOption {
|
|
53
|
+
computedStyle?: string[];
|
|
54
|
+
context?: boolean;
|
|
55
|
+
dataset?: boolean;
|
|
56
|
+
id?: boolean;
|
|
57
|
+
mark?: boolean;
|
|
58
|
+
node?: boolean;
|
|
59
|
+
properties?: string[];
|
|
60
|
+
rect?: boolean;
|
|
61
|
+
scrollOffset?: boolean;
|
|
62
|
+
size?: boolean;
|
|
63
|
+
}
|
|
64
|
+
interface HeadlessWxSelectorQueryRequest {
|
|
65
|
+
fields: HeadlessWxSelectorQueryFieldsOption;
|
|
66
|
+
selector?: string;
|
|
67
|
+
single: boolean;
|
|
68
|
+
target: 'selector' | 'viewport';
|
|
69
|
+
}
|
|
70
|
+
interface HeadlessWxSelectorQueryNode {
|
|
71
|
+
boundingClientRect: (callback?: (result: HeadlessWxSelectorQueryBoundingClientRectResult | HeadlessWxSelectorQueryBoundingClientRectResult[] | null) => void) => HeadlessWxSelectorQuery;
|
|
72
|
+
fields: (fields: HeadlessWxSelectorQueryFieldsOption, callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
|
|
73
|
+
scrollOffset: (callback?: (result: HeadlessWxSelectorQueryScrollOffsetResult | HeadlessWxSelectorQueryScrollOffsetResult[] | null) => void) => HeadlessWxSelectorQuery;
|
|
74
|
+
}
|
|
75
|
+
interface HeadlessWxSelectorQuery {
|
|
76
|
+
exec: (callback?: (result: unknown[]) => void) => unknown[];
|
|
77
|
+
in: (component: Record<string, any>) => HeadlessWxSelectorQuery;
|
|
78
|
+
select: (selector: string) => HeadlessWxSelectorQueryNode;
|
|
79
|
+
selectAll: (selector: string) => HeadlessWxSelectorQueryNode;
|
|
80
|
+
selectViewport: () => HeadlessWxSelectorQueryNode;
|
|
81
|
+
}
|
|
82
|
+
interface HeadlessWxStorageResult {
|
|
83
|
+
errMsg: string;
|
|
84
|
+
}
|
|
85
|
+
interface HeadlessWxGetStorageResult extends HeadlessWxStorageResult {
|
|
86
|
+
data: unknown;
|
|
87
|
+
}
|
|
88
|
+
interface HeadlessWxStorageInfoResult extends HeadlessWxStorageResult {
|
|
89
|
+
currentSize: number;
|
|
90
|
+
keys: string[];
|
|
91
|
+
limitSize: number;
|
|
92
|
+
}
|
|
93
|
+
type HeadlessWxNetworkType = '2g' | '3g' | '4g' | '5g' | 'none' | 'unknown' | 'wifi';
|
|
94
|
+
interface HeadlessWxGetNetworkTypeResult {
|
|
95
|
+
errMsg: string;
|
|
96
|
+
networkType: HeadlessWxNetworkType;
|
|
97
|
+
}
|
|
98
|
+
interface HeadlessWxNetworkStatusChangeResult {
|
|
99
|
+
isConnected: boolean;
|
|
100
|
+
networkType: HeadlessWxNetworkType;
|
|
101
|
+
}
|
|
102
|
+
type HeadlessWxNetworkStatusChangeCallback = (result: HeadlessWxNetworkStatusChangeResult) => void;
|
|
103
|
+
interface HeadlessWxSystemInfoResult {
|
|
104
|
+
SDKVersion: string;
|
|
105
|
+
brand: string;
|
|
106
|
+
language: string;
|
|
107
|
+
model: string;
|
|
108
|
+
pixelRatio: number;
|
|
109
|
+
platform: string;
|
|
110
|
+
screenHeight: number;
|
|
111
|
+
screenWidth: number;
|
|
112
|
+
system: string;
|
|
113
|
+
version: string;
|
|
114
|
+
windowHeight: number;
|
|
115
|
+
windowWidth: number;
|
|
116
|
+
}
|
|
117
|
+
interface HeadlessWxAppBaseInfoResult {
|
|
118
|
+
SDKVersion: string;
|
|
119
|
+
enableDebug: boolean;
|
|
120
|
+
host: {
|
|
121
|
+
env: string;
|
|
122
|
+
};
|
|
123
|
+
language: string;
|
|
124
|
+
platform: string;
|
|
125
|
+
version: string;
|
|
126
|
+
}
|
|
127
|
+
interface HeadlessWxWindowInfoResult {
|
|
128
|
+
pixelRatio: number;
|
|
129
|
+
screenHeight: number;
|
|
130
|
+
screenWidth: number;
|
|
131
|
+
statusBarHeight: number;
|
|
132
|
+
windowHeight: number;
|
|
133
|
+
windowWidth: number;
|
|
134
|
+
}
|
|
135
|
+
interface HeadlessWxLaunchOptions {
|
|
136
|
+
path: string;
|
|
137
|
+
query: Record<string, string>;
|
|
138
|
+
referrerInfo: {
|
|
139
|
+
appId: string;
|
|
140
|
+
extraData: Record<string, never>;
|
|
141
|
+
};
|
|
142
|
+
scene: number;
|
|
143
|
+
}
|
|
144
|
+
interface HeadlessWxMenuButtonBoundingClientRectResult {
|
|
145
|
+
bottom: number;
|
|
146
|
+
height: number;
|
|
147
|
+
left: number;
|
|
148
|
+
right: number;
|
|
149
|
+
top: number;
|
|
150
|
+
width: number;
|
|
151
|
+
}
|
|
152
|
+
interface HeadlessWxSetStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
153
|
+
data: unknown;
|
|
154
|
+
key: string;
|
|
155
|
+
}
|
|
156
|
+
interface HeadlessWxGetStorageOption extends HeadlessWxCallbackOption<HeadlessWxGetStorageResult> {
|
|
157
|
+
key: string;
|
|
158
|
+
}
|
|
159
|
+
interface HeadlessWxGetStorageInfoOption extends HeadlessWxCallbackOption<HeadlessWxStorageInfoResult> {}
|
|
160
|
+
interface HeadlessWxGetNetworkTypeOption extends HeadlessWxCallbackOption<HeadlessWxGetNetworkTypeResult> {}
|
|
161
|
+
interface HeadlessWxGetSystemInfoOption extends HeadlessWxCallbackOption<HeadlessWxSystemInfoResult> {}
|
|
162
|
+
interface HeadlessWxGetWindowInfoOption extends HeadlessWxCallbackOption<HeadlessWxWindowInfoResult> {}
|
|
163
|
+
interface HeadlessWxGetAppBaseInfoOption extends HeadlessWxCallbackOption<HeadlessWxAppBaseInfoResult> {}
|
|
164
|
+
interface HeadlessWxRemoveStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
165
|
+
key: string;
|
|
166
|
+
}
|
|
167
|
+
interface HeadlessWxClearStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {}
|
|
168
|
+
interface HeadlessWxHideLoadingOption extends HeadlessWxCallbackOption<{
|
|
169
|
+
errMsg: string;
|
|
170
|
+
}> {}
|
|
171
|
+
interface HeadlessWxSetBackgroundTextStyleOption extends HeadlessWxCallbackOption<{
|
|
172
|
+
errMsg: string;
|
|
173
|
+
}> {
|
|
174
|
+
textStyle: string;
|
|
175
|
+
}
|
|
176
|
+
interface HeadlessWxSetBackgroundColorOption extends HeadlessWxCallbackOption<{
|
|
177
|
+
errMsg: string;
|
|
178
|
+
}> {
|
|
179
|
+
backgroundColor?: string;
|
|
180
|
+
backgroundColorBottom?: string;
|
|
181
|
+
backgroundColorTop?: string;
|
|
182
|
+
}
|
|
183
|
+
interface HeadlessWxSetNavigationBarTitleOption extends HeadlessWxCallbackOption<{
|
|
184
|
+
errMsg: string;
|
|
185
|
+
}> {
|
|
186
|
+
title: string;
|
|
187
|
+
}
|
|
188
|
+
interface HeadlessWxSetNavigationBarColorOption extends HeadlessWxCallbackOption<{
|
|
189
|
+
errMsg: string;
|
|
190
|
+
}> {
|
|
191
|
+
animation?: {
|
|
192
|
+
duration?: number;
|
|
193
|
+
timingFunction?: string;
|
|
194
|
+
};
|
|
195
|
+
backgroundColor?: string;
|
|
196
|
+
frontColor?: string;
|
|
197
|
+
}
|
|
198
|
+
interface HeadlessWxShowNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
199
|
+
errMsg: string;
|
|
200
|
+
}> {}
|
|
201
|
+
interface HeadlessWxHideNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
202
|
+
errMsg: string;
|
|
203
|
+
}> {}
|
|
204
|
+
interface HeadlessWxShareMenuOption extends HeadlessWxCallbackOption<{
|
|
205
|
+
errMsg: string;
|
|
206
|
+
}> {
|
|
207
|
+
isUpdatableMessage?: boolean;
|
|
208
|
+
menus?: string[];
|
|
209
|
+
withShareTicket?: boolean;
|
|
210
|
+
}
|
|
211
|
+
interface HeadlessWxTabBarOption extends HeadlessWxCallbackOption<{
|
|
212
|
+
errMsg: string;
|
|
213
|
+
}> {}
|
|
214
|
+
interface HeadlessWxTabBarItemOption extends HeadlessWxCallbackOption<{
|
|
215
|
+
errMsg: string;
|
|
216
|
+
}> {
|
|
217
|
+
index: number;
|
|
218
|
+
}
|
|
219
|
+
interface HeadlessWxSetTabBarBadgeOption extends HeadlessWxTabBarItemOption {
|
|
220
|
+
text: string;
|
|
221
|
+
}
|
|
222
|
+
interface HeadlessWxShowActionSheetResult {
|
|
223
|
+
errMsg: string;
|
|
224
|
+
tapIndex: number;
|
|
225
|
+
}
|
|
226
|
+
interface HeadlessWxShowActionSheetOption extends HeadlessWxCallbackOption<HeadlessWxShowActionSheetResult> {
|
|
227
|
+
itemList: string[];
|
|
228
|
+
}
|
|
229
|
+
interface HeadlessWxShowModalResult {
|
|
230
|
+
cancel: boolean;
|
|
231
|
+
confirm: boolean;
|
|
232
|
+
errMsg: string;
|
|
233
|
+
}
|
|
234
|
+
interface HeadlessWxShowModalOption extends HeadlessWxCallbackOption<HeadlessWxShowModalResult> {
|
|
235
|
+
cancelColor?: string;
|
|
236
|
+
cancelText?: string;
|
|
237
|
+
confirmColor?: string;
|
|
238
|
+
confirmText?: string;
|
|
239
|
+
content: string;
|
|
240
|
+
showCancel?: boolean;
|
|
241
|
+
title?: string;
|
|
242
|
+
}
|
|
40
243
|
interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
|
|
41
244
|
errMsg: string;
|
|
42
245
|
}> {
|
|
@@ -45,6 +248,12 @@ interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
|
|
|
45
248
|
mask?: boolean;
|
|
46
249
|
title: string;
|
|
47
250
|
}
|
|
251
|
+
interface HeadlessWxShowLoadingOption extends HeadlessWxCallbackOption<{
|
|
252
|
+
errMsg: string;
|
|
253
|
+
}> {
|
|
254
|
+
mask?: boolean;
|
|
255
|
+
title: string;
|
|
256
|
+
}
|
|
48
257
|
interface HeadlessWxRequestSuccessResult {
|
|
49
258
|
cookies: string[];
|
|
50
259
|
data: unknown;
|
|
@@ -62,44 +271,185 @@ interface HeadlessWxRequestTask {
|
|
|
62
271
|
abort: () => void;
|
|
63
272
|
}
|
|
64
273
|
interface HeadlessWxDriver {
|
|
274
|
+
executeSelectorQuery: (requests: HeadlessWxSelectorQueryRequest[], scope?: Record<string, any>) => unknown[];
|
|
275
|
+
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
65
276
|
clearStorageSync: () => void;
|
|
277
|
+
getEnterOptionsSync: () => HeadlessWxLaunchOptions;
|
|
278
|
+
getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
|
|
279
|
+
getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
|
|
280
|
+
getNetworkType: () => HeadlessWxGetNetworkTypeResult;
|
|
281
|
+
getStorageInfoSync: () => HeadlessWxStorageInfoResult;
|
|
66
282
|
getStorageSync: (key: string) => unknown;
|
|
283
|
+
getSystemInfoSync: () => HeadlessWxSystemInfoResult;
|
|
284
|
+
getWindowInfoSync: () => HeadlessWxWindowInfoResult;
|
|
285
|
+
hideLoading: () => {
|
|
286
|
+
errMsg: string;
|
|
287
|
+
};
|
|
67
288
|
hideToast: () => {
|
|
68
289
|
errMsg: string;
|
|
69
290
|
};
|
|
70
291
|
navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
|
|
71
292
|
navigateTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
293
|
+
nextTick: (callback?: () => void) => void;
|
|
294
|
+
offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
295
|
+
onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
72
296
|
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
73
297
|
reLaunch: (option: HeadlessWxNavigateOption) => unknown;
|
|
74
298
|
redirectTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
75
299
|
removeStorageSync: (key: string) => void;
|
|
76
|
-
request: (option: HeadlessWxRequestOption) =>
|
|
300
|
+
request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
|
|
301
|
+
setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
|
|
302
|
+
errMsg: string;
|
|
303
|
+
};
|
|
304
|
+
setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
|
|
305
|
+
errMsg: string;
|
|
306
|
+
};
|
|
77
307
|
setStorageSync: (key: string, value: unknown) => void;
|
|
308
|
+
setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
|
|
309
|
+
errMsg: string;
|
|
310
|
+
};
|
|
311
|
+
setNavigationBarTitle: (option: HeadlessWxSetNavigationBarTitleOption) => {
|
|
312
|
+
errMsg: string;
|
|
313
|
+
};
|
|
314
|
+
hideShareMenu: () => {
|
|
315
|
+
errMsg: string;
|
|
316
|
+
};
|
|
317
|
+
hideNavigationBarLoading: () => {
|
|
318
|
+
errMsg: string;
|
|
319
|
+
};
|
|
320
|
+
hideTabBar: () => {
|
|
321
|
+
errMsg: string;
|
|
322
|
+
};
|
|
323
|
+
hideTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
|
|
324
|
+
errMsg: string;
|
|
325
|
+
};
|
|
326
|
+
showShareMenu: (option: HeadlessWxShareMenuOption) => {
|
|
327
|
+
errMsg: string;
|
|
328
|
+
};
|
|
329
|
+
showNavigationBarLoading: () => {
|
|
330
|
+
errMsg: string;
|
|
331
|
+
};
|
|
332
|
+
showTabBar: () => {
|
|
333
|
+
errMsg: string;
|
|
334
|
+
};
|
|
335
|
+
showTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
|
|
336
|
+
errMsg: string;
|
|
337
|
+
};
|
|
338
|
+
showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult;
|
|
339
|
+
showLoading: (option: HeadlessWxShowLoadingOption) => {
|
|
340
|
+
errMsg: string;
|
|
341
|
+
};
|
|
342
|
+
showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult;
|
|
78
343
|
showToast: (option: HeadlessWxShowToastOption) => {
|
|
79
344
|
errMsg: string;
|
|
80
345
|
};
|
|
81
346
|
stopPullDownRefresh: () => void;
|
|
82
347
|
switchTab: (option: HeadlessWxNavigateOption) => unknown;
|
|
348
|
+
removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
|
|
349
|
+
errMsg: string;
|
|
350
|
+
};
|
|
351
|
+
setTabBarBadge: (option: HeadlessWxSetTabBarBadgeOption) => {
|
|
352
|
+
errMsg: string;
|
|
353
|
+
};
|
|
354
|
+
updateShareMenu: (option: HeadlessWxShareMenuOption) => {
|
|
355
|
+
errMsg: string;
|
|
356
|
+
};
|
|
83
357
|
}
|
|
84
358
|
interface HeadlessWx {
|
|
359
|
+
canIUse: (schema: string) => boolean;
|
|
360
|
+
clearStorage: (option?: HeadlessWxClearStorageOption) => HeadlessWxStorageResult | undefined;
|
|
85
361
|
clearStorageSync: () => void;
|
|
362
|
+
createSelectorQuery: () => HeadlessWxSelectorQuery;
|
|
363
|
+
getEnterOptionsSync: () => HeadlessWxLaunchOptions;
|
|
364
|
+
getAppBaseInfo: (option?: HeadlessWxGetAppBaseInfoOption) => HeadlessWxAppBaseInfoResult | undefined;
|
|
365
|
+
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
366
|
+
getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
|
|
367
|
+
getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
|
|
368
|
+
getNetworkType: (option?: HeadlessWxGetNetworkTypeOption) => HeadlessWxGetNetworkTypeResult | undefined;
|
|
369
|
+
getStorageInfo: (option?: HeadlessWxGetStorageInfoOption) => HeadlessWxStorageInfoResult | undefined;
|
|
370
|
+
getStorageInfoSync: () => HeadlessWxStorageInfoResult;
|
|
371
|
+
getStorage: (option: HeadlessWxGetStorageOption) => HeadlessWxGetStorageResult | undefined;
|
|
86
372
|
getStorageSync: (key: string) => unknown;
|
|
373
|
+
getSystemInfo: (option?: HeadlessWxGetSystemInfoOption) => HeadlessWxSystemInfoResult | undefined;
|
|
374
|
+
getSystemInfoSync: () => HeadlessWxSystemInfoResult;
|
|
375
|
+
getWindowInfo: (option?: HeadlessWxGetWindowInfoOption) => HeadlessWxWindowInfoResult | undefined;
|
|
376
|
+
getWindowInfoSync: () => HeadlessWxWindowInfoResult;
|
|
377
|
+
hideLoading: (option?: HeadlessWxHideLoadingOption) => {
|
|
378
|
+
errMsg: string;
|
|
379
|
+
} | undefined;
|
|
87
380
|
hideToast: () => {
|
|
88
381
|
errMsg: string;
|
|
89
382
|
};
|
|
90
383
|
navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
|
|
91
384
|
navigateTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
385
|
+
nextTick: (callback?: () => void) => void;
|
|
386
|
+
offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
387
|
+
onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
92
388
|
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
93
389
|
reLaunch: (option: HeadlessWxNavigateOption) => unknown;
|
|
94
390
|
redirectTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
391
|
+
removeStorage: (option: HeadlessWxRemoveStorageOption) => HeadlessWxStorageResult | undefined;
|
|
95
392
|
removeStorageSync: (key: string) => void;
|
|
96
393
|
request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
|
|
394
|
+
setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
|
|
395
|
+
errMsg: string;
|
|
396
|
+
} | undefined;
|
|
397
|
+
setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
|
|
398
|
+
errMsg: string;
|
|
399
|
+
} | undefined;
|
|
400
|
+
setStorage: (option: HeadlessWxSetStorageOption) => HeadlessWxStorageResult | undefined;
|
|
97
401
|
setStorageSync: (key: string, value: unknown) => void;
|
|
402
|
+
setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
|
|
403
|
+
errMsg: string;
|
|
404
|
+
} | undefined;
|
|
405
|
+
setNavigationBarTitle: (option: HeadlessWxSetNavigationBarTitleOption) => {
|
|
406
|
+
errMsg: string;
|
|
407
|
+
} | undefined;
|
|
408
|
+
hideShareMenu: (option?: HeadlessWxCallbackOption<{
|
|
409
|
+
errMsg: string;
|
|
410
|
+
}>) => {
|
|
411
|
+
errMsg: string;
|
|
412
|
+
} | undefined;
|
|
413
|
+
hideNavigationBarLoading: (option?: HeadlessWxHideNavigationBarLoadingOption) => {
|
|
414
|
+
errMsg: string;
|
|
415
|
+
} | undefined;
|
|
416
|
+
hideTabBar: (option?: HeadlessWxTabBarOption) => {
|
|
417
|
+
errMsg: string;
|
|
418
|
+
} | undefined;
|
|
419
|
+
hideTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
|
|
420
|
+
errMsg: string;
|
|
421
|
+
} | undefined;
|
|
422
|
+
showShareMenu: (option?: HeadlessWxShareMenuOption) => {
|
|
423
|
+
errMsg: string;
|
|
424
|
+
} | undefined;
|
|
425
|
+
showNavigationBarLoading: (option?: HeadlessWxShowNavigationBarLoadingOption) => {
|
|
426
|
+
errMsg: string;
|
|
427
|
+
} | undefined;
|
|
428
|
+
showTabBar: (option?: HeadlessWxTabBarOption) => {
|
|
429
|
+
errMsg: string;
|
|
430
|
+
} | undefined;
|
|
431
|
+
showTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
|
|
432
|
+
errMsg: string;
|
|
433
|
+
} | undefined;
|
|
434
|
+
showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult | undefined;
|
|
435
|
+
showLoading: (option: HeadlessWxShowLoadingOption) => {
|
|
436
|
+
errMsg: string;
|
|
437
|
+
} | undefined;
|
|
438
|
+
showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult | undefined;
|
|
98
439
|
showToast: (option: HeadlessWxShowToastOption) => {
|
|
99
440
|
errMsg: string;
|
|
100
441
|
} | undefined;
|
|
101
442
|
stopPullDownRefresh: () => void;
|
|
102
443
|
switchTab: (option: HeadlessWxNavigateOption) => unknown;
|
|
444
|
+
removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
|
|
445
|
+
errMsg: string;
|
|
446
|
+
} | undefined;
|
|
447
|
+
setTabBarBadge: (option: HeadlessWxSetTabBarBadgeOption) => {
|
|
448
|
+
errMsg: string;
|
|
449
|
+
} | undefined;
|
|
450
|
+
updateShareMenu: (option?: HeadlessWxShareMenuOption) => {
|
|
451
|
+
errMsg: string;
|
|
452
|
+
} | undefined;
|
|
103
453
|
}
|
|
104
454
|
declare function createHeadlessWx(driver: HeadlessWxDriver): HeadlessWx;
|
|
105
455
|
//#endregion
|
|
@@ -193,10 +543,34 @@ declare function createComponentInstance(options: CreateComponentInstanceOptions
|
|
|
193
543
|
declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
|
|
194
544
|
declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
|
|
195
545
|
//#endregion
|
|
546
|
+
//#region src/project/pageConfig.d.ts
|
|
547
|
+
interface HeadlessNavigationBarSnapshot {
|
|
548
|
+
animation: {
|
|
549
|
+
duration?: number;
|
|
550
|
+
timingFunction?: string;
|
|
551
|
+
} | null;
|
|
552
|
+
backgroundColor: string;
|
|
553
|
+
frontColor: string;
|
|
554
|
+
loading: boolean;
|
|
555
|
+
title: string;
|
|
556
|
+
}
|
|
557
|
+
type HeadlessBackgroundTextStyle = 'dark' | 'light';
|
|
558
|
+
interface HeadlessBackgroundSnapshot {
|
|
559
|
+
backgroundColor: string;
|
|
560
|
+
backgroundColorBottom: string;
|
|
561
|
+
backgroundColorTop: string;
|
|
562
|
+
textStyle: HeadlessBackgroundTextStyle;
|
|
563
|
+
}
|
|
564
|
+
//#endregion
|
|
196
565
|
//#region src/runtime/pageInstance.d.ts
|
|
197
566
|
interface HeadlessPageInstance extends Record<string, any> {
|
|
567
|
+
__background__?: HeadlessBackgroundSnapshot;
|
|
568
|
+
__backgroundTextStyle__?: HeadlessBackgroundTextStyle;
|
|
198
569
|
__lastChangedKeys__?: string[];
|
|
570
|
+
__navigationBar__?: HeadlessNavigationBarSnapshot;
|
|
571
|
+
__navigationBarTitle__?: string;
|
|
199
572
|
__route__: string;
|
|
573
|
+
__scrollTop__?: number;
|
|
200
574
|
data: Record<string, any>;
|
|
201
575
|
options: Record<string, string>;
|
|
202
576
|
route: string;
|
|
@@ -204,15 +578,19 @@ interface HeadlessPageInstance extends Record<string, any> {
|
|
|
204
578
|
selectComponent?: (selector: string) => any;
|
|
205
579
|
setData: (patch: Record<string, any>, callback?: () => void) => void;
|
|
206
580
|
}
|
|
207
|
-
declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string
|
|
581
|
+
declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>, pageState?: {
|
|
582
|
+
background?: HeadlessBackgroundSnapshot;
|
|
583
|
+
backgroundTextStyle?: HeadlessBackgroundTextStyle;
|
|
584
|
+
navigationBar?: HeadlessNavigationBarSnapshot;
|
|
585
|
+
}): HeadlessPageInstance;
|
|
208
586
|
//#endregion
|
|
209
587
|
//#region src/browser/render.d.ts
|
|
210
|
-
interface DomNodeLike$
|
|
588
|
+
interface DomNodeLike$5 {
|
|
211
589
|
attribs?: Record<string, string>;
|
|
212
|
-
children?: DomNodeLike$
|
|
590
|
+
children?: DomNodeLike$5[];
|
|
213
591
|
data?: string;
|
|
214
592
|
name?: string;
|
|
215
|
-
parent?: DomNodeLike$
|
|
593
|
+
parent?: DomNodeLike$5 | null;
|
|
216
594
|
type?: string;
|
|
217
595
|
}
|
|
218
596
|
interface BrowserRenderScope {
|
|
@@ -232,7 +610,7 @@ interface BrowserRenderScope {
|
|
|
232
610
|
ownerScopeId?: string;
|
|
233
611
|
}
|
|
234
612
|
interface BrowserRenderedPageTree {
|
|
235
|
-
root: DomNodeLike$
|
|
613
|
+
root: DomNodeLike$5;
|
|
236
614
|
wxml: string;
|
|
237
615
|
}
|
|
238
616
|
interface BrowserRendererContext {
|
|
@@ -256,14 +634,101 @@ interface HeadlessAppInstance extends Record<string, any> {
|
|
|
256
634
|
}
|
|
257
635
|
declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
|
|
258
636
|
//#endregion
|
|
637
|
+
//#region src/project/loadProject.d.ts
|
|
638
|
+
declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
|
|
639
|
+
//#endregion
|
|
640
|
+
//#region src/runtime/moduleLoader.d.ts
|
|
641
|
+
interface HeadlessModuleLoader {
|
|
642
|
+
executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
|
|
643
|
+
executeAppModule: (filePath: string) => HeadlessAppDefinition;
|
|
644
|
+
executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
|
|
645
|
+
}
|
|
646
|
+
//#endregion
|
|
647
|
+
//#region src/runtime/render.d.ts
|
|
648
|
+
interface DomNodeLike$4 {
|
|
649
|
+
attribs?: Record<string, string>;
|
|
650
|
+
children?: DomNodeLike$4[];
|
|
651
|
+
data?: string;
|
|
652
|
+
name?: string;
|
|
653
|
+
parent?: DomNodeLike$4 | null;
|
|
654
|
+
type?: string;
|
|
655
|
+
}
|
|
656
|
+
interface RuntimeRenderScope {
|
|
657
|
+
alias?: string;
|
|
658
|
+
classList?: string[];
|
|
659
|
+
data: Record<string, any>;
|
|
660
|
+
dataset?: Record<string, string>;
|
|
661
|
+
eventBindings?: Map<string, {
|
|
662
|
+
method: string;
|
|
663
|
+
stopAfter: boolean;
|
|
664
|
+
}>;
|
|
665
|
+
getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
|
|
666
|
+
getScopeId: () => string;
|
|
667
|
+
hostId?: string;
|
|
668
|
+
listenerScopeId?: string;
|
|
669
|
+
id?: string;
|
|
670
|
+
ownerScopeId?: string;
|
|
671
|
+
}
|
|
672
|
+
interface RuntimeRenderedPageTree {
|
|
673
|
+
root: DomNodeLike$4;
|
|
674
|
+
wxml: string;
|
|
675
|
+
}
|
|
676
|
+
interface RuntimeRendererContext {
|
|
677
|
+
changedPageKeys: string[];
|
|
678
|
+
componentCache: Map<string, HeadlessComponentInstance>;
|
|
679
|
+
componentScopes: Map<string, RuntimeRenderScope>;
|
|
680
|
+
moduleLoader: HeadlessModuleLoader;
|
|
681
|
+
project: HeadlessProjectDescriptor;
|
|
682
|
+
session: {
|
|
683
|
+
selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
|
|
684
|
+
selectComponentWithin: (scopeId: string, selector: string) => any;
|
|
685
|
+
selectOwnerComponent: (scopeId: string) => any;
|
|
686
|
+
};
|
|
687
|
+
}
|
|
688
|
+
declare function renderRuntimePageTree(context: RuntimeRendererContext, page: HeadlessPageInstance): RuntimeRenderedPageTree;
|
|
689
|
+
//#endregion
|
|
259
690
|
//#region src/runtime/wxState.d.ts
|
|
691
|
+
interface HeadlessWxLoadingSnapshot {
|
|
692
|
+
mask: boolean;
|
|
693
|
+
title: string;
|
|
694
|
+
}
|
|
260
695
|
interface HeadlessWxToastSnapshot {
|
|
261
696
|
duration: number;
|
|
262
697
|
icon: string;
|
|
263
698
|
mask: boolean;
|
|
264
699
|
title: string;
|
|
265
700
|
}
|
|
701
|
+
interface HeadlessWxNetworkSnapshot extends HeadlessWxNetworkStatusChangeResult {}
|
|
702
|
+
interface HeadlessWxShareMenuSnapshot {
|
|
703
|
+
isUpdatableMessage: boolean;
|
|
704
|
+
menus: string[];
|
|
705
|
+
visible: boolean;
|
|
706
|
+
withShareTicket: boolean;
|
|
707
|
+
}
|
|
708
|
+
interface HeadlessWxActionSheetMockDefinition {
|
|
709
|
+
cancel?: boolean;
|
|
710
|
+
tapIndex?: number;
|
|
711
|
+
}
|
|
712
|
+
interface HeadlessWxActionSheetLogEntry {
|
|
713
|
+
itemList: string[];
|
|
714
|
+
result?: HeadlessWxShowActionSheetResult;
|
|
715
|
+
}
|
|
716
|
+
interface HeadlessWxModalMockDefinition {
|
|
717
|
+
cancel?: boolean;
|
|
718
|
+
confirm?: boolean;
|
|
719
|
+
}
|
|
720
|
+
interface HeadlessWxModalLogEntry {
|
|
721
|
+
cancelColor: string;
|
|
722
|
+
cancelText: string;
|
|
723
|
+
confirmColor: string;
|
|
724
|
+
confirmText: string;
|
|
725
|
+
content: string;
|
|
726
|
+
result: HeadlessWxShowModalResult;
|
|
727
|
+
showCancel: boolean;
|
|
728
|
+
title: string;
|
|
729
|
+
}
|
|
266
730
|
interface HeadlessWxRequestMockDefinition {
|
|
731
|
+
delay?: number;
|
|
267
732
|
header?: Record<string, string>;
|
|
268
733
|
method?: string;
|
|
269
734
|
response: unknown | ((option: HeadlessWxRequestOption) => unknown);
|
|
@@ -280,6 +745,28 @@ interface HeadlessWxRequestLogEntry {
|
|
|
280
745
|
}
|
|
281
746
|
declare function createHeadlessWxState(): {
|
|
282
747
|
clearStorageSync(): void;
|
|
748
|
+
getActionSheetLogs(): {
|
|
749
|
+
itemList: string[];
|
|
750
|
+
result: {
|
|
751
|
+
errMsg: string;
|
|
752
|
+
tapIndex: number;
|
|
753
|
+
} | undefined;
|
|
754
|
+
}[];
|
|
755
|
+
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
756
|
+
getModalLogs(): {
|
|
757
|
+
result: {
|
|
758
|
+
cancel: boolean;
|
|
759
|
+
confirm: boolean;
|
|
760
|
+
errMsg: string;
|
|
761
|
+
};
|
|
762
|
+
cancelColor: string;
|
|
763
|
+
cancelText: string;
|
|
764
|
+
confirmColor: string;
|
|
765
|
+
confirmText: string;
|
|
766
|
+
content: string;
|
|
767
|
+
showCancel: boolean;
|
|
768
|
+
title: string;
|
|
769
|
+
}[];
|
|
283
770
|
getRequestLogs(): {
|
|
284
771
|
data: unknown;
|
|
285
772
|
header: {
|
|
@@ -298,44 +785,74 @@ declare function createHeadlessWxState(): {
|
|
|
298
785
|
method: string;
|
|
299
786
|
url: string;
|
|
300
787
|
}[];
|
|
788
|
+
getStorageInfoSync(): {
|
|
789
|
+
currentSize: number;
|
|
790
|
+
errMsg: string;
|
|
791
|
+
keys: string[];
|
|
792
|
+
limitSize: number;
|
|
793
|
+
};
|
|
301
794
|
getStorageSnapshot(): {
|
|
302
795
|
[k: string]: unknown;
|
|
303
796
|
};
|
|
304
797
|
getStorageSync(key: string): unknown;
|
|
798
|
+
getShareMenu(): {
|
|
799
|
+
isUpdatableMessage: boolean;
|
|
800
|
+
menus: string[];
|
|
801
|
+
visible: boolean;
|
|
802
|
+
withShareTicket: boolean;
|
|
803
|
+
};
|
|
804
|
+
getLoading(): {
|
|
805
|
+
mask: boolean;
|
|
806
|
+
title: string;
|
|
807
|
+
} | null;
|
|
808
|
+
hideShareMenu(): {
|
|
809
|
+
errMsg: string;
|
|
810
|
+
};
|
|
305
811
|
getToast(): {
|
|
306
812
|
duration: number;
|
|
307
813
|
icon: string;
|
|
308
814
|
mask: boolean;
|
|
309
815
|
title: string;
|
|
310
816
|
} | null;
|
|
817
|
+
hideLoading(): {
|
|
818
|
+
errMsg: string;
|
|
819
|
+
};
|
|
311
820
|
hideToast(): {
|
|
312
821
|
errMsg: string;
|
|
313
822
|
};
|
|
823
|
+
offNetworkStatusChange(callback?: HeadlessWxNetworkStatusChangeCallback): void;
|
|
314
824
|
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
825
|
+
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
826
|
+
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
827
|
+
onNetworkStatusChange(callback: HeadlessWxNetworkStatusChangeCallback): void;
|
|
315
828
|
removeStorageSync(key: string): void;
|
|
316
|
-
request(option: HeadlessWxRequestOption):
|
|
829
|
+
request(option: HeadlessWxRequestOption): HeadlessWxRequestTask;
|
|
317
830
|
setStorageSync(key: string, value: unknown): void;
|
|
831
|
+
setNetworkType(nextNetworkType: HeadlessWxNetworkType): {
|
|
832
|
+
errMsg: string;
|
|
833
|
+
networkType: HeadlessWxNetworkType;
|
|
834
|
+
};
|
|
835
|
+
showActionSheet(option: HeadlessWxShowActionSheetOption): HeadlessWxShowActionSheetResult;
|
|
836
|
+
showShareMenu(option?: HeadlessWxShareMenuOption): {
|
|
837
|
+
errMsg: string;
|
|
838
|
+
};
|
|
839
|
+
showLoading(option: HeadlessWxShowLoadingOption): {
|
|
840
|
+
errMsg: string;
|
|
841
|
+
};
|
|
842
|
+
showModal(option: HeadlessWxShowModalOption): HeadlessWxShowModalResult;
|
|
318
843
|
showToast(option: HeadlessWxShowToastOption): {
|
|
319
844
|
errMsg: string;
|
|
320
845
|
};
|
|
846
|
+
updateShareMenu(option?: HeadlessWxShareMenuOption): {
|
|
847
|
+
errMsg: string;
|
|
848
|
+
};
|
|
321
849
|
};
|
|
322
850
|
//#endregion
|
|
323
|
-
//#region src/
|
|
324
|
-
interface
|
|
325
|
-
|
|
326
|
-
project?: HeadlessProjectDescriptor;
|
|
327
|
-
}
|
|
328
|
-
interface HeadlessAppLaunchOptions$1 {
|
|
329
|
-
path: string;
|
|
330
|
-
query: Record<string, string>;
|
|
331
|
-
referrerInfo: {
|
|
332
|
-
appId: string;
|
|
333
|
-
extraData: Record<string, never>;
|
|
334
|
-
};
|
|
335
|
-
scene: number;
|
|
851
|
+
//#region src/runtime/session.d.ts
|
|
852
|
+
interface HeadlessSessionOptions {
|
|
853
|
+
projectPath: string;
|
|
336
854
|
}
|
|
337
|
-
declare class
|
|
338
|
-
readonly files: BrowserVirtualFiles;
|
|
855
|
+
declare class HeadlessSession {
|
|
339
856
|
readonly project: HeadlessProjectDescriptor;
|
|
340
857
|
private appDefinition;
|
|
341
858
|
private appInstance;
|
|
@@ -348,10 +865,40 @@ declare class BrowserHeadlessSession {
|
|
|
348
865
|
private readonly tabBarRoutes;
|
|
349
866
|
private readonly tabPages;
|
|
350
867
|
private readonly tabBarItems;
|
|
868
|
+
private readonly tabBarState;
|
|
869
|
+
private tabBarVisible;
|
|
870
|
+
private readonly systemInfo;
|
|
871
|
+
private enterOptions;
|
|
872
|
+
private launchOptions;
|
|
351
873
|
private readonly wxState;
|
|
352
|
-
|
|
874
|
+
private pullDownRefreshState;
|
|
875
|
+
constructor(options: HeadlessSessionOptions);
|
|
353
876
|
getApp(): HeadlessAppInstance | null;
|
|
354
877
|
getCurrentPages(): HeadlessPageInstance[];
|
|
878
|
+
getCurrentPageNavigationBarTitle(): string | null;
|
|
879
|
+
getCurrentPageNavigationBar(): {
|
|
880
|
+
animation: {
|
|
881
|
+
duration?: number;
|
|
882
|
+
timingFunction?: string;
|
|
883
|
+
} | null;
|
|
884
|
+
backgroundColor: string;
|
|
885
|
+
frontColor: string;
|
|
886
|
+
loading: boolean;
|
|
887
|
+
title: string;
|
|
888
|
+
} | null;
|
|
889
|
+
getCurrentPageBackground(): {
|
|
890
|
+
backgroundColor: string;
|
|
891
|
+
backgroundColorBottom: string;
|
|
892
|
+
backgroundColorTop: string;
|
|
893
|
+
textStyle: HeadlessBackgroundTextStyle;
|
|
894
|
+
} | null;
|
|
895
|
+
getActionSheetLogs(): {
|
|
896
|
+
itemList: string[];
|
|
897
|
+
result: {
|
|
898
|
+
errMsg: string;
|
|
899
|
+
tapIndex: number;
|
|
900
|
+
} | undefined;
|
|
901
|
+
}[];
|
|
355
902
|
getRequestLogs(): {
|
|
356
903
|
data: unknown;
|
|
357
904
|
header: {
|
|
@@ -370,20 +917,11 @@ declare class BrowserHeadlessSession {
|
|
|
370
917
|
method: string;
|
|
371
918
|
url: string;
|
|
372
919
|
}[];
|
|
373
|
-
|
|
374
|
-
[k: string]: unknown;
|
|
375
|
-
};
|
|
376
|
-
getToast(): {
|
|
377
|
-
duration: number;
|
|
378
|
-
icon: string;
|
|
379
|
-
mask: boolean;
|
|
380
|
-
title: string;
|
|
381
|
-
} | null;
|
|
382
|
-
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
920
|
+
renderCurrentPage(): RuntimeRenderedPageTree;
|
|
383
921
|
getScopeSnapshot(scopeId: string): {
|
|
384
|
-
data: any
|
|
922
|
+
data: Record<string, any>;
|
|
385
923
|
methods: string[];
|
|
386
|
-
properties: any
|
|
924
|
+
properties: Record<string, any>;
|
|
387
925
|
scopeId: string;
|
|
388
926
|
type: "component";
|
|
389
927
|
} | {
|
|
@@ -399,27 +937,169 @@ declare class BrowserHeadlessSession {
|
|
|
399
937
|
scopeId: string;
|
|
400
938
|
type: "scope";
|
|
401
939
|
} | null;
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
940
|
+
getScopeIdForComponent(component: HeadlessComponentInstance | null | undefined): string | null;
|
|
941
|
+
callScopeMethod(scopeId: string | null, methodName: string, event: Record<string, any>): any;
|
|
942
|
+
callScopeMethodDirect(scopeId: string, methodName: string, ...args: any[]): any;
|
|
943
|
+
getStorageSnapshot(): {
|
|
944
|
+
[k: string]: unknown;
|
|
945
|
+
};
|
|
946
|
+
getShareMenu(): {
|
|
947
|
+
isUpdatableMessage: boolean;
|
|
948
|
+
menus: string[];
|
|
949
|
+
visible: boolean;
|
|
950
|
+
withShareTicket: boolean;
|
|
951
|
+
};
|
|
952
|
+
selectComponent(selector: string): HeadlessComponentInstance | null;
|
|
953
|
+
selectAllComponents(selector: string): (HeadlessComponentInstance | undefined)[];
|
|
954
|
+
selectComponentWithin(scopeId: string, selector: string): HeadlessComponentInstance | null;
|
|
955
|
+
selectAllComponentsWithin(scopeId: string, selector: string): (HeadlessComponentInstance | undefined)[];
|
|
956
|
+
selectOwnerComponent(scopeId: string): HeadlessComponentInstance | null;
|
|
957
|
+
getTabBar(): {
|
|
958
|
+
visible: boolean;
|
|
959
|
+
};
|
|
960
|
+
getTabBarSnapshot(): {
|
|
961
|
+
items: {
|
|
962
|
+
badge: string | null;
|
|
963
|
+
index: number;
|
|
964
|
+
pagePath: string;
|
|
965
|
+
redDot: boolean;
|
|
966
|
+
text: string | undefined;
|
|
967
|
+
}[];
|
|
968
|
+
visible: boolean;
|
|
969
|
+
};
|
|
970
|
+
getStorageInfo(): {
|
|
971
|
+
currentSize: number;
|
|
972
|
+
errMsg: string;
|
|
973
|
+
keys: string[];
|
|
974
|
+
limitSize: number;
|
|
975
|
+
};
|
|
976
|
+
getPullDownRefreshState(): {
|
|
977
|
+
active: boolean;
|
|
978
|
+
stopCalls: number;
|
|
979
|
+
};
|
|
980
|
+
getSystemInfo(): {
|
|
981
|
+
SDKVersion: string;
|
|
982
|
+
brand: string;
|
|
983
|
+
language: string;
|
|
984
|
+
model: string;
|
|
985
|
+
pixelRatio: number;
|
|
986
|
+
platform: string;
|
|
987
|
+
screenHeight: number;
|
|
988
|
+
screenWidth: number;
|
|
989
|
+
system: string;
|
|
990
|
+
version: string;
|
|
991
|
+
windowHeight: number;
|
|
992
|
+
windowWidth: number;
|
|
993
|
+
};
|
|
994
|
+
getWindowInfo(): HeadlessWxWindowInfoResult;
|
|
995
|
+
getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
|
|
996
|
+
getLaunchOptions(): {
|
|
997
|
+
query: {
|
|
998
|
+
[x: string]: string;
|
|
414
999
|
};
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
1000
|
+
referrerInfo: {
|
|
1001
|
+
extraData: {
|
|
1002
|
+
[x: string]: never;
|
|
1003
|
+
};
|
|
1004
|
+
appId: string;
|
|
420
1005
|
};
|
|
421
|
-
|
|
422
|
-
|
|
1006
|
+
path: string;
|
|
1007
|
+
scene: number;
|
|
1008
|
+
};
|
|
1009
|
+
getEnterOptions(): {
|
|
1010
|
+
query: {
|
|
1011
|
+
[x: string]: string;
|
|
1012
|
+
};
|
|
1013
|
+
referrerInfo: {
|
|
1014
|
+
extraData: {
|
|
1015
|
+
[x: string]: never;
|
|
1016
|
+
};
|
|
1017
|
+
appId: string;
|
|
1018
|
+
};
|
|
1019
|
+
path: string;
|
|
1020
|
+
scene: number;
|
|
1021
|
+
};
|
|
1022
|
+
getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
|
|
1023
|
+
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
1024
|
+
getLoading(): {
|
|
1025
|
+
mask: boolean;
|
|
1026
|
+
title: string;
|
|
1027
|
+
} | null;
|
|
1028
|
+
getModalLogs(): {
|
|
1029
|
+
result: {
|
|
1030
|
+
cancel: boolean;
|
|
1031
|
+
confirm: boolean;
|
|
1032
|
+
errMsg: string;
|
|
1033
|
+
};
|
|
1034
|
+
cancelColor: string;
|
|
1035
|
+
cancelText: string;
|
|
1036
|
+
confirmColor: string;
|
|
1037
|
+
confirmText: string;
|
|
1038
|
+
content: string;
|
|
1039
|
+
showCancel: boolean;
|
|
1040
|
+
title: string;
|
|
1041
|
+
}[];
|
|
1042
|
+
getToast(): {
|
|
1043
|
+
duration: number;
|
|
1044
|
+
icon: string;
|
|
1045
|
+
mask: boolean;
|
|
1046
|
+
title: string;
|
|
1047
|
+
} | null;
|
|
1048
|
+
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
1049
|
+
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
1050
|
+
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
1051
|
+
setNetworkType(networkType: HeadlessWxNetworkType): {
|
|
1052
|
+
errMsg: string;
|
|
1053
|
+
networkType: HeadlessWxNetworkType;
|
|
1054
|
+
};
|
|
1055
|
+
setBackgroundTextStyle(textStyle: string): {
|
|
1056
|
+
errMsg: string;
|
|
1057
|
+
};
|
|
1058
|
+
setBackgroundColor(option: {
|
|
1059
|
+
backgroundColor?: string;
|
|
1060
|
+
backgroundColorBottom?: string;
|
|
1061
|
+
backgroundColorTop?: string;
|
|
1062
|
+
}): {
|
|
1063
|
+
errMsg: string;
|
|
1064
|
+
};
|
|
1065
|
+
setNavigationBarTitle(title: string): {
|
|
1066
|
+
errMsg: string;
|
|
1067
|
+
};
|
|
1068
|
+
setNavigationBarColor(option: {
|
|
1069
|
+
animation?: {
|
|
1070
|
+
duration?: number;
|
|
1071
|
+
timingFunction?: string;
|
|
1072
|
+
};
|
|
1073
|
+
backgroundColor?: string;
|
|
1074
|
+
frontColor?: string;
|
|
1075
|
+
}): {
|
|
1076
|
+
errMsg: string;
|
|
1077
|
+
};
|
|
1078
|
+
showNavigationBarLoading(): {
|
|
1079
|
+
errMsg: string;
|
|
1080
|
+
};
|
|
1081
|
+
hideNavigationBarLoading(): {
|
|
1082
|
+
errMsg: string;
|
|
1083
|
+
};
|
|
1084
|
+
hideTabBar(): {
|
|
1085
|
+
errMsg: string;
|
|
1086
|
+
};
|
|
1087
|
+
hideTabBarRedDot(index: number): {
|
|
1088
|
+
errMsg: string;
|
|
1089
|
+
};
|
|
1090
|
+
showTabBar(): {
|
|
1091
|
+
errMsg: string;
|
|
1092
|
+
};
|
|
1093
|
+
showTabBarRedDot(index: number): {
|
|
1094
|
+
errMsg: string;
|
|
1095
|
+
};
|
|
1096
|
+
removeTabBarBadge(index: number): {
|
|
1097
|
+
errMsg: string;
|
|
1098
|
+
};
|
|
1099
|
+
setTabBarBadge(index: number, text: string): {
|
|
1100
|
+
errMsg: string;
|
|
1101
|
+
};
|
|
1102
|
+
bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
|
|
423
1103
|
reLaunch(url: string): HeadlessPageInstance;
|
|
424
1104
|
navigateTo(url: string): HeadlessPageInstance;
|
|
425
1105
|
redirectTo(url: string): HeadlessPageInstance;
|
|
@@ -427,42 +1107,41 @@ declare class BrowserHeadlessSession {
|
|
|
427
1107
|
switchTab(url: string): HeadlessPageInstance;
|
|
428
1108
|
pageScrollTo(option: {
|
|
429
1109
|
scrollTop?: number;
|
|
1110
|
+
duration?: number;
|
|
1111
|
+
selector?: string;
|
|
1112
|
+
success?: () => void;
|
|
1113
|
+
fail?: (error: Error) => void;
|
|
1114
|
+
complete?: () => void;
|
|
430
1115
|
}): void;
|
|
431
1116
|
triggerPullDownRefresh(): HeadlessPageInstance;
|
|
432
1117
|
triggerReachBottom(): HeadlessPageInstance;
|
|
433
1118
|
triggerResize(options: Record<string, any>): HeadlessPageInstance;
|
|
434
1119
|
triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
|
|
435
1120
|
stopPullDownRefresh(): void;
|
|
1121
|
+
private executeSelectorQuery;
|
|
436
1122
|
private createFreshPage;
|
|
437
1123
|
private isTabBarRoute;
|
|
1124
|
+
private resolveTabBarItem;
|
|
1125
|
+
private requireTabBarItem;
|
|
438
1126
|
private removePageInstance;
|
|
439
1127
|
private resolveNavigationTarget;
|
|
440
|
-
private resolveTabBarItem;
|
|
441
1128
|
private unloadAllPages;
|
|
442
1129
|
private unloadPage;
|
|
443
1130
|
private requireCurrentPage;
|
|
1131
|
+
private selectComponentsWithin;
|
|
444
1132
|
private detachPageComponents;
|
|
445
1133
|
private runPageComponentLifetime;
|
|
1134
|
+
private getComponentScopeId;
|
|
446
1135
|
}
|
|
447
|
-
declare function
|
|
448
|
-
//#endregion
|
|
449
|
-
//#region src/project/loadProject.d.ts
|
|
450
|
-
declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
|
|
1136
|
+
declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
|
|
451
1137
|
//#endregion
|
|
452
|
-
//#region src/
|
|
453
|
-
interface
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
interface HeadlessAppLaunchOptions {
|
|
457
|
-
path: string;
|
|
458
|
-
query: Record<string, string>;
|
|
459
|
-
referrerInfo: {
|
|
460
|
-
appId: string;
|
|
461
|
-
extraData: Record<string, never>;
|
|
462
|
-
};
|
|
463
|
-
scene: number;
|
|
1138
|
+
//#region src/browser/session.d.ts
|
|
1139
|
+
interface BrowserHeadlessSessionOptions {
|
|
1140
|
+
files: BrowserVirtualFiles;
|
|
1141
|
+
project?: HeadlessProjectDescriptor;
|
|
464
1142
|
}
|
|
465
|
-
declare class
|
|
1143
|
+
declare class BrowserHeadlessSession {
|
|
1144
|
+
readonly files: BrowserVirtualFiles;
|
|
466
1145
|
readonly project: HeadlessProjectDescriptor;
|
|
467
1146
|
private appDefinition;
|
|
468
1147
|
private appInstance;
|
|
@@ -470,13 +1149,45 @@ declare class HeadlessSession {
|
|
|
470
1149
|
private readonly registries;
|
|
471
1150
|
private currentPageInstance;
|
|
472
1151
|
private readonly pages;
|
|
1152
|
+
private readonly componentCache;
|
|
1153
|
+
private readonly componentScopes;
|
|
473
1154
|
private readonly tabBarRoutes;
|
|
474
1155
|
private readonly tabPages;
|
|
475
1156
|
private readonly tabBarItems;
|
|
1157
|
+
private readonly tabBarState;
|
|
1158
|
+
private tabBarVisible;
|
|
1159
|
+
private readonly systemInfo;
|
|
1160
|
+
private enterOptions;
|
|
1161
|
+
private launchOptions;
|
|
476
1162
|
private readonly wxState;
|
|
477
|
-
|
|
1163
|
+
private pullDownRefreshState;
|
|
1164
|
+
constructor(options: BrowserHeadlessSessionOptions);
|
|
478
1165
|
getApp(): HeadlessAppInstance | null;
|
|
479
1166
|
getCurrentPages(): HeadlessPageInstance[];
|
|
1167
|
+
getCurrentPageNavigationBarTitle(): string | null;
|
|
1168
|
+
getCurrentPageNavigationBar(): {
|
|
1169
|
+
animation: {
|
|
1170
|
+
duration?: number;
|
|
1171
|
+
timingFunction?: string;
|
|
1172
|
+
} | null;
|
|
1173
|
+
backgroundColor: string;
|
|
1174
|
+
frontColor: string;
|
|
1175
|
+
loading: boolean;
|
|
1176
|
+
title: string;
|
|
1177
|
+
} | null;
|
|
1178
|
+
getCurrentPageBackground(): {
|
|
1179
|
+
backgroundColor: string;
|
|
1180
|
+
backgroundColorBottom: string;
|
|
1181
|
+
backgroundColorTop: string;
|
|
1182
|
+
textStyle: HeadlessBackgroundTextStyle;
|
|
1183
|
+
} | null;
|
|
1184
|
+
getActionSheetLogs(): {
|
|
1185
|
+
itemList: string[];
|
|
1186
|
+
result: {
|
|
1187
|
+
errMsg: string;
|
|
1188
|
+
tapIndex: number;
|
|
1189
|
+
} | undefined;
|
|
1190
|
+
}[];
|
|
480
1191
|
getRequestLogs(): {
|
|
481
1192
|
data: unknown;
|
|
482
1193
|
header: {
|
|
@@ -498,14 +1209,201 @@ declare class HeadlessSession {
|
|
|
498
1209
|
getStorageSnapshot(): {
|
|
499
1210
|
[k: string]: unknown;
|
|
500
1211
|
};
|
|
1212
|
+
getShareMenu(): {
|
|
1213
|
+
isUpdatableMessage: boolean;
|
|
1214
|
+
menus: string[];
|
|
1215
|
+
visible: boolean;
|
|
1216
|
+
withShareTicket: boolean;
|
|
1217
|
+
};
|
|
1218
|
+
getTabBar(): {
|
|
1219
|
+
visible: boolean;
|
|
1220
|
+
};
|
|
1221
|
+
getTabBarSnapshot(): {
|
|
1222
|
+
items: {
|
|
1223
|
+
badge: string | null;
|
|
1224
|
+
index: number;
|
|
1225
|
+
pagePath: string;
|
|
1226
|
+
redDot: boolean;
|
|
1227
|
+
text: string | undefined;
|
|
1228
|
+
}[];
|
|
1229
|
+
visible: boolean;
|
|
1230
|
+
};
|
|
1231
|
+
getStorageInfo(): {
|
|
1232
|
+
currentSize: number;
|
|
1233
|
+
errMsg: string;
|
|
1234
|
+
keys: string[];
|
|
1235
|
+
limitSize: number;
|
|
1236
|
+
};
|
|
1237
|
+
getPullDownRefreshState(): {
|
|
1238
|
+
active: boolean;
|
|
1239
|
+
stopCalls: number;
|
|
1240
|
+
};
|
|
1241
|
+
getSystemInfo(): {
|
|
1242
|
+
SDKVersion: string;
|
|
1243
|
+
brand: string;
|
|
1244
|
+
language: string;
|
|
1245
|
+
model: string;
|
|
1246
|
+
pixelRatio: number;
|
|
1247
|
+
platform: string;
|
|
1248
|
+
screenHeight: number;
|
|
1249
|
+
screenWidth: number;
|
|
1250
|
+
system: string;
|
|
1251
|
+
version: string;
|
|
1252
|
+
windowHeight: number;
|
|
1253
|
+
windowWidth: number;
|
|
1254
|
+
};
|
|
1255
|
+
getWindowInfo(): HeadlessWxWindowInfoResult;
|
|
1256
|
+
getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
|
|
1257
|
+
getLaunchOptions(): {
|
|
1258
|
+
query: {
|
|
1259
|
+
[x: string]: string;
|
|
1260
|
+
};
|
|
1261
|
+
referrerInfo: {
|
|
1262
|
+
extraData: {
|
|
1263
|
+
[x: string]: never;
|
|
1264
|
+
};
|
|
1265
|
+
appId: string;
|
|
1266
|
+
};
|
|
1267
|
+
path: string;
|
|
1268
|
+
scene: number;
|
|
1269
|
+
};
|
|
1270
|
+
getEnterOptions(): {
|
|
1271
|
+
query: {
|
|
1272
|
+
[x: string]: string;
|
|
1273
|
+
};
|
|
1274
|
+
referrerInfo: {
|
|
1275
|
+
extraData: {
|
|
1276
|
+
[x: string]: never;
|
|
1277
|
+
};
|
|
1278
|
+
appId: string;
|
|
1279
|
+
};
|
|
1280
|
+
path: string;
|
|
1281
|
+
scene: number;
|
|
1282
|
+
};
|
|
1283
|
+
getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
|
|
1284
|
+
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
1285
|
+
getLoading(): {
|
|
1286
|
+
mask: boolean;
|
|
1287
|
+
title: string;
|
|
1288
|
+
} | null;
|
|
1289
|
+
getModalLogs(): {
|
|
1290
|
+
result: {
|
|
1291
|
+
cancel: boolean;
|
|
1292
|
+
confirm: boolean;
|
|
1293
|
+
errMsg: string;
|
|
1294
|
+
};
|
|
1295
|
+
cancelColor: string;
|
|
1296
|
+
cancelText: string;
|
|
1297
|
+
confirmColor: string;
|
|
1298
|
+
confirmText: string;
|
|
1299
|
+
content: string;
|
|
1300
|
+
showCancel: boolean;
|
|
1301
|
+
title: string;
|
|
1302
|
+
}[];
|
|
501
1303
|
getToast(): {
|
|
502
1304
|
duration: number;
|
|
503
1305
|
icon: string;
|
|
504
1306
|
mask: boolean;
|
|
505
1307
|
title: string;
|
|
506
1308
|
} | null;
|
|
1309
|
+
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
1310
|
+
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
507
1311
|
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
508
|
-
|
|
1312
|
+
setNetworkType(networkType: HeadlessWxNetworkType): {
|
|
1313
|
+
errMsg: string;
|
|
1314
|
+
networkType: HeadlessWxNetworkType;
|
|
1315
|
+
};
|
|
1316
|
+
setBackgroundTextStyle(textStyle: string): {
|
|
1317
|
+
errMsg: string;
|
|
1318
|
+
};
|
|
1319
|
+
setBackgroundColor(option: {
|
|
1320
|
+
backgroundColor?: string;
|
|
1321
|
+
backgroundColorBottom?: string;
|
|
1322
|
+
backgroundColorTop?: string;
|
|
1323
|
+
}): {
|
|
1324
|
+
errMsg: string;
|
|
1325
|
+
};
|
|
1326
|
+
setNavigationBarTitle(title: string): {
|
|
1327
|
+
errMsg: string;
|
|
1328
|
+
};
|
|
1329
|
+
setNavigationBarColor(option: {
|
|
1330
|
+
animation?: {
|
|
1331
|
+
duration?: number;
|
|
1332
|
+
timingFunction?: string;
|
|
1333
|
+
};
|
|
1334
|
+
backgroundColor?: string;
|
|
1335
|
+
frontColor?: string;
|
|
1336
|
+
}): {
|
|
1337
|
+
errMsg: string;
|
|
1338
|
+
};
|
|
1339
|
+
showNavigationBarLoading(): {
|
|
1340
|
+
errMsg: string;
|
|
1341
|
+
};
|
|
1342
|
+
hideNavigationBarLoading(): {
|
|
1343
|
+
errMsg: string;
|
|
1344
|
+
};
|
|
1345
|
+
hideTabBar(): {
|
|
1346
|
+
errMsg: string;
|
|
1347
|
+
};
|
|
1348
|
+
hideTabBarRedDot(index: number): {
|
|
1349
|
+
errMsg: string;
|
|
1350
|
+
};
|
|
1351
|
+
showTabBar(): {
|
|
1352
|
+
errMsg: string;
|
|
1353
|
+
};
|
|
1354
|
+
showTabBarRedDot(index: number): {
|
|
1355
|
+
errMsg: string;
|
|
1356
|
+
};
|
|
1357
|
+
removeTabBarBadge(index: number): {
|
|
1358
|
+
errMsg: string;
|
|
1359
|
+
};
|
|
1360
|
+
setTabBarBadge(index: number, text: string): {
|
|
1361
|
+
errMsg: string;
|
|
1362
|
+
};
|
|
1363
|
+
getScopeSnapshot(scopeId: string): {
|
|
1364
|
+
data: any;
|
|
1365
|
+
methods: string[];
|
|
1366
|
+
properties: any;
|
|
1367
|
+
scopeId: string;
|
|
1368
|
+
type: "component";
|
|
1369
|
+
} | {
|
|
1370
|
+
data: Record<string, any>;
|
|
1371
|
+
methods: string[];
|
|
1372
|
+
properties: Record<string, string>;
|
|
1373
|
+
scopeId: string;
|
|
1374
|
+
type: "page";
|
|
1375
|
+
} | {
|
|
1376
|
+
data: any;
|
|
1377
|
+
methods: string[];
|
|
1378
|
+
properties: {};
|
|
1379
|
+
scopeId: string;
|
|
1380
|
+
type: "scope";
|
|
1381
|
+
} | null;
|
|
1382
|
+
getScopeIdForComponent(component: HeadlessComponentInstance | null | undefined): string | null;
|
|
1383
|
+
selectComponent(selector: string): any;
|
|
1384
|
+
selectAllComponents(selector: string): any[];
|
|
1385
|
+
selectComponentWithin(scopeId: string, selector: string): any;
|
|
1386
|
+
selectAllComponentsWithin(scopeId: string, selector: string): any[];
|
|
1387
|
+
selectOwnerComponent(scopeId: string): any;
|
|
1388
|
+
private selectComponentsWithin;
|
|
1389
|
+
renderCurrentPage(): BrowserRenderedPageTree;
|
|
1390
|
+
callScopeMethod(scopeId: string | null, methodName: string, event: Record<string, any>): any;
|
|
1391
|
+
callScopeMethodDirect(scopeId: string, methodName: string, ...args: any[]): any;
|
|
1392
|
+
callTapBinding(scopeId: string, methodName: string): any;
|
|
1393
|
+
callTapBindingWithEvent(scopeId: string, methodName: string, event?: {
|
|
1394
|
+
currentTarget?: {
|
|
1395
|
+
dataset?: Record<string, string>;
|
|
1396
|
+
id?: string;
|
|
1397
|
+
};
|
|
1398
|
+
dataset?: Record<string, string>;
|
|
1399
|
+
id?: string;
|
|
1400
|
+
mark?: Record<string, unknown>;
|
|
1401
|
+
target?: {
|
|
1402
|
+
dataset?: Record<string, string>;
|
|
1403
|
+
id?: string;
|
|
1404
|
+
};
|
|
1405
|
+
}): any;
|
|
1406
|
+
bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
|
|
509
1407
|
reLaunch(url: string): HeadlessPageInstance;
|
|
510
1408
|
navigateTo(url: string): HeadlessPageInstance;
|
|
511
1409
|
redirectTo(url: string): HeadlessPageInstance;
|
|
@@ -513,49 +1411,120 @@ declare class HeadlessSession {
|
|
|
513
1411
|
switchTab(url: string): HeadlessPageInstance;
|
|
514
1412
|
pageScrollTo(option: {
|
|
515
1413
|
scrollTop?: number;
|
|
516
|
-
duration?: number;
|
|
517
|
-
selector?: string;
|
|
518
|
-
success?: () => void;
|
|
519
|
-
fail?: (error: Error) => void;
|
|
520
|
-
complete?: () => void;
|
|
521
1414
|
}): void;
|
|
522
1415
|
triggerPullDownRefresh(): HeadlessPageInstance;
|
|
523
1416
|
triggerReachBottom(): HeadlessPageInstance;
|
|
524
1417
|
triggerResize(options: Record<string, any>): HeadlessPageInstance;
|
|
525
1418
|
triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
|
|
526
1419
|
stopPullDownRefresh(): void;
|
|
1420
|
+
private executeSelectorQuery;
|
|
527
1421
|
private createFreshPage;
|
|
528
1422
|
private isTabBarRoute;
|
|
529
|
-
private resolveTabBarItem;
|
|
530
1423
|
private removePageInstance;
|
|
531
1424
|
private resolveNavigationTarget;
|
|
1425
|
+
private resolveTabBarItem;
|
|
1426
|
+
private requireTabBarItem;
|
|
532
1427
|
private unloadAllPages;
|
|
533
1428
|
private unloadPage;
|
|
534
1429
|
private requireCurrentPage;
|
|
1430
|
+
private detachPageComponents;
|
|
1431
|
+
private runPageComponentLifetime;
|
|
1432
|
+
private getComponentScopeId;
|
|
535
1433
|
}
|
|
536
|
-
declare function
|
|
1434
|
+
declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
|
|
537
1435
|
//#endregion
|
|
538
1436
|
//#region src/view/nodeHandle.d.ts
|
|
539
|
-
interface DomNodeLike$
|
|
1437
|
+
interface DomNodeLike$3 {
|
|
540
1438
|
attribs?: Record<string, string>;
|
|
541
|
-
children?: DomNodeLike$
|
|
1439
|
+
children?: DomNodeLike$3[];
|
|
542
1440
|
data?: string;
|
|
543
1441
|
name?: string;
|
|
544
|
-
parent?: DomNodeLike$
|
|
1442
|
+
parent?: DomNodeLike$3 | null;
|
|
545
1443
|
type?: string;
|
|
546
1444
|
}
|
|
1445
|
+
interface HeadlessTestingNodeEventInit {
|
|
1446
|
+
currentTarget?: {
|
|
1447
|
+
dataset?: Record<string, string>;
|
|
1448
|
+
id?: string;
|
|
1449
|
+
};
|
|
1450
|
+
dataset?: Record<string, string>;
|
|
1451
|
+
detail?: unknown;
|
|
1452
|
+
id?: string;
|
|
1453
|
+
mark?: Record<string, unknown>;
|
|
1454
|
+
target?: {
|
|
1455
|
+
dataset?: Record<string, string>;
|
|
1456
|
+
id?: string;
|
|
1457
|
+
};
|
|
1458
|
+
}
|
|
1459
|
+
interface HeadlessTestingNodeValueEventInit extends HeadlessTestingNodeEventInit {
|
|
1460
|
+
detail?: {
|
|
1461
|
+
value?: string;
|
|
1462
|
+
[key: string]: unknown;
|
|
1463
|
+
};
|
|
1464
|
+
}
|
|
1465
|
+
interface HeadlessTestingNodeInteractionHandlers {
|
|
1466
|
+
callMethod: (scopeId: string | null, methodName: string, event: Record<string, any>) => unknown;
|
|
1467
|
+
createScopeHandle: (scopeId: string | null) => {
|
|
1468
|
+
scopeId: string;
|
|
1469
|
+
snapshot: () => Promise<unknown>;
|
|
1470
|
+
} | null;
|
|
1471
|
+
createPageHandle: () => {
|
|
1472
|
+
data: (path?: string) => Promise<unknown>;
|
|
1473
|
+
};
|
|
1474
|
+
ownerScopeId: (scopeId: string | null) => string | null;
|
|
1475
|
+
}
|
|
547
1476
|
declare class HeadlessTestingNodeHandle {
|
|
548
1477
|
private readonly node;
|
|
549
|
-
|
|
1478
|
+
private readonly interactions?;
|
|
1479
|
+
constructor(node: DomNodeLike$3, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
|
|
550
1480
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
551
1481
|
$$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
552
1482
|
attr(name: string): Promise<string | undefined>;
|
|
553
|
-
dataset(): Promise<Record<string,
|
|
1483
|
+
dataset(): Promise<Record<string, string>>;
|
|
1484
|
+
scope(): Promise<{
|
|
1485
|
+
scopeId: string;
|
|
1486
|
+
snapshot: () => Promise<unknown>;
|
|
1487
|
+
} | null>;
|
|
1488
|
+
componentScope(): Promise<{
|
|
1489
|
+
scopeId: string;
|
|
1490
|
+
snapshot: () => Promise<unknown>;
|
|
1491
|
+
} | null>;
|
|
1492
|
+
pageScope(): Promise<{
|
|
1493
|
+
scopeId: string;
|
|
1494
|
+
snapshot: () => Promise<unknown>;
|
|
1495
|
+
} | null>;
|
|
1496
|
+
page(): Promise<{
|
|
1497
|
+
data: (path?: string) => Promise<unknown>;
|
|
1498
|
+
}>;
|
|
1499
|
+
ownerComponentScope(): Promise<{
|
|
1500
|
+
scopeId: string;
|
|
1501
|
+
snapshot: () => Promise<unknown>;
|
|
1502
|
+
} | null>;
|
|
554
1503
|
text(): Promise<string>;
|
|
1504
|
+
trigger(eventName: string, event?: HeadlessTestingNodeEventInit): Promise<unknown>;
|
|
1505
|
+
tap(event?: HeadlessTestingNodeEventInit): Promise<unknown>;
|
|
1506
|
+
input(value: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
|
|
1507
|
+
change(value: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
|
|
1508
|
+
blur(value?: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
|
|
555
1509
|
wxml(): Promise<string>;
|
|
556
1510
|
}
|
|
557
1511
|
//#endregion
|
|
558
1512
|
//#region src/view/render.d.ts
|
|
1513
|
+
interface DomNodeLike$2 {
|
|
1514
|
+
attribs?: Record<string, string>;
|
|
1515
|
+
children?: DomNodeLike$2[];
|
|
1516
|
+
data?: string;
|
|
1517
|
+
name?: string;
|
|
1518
|
+
parent?: DomNodeLike$2 | null;
|
|
1519
|
+
type?: string;
|
|
1520
|
+
}
|
|
1521
|
+
interface RenderedPageTree {
|
|
1522
|
+
root: DomNodeLike$2;
|
|
1523
|
+
wxml: string;
|
|
1524
|
+
}
|
|
1525
|
+
declare function renderPageTree(project: HeadlessProjectDescriptor, page: HeadlessPageInstance): RenderedPageTree;
|
|
1526
|
+
//#endregion
|
|
1527
|
+
//#region src/view/selectorQuery.d.ts
|
|
559
1528
|
interface DomNodeLike$1 {
|
|
560
1529
|
attribs?: Record<string, string>;
|
|
561
1530
|
children?: DomNodeLike$1[];
|
|
@@ -564,11 +1533,13 @@ interface DomNodeLike$1 {
|
|
|
564
1533
|
parent?: DomNodeLike$1 | null;
|
|
565
1534
|
type?: string;
|
|
566
1535
|
}
|
|
567
|
-
interface
|
|
1536
|
+
interface HeadlessSelectorQueryResolverOptions {
|
|
1537
|
+
page: HeadlessPageInstance;
|
|
568
1538
|
root: DomNodeLike$1;
|
|
569
|
-
|
|
1539
|
+
windowInfo: HeadlessWxWindowInfoResult;
|
|
570
1540
|
}
|
|
571
|
-
declare function
|
|
1541
|
+
declare function executeSelectorQueryRequests(requests: HeadlessWxSelectorQueryRequest[], options: HeadlessSelectorQueryResolverOptions): (Record<string, any> | Record<string, any>[] | null)[];
|
|
1542
|
+
declare function resolveSelectorQueryScopeRoot(root: DomNodeLike$1, scopeId?: string | null): DomNodeLike$1;
|
|
572
1543
|
//#endregion
|
|
573
1544
|
//#region src/view/selectors.d.ts
|
|
574
1545
|
interface DomNodeLike {
|
|
@@ -582,27 +1553,117 @@ interface DomNodeLike {
|
|
|
582
1553
|
declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
|
|
583
1554
|
//#endregion
|
|
584
1555
|
//#region src/testing/pageHandle.d.ts
|
|
1556
|
+
interface HeadlessTestingWaitOptions {
|
|
1557
|
+
interval?: number;
|
|
1558
|
+
timeout?: number;
|
|
1559
|
+
}
|
|
1560
|
+
type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
|
|
1561
|
+
interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
|
|
1562
|
+
state?: 'attached' | 'detached';
|
|
1563
|
+
}
|
|
585
1564
|
declare class HeadlessTestingPageHandle {
|
|
586
1565
|
private readonly project;
|
|
587
1566
|
private readonly page;
|
|
588
|
-
|
|
1567
|
+
private readonly session?;
|
|
1568
|
+
constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance, session?: HeadlessSession | undefined);
|
|
1569
|
+
private resolveDataByPath;
|
|
1570
|
+
private pollUntil;
|
|
1571
|
+
private createScopeHandle;
|
|
589
1572
|
callMethod(methodName: string, ...args: any[]): Promise<any>;
|
|
590
1573
|
data(path?: string): Promise<any>;
|
|
1574
|
+
selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
|
|
1575
|
+
selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
|
|
591
1576
|
waitFor(ms?: number): Promise<void>;
|
|
592
1577
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
593
1578
|
$$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
1579
|
+
waitForSelector(selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<HeadlessTestingNodeHandle | null>;
|
|
1580
|
+
waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
|
|
1581
|
+
waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
|
|
1582
|
+
waitForText(text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
|
|
1583
|
+
waitForTextGone(text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
|
|
1584
|
+
waitForData(path: string, matcher?: HeadlessTestingDataMatcher, options?: HeadlessTestingWaitOptions): Promise<any>;
|
|
594
1585
|
wxml(): Promise<string>;
|
|
595
1586
|
}
|
|
596
1587
|
//#endregion
|
|
597
1588
|
//#region src/testing/sessionHandle.d.ts
|
|
1589
|
+
declare class HeadlessTestingScopeHandle {
|
|
1590
|
+
readonly scopeId: string;
|
|
1591
|
+
private readonly project;
|
|
1592
|
+
private readonly session;
|
|
1593
|
+
constructor(scopeId: string, project: HeadlessProjectDescriptor, session: HeadlessSession);
|
|
1594
|
+
private createScopeHandle;
|
|
1595
|
+
callMethod(methodName: string, ...args: any[]): Promise<any>;
|
|
1596
|
+
snapshot(): Promise<{
|
|
1597
|
+
data: Record<string, any>;
|
|
1598
|
+
methods: string[];
|
|
1599
|
+
properties: Record<string, any>;
|
|
1600
|
+
scopeId: string;
|
|
1601
|
+
type: "component";
|
|
1602
|
+
} | {
|
|
1603
|
+
data: Record<string, any>;
|
|
1604
|
+
methods: string[];
|
|
1605
|
+
properties: Record<string, string>;
|
|
1606
|
+
scopeId: string;
|
|
1607
|
+
type: "page";
|
|
1608
|
+
} | {
|
|
1609
|
+
data: any;
|
|
1610
|
+
methods: string[];
|
|
1611
|
+
properties: {};
|
|
1612
|
+
scopeId: string;
|
|
1613
|
+
type: "scope";
|
|
1614
|
+
} | null>;
|
|
1615
|
+
page(): Promise<HeadlessTestingPageHandle | null>;
|
|
1616
|
+
pageScope(): Promise<HeadlessTestingScopeHandle>;
|
|
1617
|
+
ownerComponent(): Promise<HeadlessTestingScopeHandle | null>;
|
|
1618
|
+
waitForOwnerComponent(options?: {
|
|
1619
|
+
interval?: number;
|
|
1620
|
+
timeout?: number;
|
|
1621
|
+
}): Promise<HeadlessTestingScopeHandle>;
|
|
1622
|
+
selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
|
|
1623
|
+
selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
|
|
1624
|
+
waitForComponent(selector: string, options?: {
|
|
1625
|
+
interval?: number;
|
|
1626
|
+
timeout?: number;
|
|
1627
|
+
}): Promise<HeadlessTestingScopeHandle>;
|
|
1628
|
+
waitForComponents(selector: string, count?: number, options?: {
|
|
1629
|
+
interval?: number;
|
|
1630
|
+
timeout?: number;
|
|
1631
|
+
}): Promise<HeadlessTestingScopeHandle[]>;
|
|
1632
|
+
}
|
|
598
1633
|
declare class HeadlessTestingSessionHandle {
|
|
599
1634
|
private readonly project;
|
|
600
1635
|
private readonly session;
|
|
601
1636
|
constructor(project: HeadlessProjectDescriptor, session: HeadlessSession);
|
|
1637
|
+
private waitFor;
|
|
1638
|
+
private pollUntil;
|
|
602
1639
|
close(): Promise<void>;
|
|
603
1640
|
currentPage(): Promise<HeadlessTestingPageHandle | null>;
|
|
604
1641
|
getCurrentPages(): Promise<HeadlessTestingPageHandle[]>;
|
|
1642
|
+
scopeSnapshot(scopeId: string): Promise<{
|
|
1643
|
+
data: Record<string, any>;
|
|
1644
|
+
methods: string[];
|
|
1645
|
+
properties: Record<string, any>;
|
|
1646
|
+
scopeId: string;
|
|
1647
|
+
type: "component";
|
|
1648
|
+
} | {
|
|
1649
|
+
data: Record<string, any>;
|
|
1650
|
+
methods: string[];
|
|
1651
|
+
properties: Record<string, string>;
|
|
1652
|
+
scopeId: string;
|
|
1653
|
+
type: "page";
|
|
1654
|
+
} | {
|
|
1655
|
+
data: any;
|
|
1656
|
+
methods: string[];
|
|
1657
|
+
properties: {};
|
|
1658
|
+
scopeId: string;
|
|
1659
|
+
type: "scope";
|
|
1660
|
+
} | null>;
|
|
1661
|
+
selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
|
|
1662
|
+
selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
|
|
1663
|
+
waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
|
|
1664
|
+
waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
|
|
605
1665
|
reLaunch(route: string): Promise<HeadlessTestingPageHandle>;
|
|
1666
|
+
waitForCurrentPage(route?: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingPageHandle>;
|
|
606
1667
|
pageScrollTo(scrollTop: number): Promise<void>;
|
|
607
1668
|
triggerPullDownRefresh(): Promise<void>;
|
|
608
1669
|
triggerReachBottom(): Promise<void>;
|
|
@@ -616,4 +1677,4 @@ interface HeadlessTestingLaunchOptions {
|
|
|
616
1677
|
}
|
|
617
1678
|
declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
|
|
618
1679
|
//#endregion
|
|
619
|
-
export { BrowserDirectoryFileLike, BrowserHeadlessSession, BrowserHeadlessSessionOptions, BrowserModuleLoader, BrowserRenderedPageTree, BrowserRendererContext, BrowserVirtualFiles, CreateBrowserProjectOptions, CreateComponentInstanceOptions, CreateProjectDescriptorOptions, HeadlessAppDefinition, HeadlessAppInstance, HeadlessBehaviorDefinition, HeadlessComponentDefinition, HeadlessComponentInstance, HeadlessHostLoadContext, HeadlessHostRegistries, HeadlessPageDefinition, HeadlessPageInstance, HeadlessProjectConfigFile, HeadlessProjectDescriptor, HeadlessRouteRecord, HeadlessSession, HeadlessSessionOptions, HeadlessTestingLaunchOptions, HeadlessTestingNodeHandle, HeadlessTestingPageHandle, HeadlessTestingSessionHandle, HeadlessWx, HeadlessWxCallbackOption, HeadlessWxDriver, HeadlessWxNavigateBackOption, HeadlessWxNavigateOption, HeadlessWxPageScrollToOption, HeadlessWxRequestLogEntry, HeadlessWxRequestMockDefinition, HeadlessWxRequestOption, HeadlessWxRequestSuccessResult, HeadlessWxRequestTask, HeadlessWxShowToastOption, HeadlessWxToastSnapshot, RenderedPageTree, cloneValue, coerceComponentPropertyValue, createAppInstance, createBrowserHeadlessSession, createBrowserModuleLoader, createBrowserProject, createBrowserVirtualFiles, createBrowserVirtualFilesFromDirectory, createComponentInstance, createHeadlessSession, createHeadlessWx, createHeadlessWxState, createHostRegistries, createPageInstance, createProjectDescriptor, hasBrowserVirtualFile, launch, loadProject, normalizeBrowserFilePath, normalizeComponentPropertyValue, querySelectorAll, readBrowserVirtualFile, registerAppDefinition, registerComponentDefinition, registerPageDefinition, renderBrowserPageTree, renderPageTree, resolveRoutesFromAppConfig, runComponentLifecycle, runComponentObservers, runComponentPageLifetime };
|
|
1680
|
+
export { BrowserDirectoryFileLike, BrowserHeadlessSession, BrowserHeadlessSessionOptions, BrowserModuleLoader, BrowserRenderedPageTree, BrowserRendererContext, BrowserVirtualFiles, CreateBrowserProjectOptions, CreateComponentInstanceOptions, CreateProjectDescriptorOptions, HeadlessAppDefinition, HeadlessAppInstance, HeadlessBehaviorDefinition, HeadlessComponentDefinition, HeadlessComponentInstance, HeadlessHostLoadContext, HeadlessHostRegistries, HeadlessPageDefinition, HeadlessPageInstance, HeadlessProjectConfigFile, HeadlessProjectDescriptor, HeadlessRouteRecord, HeadlessSelectorQueryResolverOptions, HeadlessSession, HeadlessSessionOptions, HeadlessTestingDataMatcher, HeadlessTestingLaunchOptions, HeadlessTestingNodeHandle, HeadlessTestingPageHandle, HeadlessTestingScopeHandle, HeadlessTestingSessionHandle, HeadlessTestingWaitForSelectorOptions, HeadlessTestingWaitOptions, HeadlessWx, HeadlessWxActionSheetLogEntry, HeadlessWxActionSheetMockDefinition, HeadlessWxAppBaseInfoResult, HeadlessWxCallbackOption, HeadlessWxClearStorageOption, HeadlessWxDriver, HeadlessWxGetAppBaseInfoOption, HeadlessWxGetNetworkTypeOption, HeadlessWxGetNetworkTypeResult, HeadlessWxGetStorageInfoOption, HeadlessWxGetStorageOption, HeadlessWxGetStorageResult, HeadlessWxGetSystemInfoOption, HeadlessWxGetWindowInfoOption, HeadlessWxHideLoadingOption, HeadlessWxHideNavigationBarLoadingOption, HeadlessWxLaunchOptions, HeadlessWxLoadingSnapshot, HeadlessWxMenuButtonBoundingClientRectResult, HeadlessWxModalLogEntry, HeadlessWxModalMockDefinition, HeadlessWxNavigateBackOption, HeadlessWxNavigateOption, HeadlessWxNetworkSnapshot, HeadlessWxNetworkStatusChangeCallback, HeadlessWxNetworkStatusChangeResult, HeadlessWxNetworkType, HeadlessWxPageScrollToOption, HeadlessWxRemoveStorageOption, HeadlessWxRequestLogEntry, HeadlessWxRequestMockDefinition, HeadlessWxRequestOption, HeadlessWxRequestSuccessResult, HeadlessWxRequestTask, HeadlessWxSelectorQuery, HeadlessWxSelectorQueryBoundingClientRectResult, HeadlessWxSelectorQueryFieldsOption, HeadlessWxSelectorQueryNode, HeadlessWxSelectorQueryRequest, HeadlessWxSelectorQueryScrollOffsetResult, HeadlessWxSetBackgroundColorOption, HeadlessWxSetBackgroundTextStyleOption, HeadlessWxSetNavigationBarColorOption, HeadlessWxSetNavigationBarTitleOption, HeadlessWxSetStorageOption, HeadlessWxSetTabBarBadgeOption, HeadlessWxShareMenuOption, HeadlessWxShareMenuSnapshot, HeadlessWxShowActionSheetOption, HeadlessWxShowActionSheetResult, HeadlessWxShowLoadingOption, HeadlessWxShowModalOption, HeadlessWxShowModalResult, HeadlessWxShowNavigationBarLoadingOption, HeadlessWxShowToastOption, HeadlessWxStorageInfoResult, HeadlessWxStorageResult, HeadlessWxSystemInfoResult, HeadlessWxTabBarItemOption, HeadlessWxTabBarOption, HeadlessWxToastSnapshot, HeadlessWxWindowInfoResult, RenderedPageTree, RuntimeRenderedPageTree, RuntimeRendererContext, cloneValue, coerceComponentPropertyValue, createAppInstance, createBrowserHeadlessSession, createBrowserModuleLoader, createBrowserProject, createBrowserVirtualFiles, createBrowserVirtualFilesFromDirectory, createComponentInstance, createHeadlessSession, createHeadlessWx, createHeadlessWxState, createHostRegistries, createPageInstance, createProjectDescriptor, executeSelectorQueryRequests, hasBrowserVirtualFile, launch, loadProject, normalizeBrowserFilePath, normalizeComponentPropertyValue, querySelectorAll, readBrowserVirtualFile, registerAppDefinition, registerComponentDefinition, registerPageDefinition, renderBrowserPageTree, renderPageTree, renderRuntimePageTree, resolveRoutesFromAppConfig, resolveSelectorQueryScopeRoot, runComponentLifecycle, runComponentObservers, runComponentPageLifetime };
|