@mpcore/simulator 0.0.1 → 0.0.2
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 +824 -26
- package/dist/index.mjs +1336 -66
- package/package.json +1 -1
package/dist/index.d.mts
CHANGED
|
@@ -37,6 +37,167 @@ interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
|
|
|
37
37
|
scrollTop?: number;
|
|
38
38
|
selector?: string;
|
|
39
39
|
}
|
|
40
|
+
interface HeadlessWxStorageResult {
|
|
41
|
+
errMsg: string;
|
|
42
|
+
}
|
|
43
|
+
interface HeadlessWxGetStorageResult extends HeadlessWxStorageResult {
|
|
44
|
+
data: unknown;
|
|
45
|
+
}
|
|
46
|
+
interface HeadlessWxStorageInfoResult extends HeadlessWxStorageResult {
|
|
47
|
+
currentSize: number;
|
|
48
|
+
keys: string[];
|
|
49
|
+
limitSize: number;
|
|
50
|
+
}
|
|
51
|
+
type HeadlessWxNetworkType = '2g' | '3g' | '4g' | '5g' | 'none' | 'unknown' | 'wifi';
|
|
52
|
+
interface HeadlessWxGetNetworkTypeResult {
|
|
53
|
+
errMsg: string;
|
|
54
|
+
networkType: HeadlessWxNetworkType;
|
|
55
|
+
}
|
|
56
|
+
interface HeadlessWxNetworkStatusChangeResult {
|
|
57
|
+
isConnected: boolean;
|
|
58
|
+
networkType: HeadlessWxNetworkType;
|
|
59
|
+
}
|
|
60
|
+
type HeadlessWxNetworkStatusChangeCallback = (result: HeadlessWxNetworkStatusChangeResult) => void;
|
|
61
|
+
interface HeadlessWxSystemInfoResult {
|
|
62
|
+
SDKVersion: string;
|
|
63
|
+
brand: string;
|
|
64
|
+
language: string;
|
|
65
|
+
model: string;
|
|
66
|
+
pixelRatio: number;
|
|
67
|
+
platform: string;
|
|
68
|
+
screenHeight: number;
|
|
69
|
+
screenWidth: number;
|
|
70
|
+
system: string;
|
|
71
|
+
version: string;
|
|
72
|
+
windowHeight: number;
|
|
73
|
+
windowWidth: number;
|
|
74
|
+
}
|
|
75
|
+
interface HeadlessWxAppBaseInfoResult {
|
|
76
|
+
SDKVersion: string;
|
|
77
|
+
enableDebug: boolean;
|
|
78
|
+
host: {
|
|
79
|
+
env: string;
|
|
80
|
+
};
|
|
81
|
+
language: string;
|
|
82
|
+
platform: string;
|
|
83
|
+
version: string;
|
|
84
|
+
}
|
|
85
|
+
interface HeadlessWxWindowInfoResult {
|
|
86
|
+
pixelRatio: number;
|
|
87
|
+
screenHeight: number;
|
|
88
|
+
screenWidth: number;
|
|
89
|
+
statusBarHeight: number;
|
|
90
|
+
windowHeight: number;
|
|
91
|
+
windowWidth: number;
|
|
92
|
+
}
|
|
93
|
+
interface HeadlessWxLaunchOptions {
|
|
94
|
+
path: string;
|
|
95
|
+
query: Record<string, string>;
|
|
96
|
+
referrerInfo: {
|
|
97
|
+
appId: string;
|
|
98
|
+
extraData: Record<string, never>;
|
|
99
|
+
};
|
|
100
|
+
scene: number;
|
|
101
|
+
}
|
|
102
|
+
interface HeadlessWxMenuButtonBoundingClientRectResult {
|
|
103
|
+
bottom: number;
|
|
104
|
+
height: number;
|
|
105
|
+
left: number;
|
|
106
|
+
right: number;
|
|
107
|
+
top: number;
|
|
108
|
+
width: number;
|
|
109
|
+
}
|
|
110
|
+
interface HeadlessWxSetStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
111
|
+
data: unknown;
|
|
112
|
+
key: string;
|
|
113
|
+
}
|
|
114
|
+
interface HeadlessWxGetStorageOption extends HeadlessWxCallbackOption<HeadlessWxGetStorageResult> {
|
|
115
|
+
key: string;
|
|
116
|
+
}
|
|
117
|
+
interface HeadlessWxGetStorageInfoOption extends HeadlessWxCallbackOption<HeadlessWxStorageInfoResult> {}
|
|
118
|
+
interface HeadlessWxGetNetworkTypeOption extends HeadlessWxCallbackOption<HeadlessWxGetNetworkTypeResult> {}
|
|
119
|
+
interface HeadlessWxGetSystemInfoOption extends HeadlessWxCallbackOption<HeadlessWxSystemInfoResult> {}
|
|
120
|
+
interface HeadlessWxGetWindowInfoOption extends HeadlessWxCallbackOption<HeadlessWxWindowInfoResult> {}
|
|
121
|
+
interface HeadlessWxGetAppBaseInfoOption extends HeadlessWxCallbackOption<HeadlessWxAppBaseInfoResult> {}
|
|
122
|
+
interface HeadlessWxRemoveStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
123
|
+
key: string;
|
|
124
|
+
}
|
|
125
|
+
interface HeadlessWxClearStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {}
|
|
126
|
+
interface HeadlessWxHideLoadingOption extends HeadlessWxCallbackOption<{
|
|
127
|
+
errMsg: string;
|
|
128
|
+
}> {}
|
|
129
|
+
interface HeadlessWxSetBackgroundTextStyleOption extends HeadlessWxCallbackOption<{
|
|
130
|
+
errMsg: string;
|
|
131
|
+
}> {
|
|
132
|
+
textStyle: string;
|
|
133
|
+
}
|
|
134
|
+
interface HeadlessWxSetBackgroundColorOption extends HeadlessWxCallbackOption<{
|
|
135
|
+
errMsg: string;
|
|
136
|
+
}> {
|
|
137
|
+
backgroundColor?: string;
|
|
138
|
+
backgroundColorBottom?: string;
|
|
139
|
+
backgroundColorTop?: string;
|
|
140
|
+
}
|
|
141
|
+
interface HeadlessWxSetNavigationBarTitleOption extends HeadlessWxCallbackOption<{
|
|
142
|
+
errMsg: string;
|
|
143
|
+
}> {
|
|
144
|
+
title: string;
|
|
145
|
+
}
|
|
146
|
+
interface HeadlessWxSetNavigationBarColorOption extends HeadlessWxCallbackOption<{
|
|
147
|
+
errMsg: string;
|
|
148
|
+
}> {
|
|
149
|
+
animation?: {
|
|
150
|
+
duration?: number;
|
|
151
|
+
timingFunction?: string;
|
|
152
|
+
};
|
|
153
|
+
backgroundColor?: string;
|
|
154
|
+
frontColor?: string;
|
|
155
|
+
}
|
|
156
|
+
interface HeadlessWxShowNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
157
|
+
errMsg: string;
|
|
158
|
+
}> {}
|
|
159
|
+
interface HeadlessWxHideNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
160
|
+
errMsg: string;
|
|
161
|
+
}> {}
|
|
162
|
+
interface HeadlessWxShareMenuOption extends HeadlessWxCallbackOption<{
|
|
163
|
+
errMsg: string;
|
|
164
|
+
}> {
|
|
165
|
+
isUpdatableMessage?: boolean;
|
|
166
|
+
menus?: string[];
|
|
167
|
+
withShareTicket?: boolean;
|
|
168
|
+
}
|
|
169
|
+
interface HeadlessWxTabBarOption extends HeadlessWxCallbackOption<{
|
|
170
|
+
errMsg: string;
|
|
171
|
+
}> {}
|
|
172
|
+
interface HeadlessWxTabBarItemOption extends HeadlessWxCallbackOption<{
|
|
173
|
+
errMsg: string;
|
|
174
|
+
}> {
|
|
175
|
+
index: number;
|
|
176
|
+
}
|
|
177
|
+
interface HeadlessWxSetTabBarBadgeOption extends HeadlessWxTabBarItemOption {
|
|
178
|
+
text: string;
|
|
179
|
+
}
|
|
180
|
+
interface HeadlessWxShowActionSheetResult {
|
|
181
|
+
errMsg: string;
|
|
182
|
+
tapIndex: number;
|
|
183
|
+
}
|
|
184
|
+
interface HeadlessWxShowActionSheetOption extends HeadlessWxCallbackOption<HeadlessWxShowActionSheetResult> {
|
|
185
|
+
itemList: string[];
|
|
186
|
+
}
|
|
187
|
+
interface HeadlessWxShowModalResult {
|
|
188
|
+
cancel: boolean;
|
|
189
|
+
confirm: boolean;
|
|
190
|
+
errMsg: string;
|
|
191
|
+
}
|
|
192
|
+
interface HeadlessWxShowModalOption extends HeadlessWxCallbackOption<HeadlessWxShowModalResult> {
|
|
193
|
+
cancelColor?: string;
|
|
194
|
+
cancelText?: string;
|
|
195
|
+
confirmColor?: string;
|
|
196
|
+
confirmText?: string;
|
|
197
|
+
content: string;
|
|
198
|
+
showCancel?: boolean;
|
|
199
|
+
title?: string;
|
|
200
|
+
}
|
|
40
201
|
interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
|
|
41
202
|
errMsg: string;
|
|
42
203
|
}> {
|
|
@@ -45,6 +206,12 @@ interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
|
|
|
45
206
|
mask?: boolean;
|
|
46
207
|
title: string;
|
|
47
208
|
}
|
|
209
|
+
interface HeadlessWxShowLoadingOption extends HeadlessWxCallbackOption<{
|
|
210
|
+
errMsg: string;
|
|
211
|
+
}> {
|
|
212
|
+
mask?: boolean;
|
|
213
|
+
title: string;
|
|
214
|
+
}
|
|
48
215
|
interface HeadlessWxRequestSuccessResult {
|
|
49
216
|
cookies: string[];
|
|
50
217
|
data: unknown;
|
|
@@ -62,44 +229,183 @@ interface HeadlessWxRequestTask {
|
|
|
62
229
|
abort: () => void;
|
|
63
230
|
}
|
|
64
231
|
interface HeadlessWxDriver {
|
|
232
|
+
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
65
233
|
clearStorageSync: () => void;
|
|
234
|
+
getEnterOptionsSync: () => HeadlessWxLaunchOptions;
|
|
235
|
+
getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
|
|
236
|
+
getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
|
|
237
|
+
getNetworkType: () => HeadlessWxGetNetworkTypeResult;
|
|
238
|
+
getStorageInfoSync: () => HeadlessWxStorageInfoResult;
|
|
66
239
|
getStorageSync: (key: string) => unknown;
|
|
240
|
+
getSystemInfoSync: () => HeadlessWxSystemInfoResult;
|
|
241
|
+
getWindowInfoSync: () => HeadlessWxWindowInfoResult;
|
|
242
|
+
hideLoading: () => {
|
|
243
|
+
errMsg: string;
|
|
244
|
+
};
|
|
67
245
|
hideToast: () => {
|
|
68
246
|
errMsg: string;
|
|
69
247
|
};
|
|
70
248
|
navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
|
|
71
249
|
navigateTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
250
|
+
nextTick: (callback?: () => void) => void;
|
|
251
|
+
offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
252
|
+
onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
72
253
|
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
73
254
|
reLaunch: (option: HeadlessWxNavigateOption) => unknown;
|
|
74
255
|
redirectTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
75
256
|
removeStorageSync: (key: string) => void;
|
|
76
|
-
request: (option: HeadlessWxRequestOption) =>
|
|
257
|
+
request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
|
|
258
|
+
setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
|
|
259
|
+
errMsg: string;
|
|
260
|
+
};
|
|
261
|
+
setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
|
|
262
|
+
errMsg: string;
|
|
263
|
+
};
|
|
77
264
|
setStorageSync: (key: string, value: unknown) => void;
|
|
265
|
+
setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
|
|
266
|
+
errMsg: string;
|
|
267
|
+
};
|
|
268
|
+
setNavigationBarTitle: (option: HeadlessWxSetNavigationBarTitleOption) => {
|
|
269
|
+
errMsg: string;
|
|
270
|
+
};
|
|
271
|
+
hideShareMenu: () => {
|
|
272
|
+
errMsg: string;
|
|
273
|
+
};
|
|
274
|
+
hideNavigationBarLoading: () => {
|
|
275
|
+
errMsg: string;
|
|
276
|
+
};
|
|
277
|
+
hideTabBar: () => {
|
|
278
|
+
errMsg: string;
|
|
279
|
+
};
|
|
280
|
+
hideTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
|
|
281
|
+
errMsg: string;
|
|
282
|
+
};
|
|
283
|
+
showShareMenu: (option: HeadlessWxShareMenuOption) => {
|
|
284
|
+
errMsg: string;
|
|
285
|
+
};
|
|
286
|
+
showNavigationBarLoading: () => {
|
|
287
|
+
errMsg: string;
|
|
288
|
+
};
|
|
289
|
+
showTabBar: () => {
|
|
290
|
+
errMsg: string;
|
|
291
|
+
};
|
|
292
|
+
showTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
|
|
293
|
+
errMsg: string;
|
|
294
|
+
};
|
|
295
|
+
showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult;
|
|
296
|
+
showLoading: (option: HeadlessWxShowLoadingOption) => {
|
|
297
|
+
errMsg: string;
|
|
298
|
+
};
|
|
299
|
+
showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult;
|
|
78
300
|
showToast: (option: HeadlessWxShowToastOption) => {
|
|
79
301
|
errMsg: string;
|
|
80
302
|
};
|
|
81
303
|
stopPullDownRefresh: () => void;
|
|
82
304
|
switchTab: (option: HeadlessWxNavigateOption) => unknown;
|
|
305
|
+
removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
|
|
306
|
+
errMsg: string;
|
|
307
|
+
};
|
|
308
|
+
setTabBarBadge: (option: HeadlessWxSetTabBarBadgeOption) => {
|
|
309
|
+
errMsg: string;
|
|
310
|
+
};
|
|
311
|
+
updateShareMenu: (option: HeadlessWxShareMenuOption) => {
|
|
312
|
+
errMsg: string;
|
|
313
|
+
};
|
|
83
314
|
}
|
|
84
315
|
interface HeadlessWx {
|
|
316
|
+
canIUse: (schema: string) => boolean;
|
|
317
|
+
clearStorage: (option?: HeadlessWxClearStorageOption) => HeadlessWxStorageResult | undefined;
|
|
85
318
|
clearStorageSync: () => void;
|
|
319
|
+
getEnterOptionsSync: () => HeadlessWxLaunchOptions;
|
|
320
|
+
getAppBaseInfo: (option?: HeadlessWxGetAppBaseInfoOption) => HeadlessWxAppBaseInfoResult | undefined;
|
|
321
|
+
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
322
|
+
getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
|
|
323
|
+
getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
|
|
324
|
+
getNetworkType: (option?: HeadlessWxGetNetworkTypeOption) => HeadlessWxGetNetworkTypeResult | undefined;
|
|
325
|
+
getStorageInfo: (option?: HeadlessWxGetStorageInfoOption) => HeadlessWxStorageInfoResult | undefined;
|
|
326
|
+
getStorageInfoSync: () => HeadlessWxStorageInfoResult;
|
|
327
|
+
getStorage: (option: HeadlessWxGetStorageOption) => HeadlessWxGetStorageResult | undefined;
|
|
86
328
|
getStorageSync: (key: string) => unknown;
|
|
329
|
+
getSystemInfo: (option?: HeadlessWxGetSystemInfoOption) => HeadlessWxSystemInfoResult | undefined;
|
|
330
|
+
getSystemInfoSync: () => HeadlessWxSystemInfoResult;
|
|
331
|
+
getWindowInfo: (option?: HeadlessWxGetWindowInfoOption) => HeadlessWxWindowInfoResult | undefined;
|
|
332
|
+
getWindowInfoSync: () => HeadlessWxWindowInfoResult;
|
|
333
|
+
hideLoading: (option?: HeadlessWxHideLoadingOption) => {
|
|
334
|
+
errMsg: string;
|
|
335
|
+
} | undefined;
|
|
87
336
|
hideToast: () => {
|
|
88
337
|
errMsg: string;
|
|
89
338
|
};
|
|
90
339
|
navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
|
|
91
340
|
navigateTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
341
|
+
nextTick: (callback?: () => void) => void;
|
|
342
|
+
offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
343
|
+
onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
92
344
|
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
93
345
|
reLaunch: (option: HeadlessWxNavigateOption) => unknown;
|
|
94
346
|
redirectTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
347
|
+
removeStorage: (option: HeadlessWxRemoveStorageOption) => HeadlessWxStorageResult | undefined;
|
|
95
348
|
removeStorageSync: (key: string) => void;
|
|
96
349
|
request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
|
|
350
|
+
setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
|
|
351
|
+
errMsg: string;
|
|
352
|
+
} | undefined;
|
|
353
|
+
setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
|
|
354
|
+
errMsg: string;
|
|
355
|
+
} | undefined;
|
|
356
|
+
setStorage: (option: HeadlessWxSetStorageOption) => HeadlessWxStorageResult | undefined;
|
|
97
357
|
setStorageSync: (key: string, value: unknown) => void;
|
|
358
|
+
setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
|
|
359
|
+
errMsg: string;
|
|
360
|
+
} | undefined;
|
|
361
|
+
setNavigationBarTitle: (option: HeadlessWxSetNavigationBarTitleOption) => {
|
|
362
|
+
errMsg: string;
|
|
363
|
+
} | undefined;
|
|
364
|
+
hideShareMenu: (option?: HeadlessWxCallbackOption<{
|
|
365
|
+
errMsg: string;
|
|
366
|
+
}>) => {
|
|
367
|
+
errMsg: string;
|
|
368
|
+
} | undefined;
|
|
369
|
+
hideNavigationBarLoading: (option?: HeadlessWxHideNavigationBarLoadingOption) => {
|
|
370
|
+
errMsg: string;
|
|
371
|
+
} | undefined;
|
|
372
|
+
hideTabBar: (option?: HeadlessWxTabBarOption) => {
|
|
373
|
+
errMsg: string;
|
|
374
|
+
} | undefined;
|
|
375
|
+
hideTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
|
|
376
|
+
errMsg: string;
|
|
377
|
+
} | undefined;
|
|
378
|
+
showShareMenu: (option?: HeadlessWxShareMenuOption) => {
|
|
379
|
+
errMsg: string;
|
|
380
|
+
} | undefined;
|
|
381
|
+
showNavigationBarLoading: (option?: HeadlessWxShowNavigationBarLoadingOption) => {
|
|
382
|
+
errMsg: string;
|
|
383
|
+
} | undefined;
|
|
384
|
+
showTabBar: (option?: HeadlessWxTabBarOption) => {
|
|
385
|
+
errMsg: string;
|
|
386
|
+
} | undefined;
|
|
387
|
+
showTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
|
|
388
|
+
errMsg: string;
|
|
389
|
+
} | undefined;
|
|
390
|
+
showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult | undefined;
|
|
391
|
+
showLoading: (option: HeadlessWxShowLoadingOption) => {
|
|
392
|
+
errMsg: string;
|
|
393
|
+
} | undefined;
|
|
394
|
+
showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult | undefined;
|
|
98
395
|
showToast: (option: HeadlessWxShowToastOption) => {
|
|
99
396
|
errMsg: string;
|
|
100
397
|
} | undefined;
|
|
101
398
|
stopPullDownRefresh: () => void;
|
|
102
399
|
switchTab: (option: HeadlessWxNavigateOption) => unknown;
|
|
400
|
+
removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
|
|
401
|
+
errMsg: string;
|
|
402
|
+
} | undefined;
|
|
403
|
+
setTabBarBadge: (option: HeadlessWxSetTabBarBadgeOption) => {
|
|
404
|
+
errMsg: string;
|
|
405
|
+
} | undefined;
|
|
406
|
+
updateShareMenu: (option?: HeadlessWxShareMenuOption) => {
|
|
407
|
+
errMsg: string;
|
|
408
|
+
} | undefined;
|
|
103
409
|
}
|
|
104
410
|
declare function createHeadlessWx(driver: HeadlessWxDriver): HeadlessWx;
|
|
105
411
|
//#endregion
|
|
@@ -193,9 +499,32 @@ declare function createComponentInstance(options: CreateComponentInstanceOptions
|
|
|
193
499
|
declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
|
|
194
500
|
declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
|
|
195
501
|
//#endregion
|
|
502
|
+
//#region src/project/pageConfig.d.ts
|
|
503
|
+
interface HeadlessNavigationBarSnapshot {
|
|
504
|
+
animation: {
|
|
505
|
+
duration?: number;
|
|
506
|
+
timingFunction?: string;
|
|
507
|
+
} | null;
|
|
508
|
+
backgroundColor: string;
|
|
509
|
+
frontColor: string;
|
|
510
|
+
loading: boolean;
|
|
511
|
+
title: string;
|
|
512
|
+
}
|
|
513
|
+
type HeadlessBackgroundTextStyle = 'dark' | 'light';
|
|
514
|
+
interface HeadlessBackgroundSnapshot {
|
|
515
|
+
backgroundColor: string;
|
|
516
|
+
backgroundColorBottom: string;
|
|
517
|
+
backgroundColorTop: string;
|
|
518
|
+
textStyle: HeadlessBackgroundTextStyle;
|
|
519
|
+
}
|
|
520
|
+
//#endregion
|
|
196
521
|
//#region src/runtime/pageInstance.d.ts
|
|
197
522
|
interface HeadlessPageInstance extends Record<string, any> {
|
|
523
|
+
__background__?: HeadlessBackgroundSnapshot;
|
|
524
|
+
__backgroundTextStyle__?: HeadlessBackgroundTextStyle;
|
|
198
525
|
__lastChangedKeys__?: string[];
|
|
526
|
+
__navigationBar__?: HeadlessNavigationBarSnapshot;
|
|
527
|
+
__navigationBarTitle__?: string;
|
|
199
528
|
__route__: string;
|
|
200
529
|
data: Record<string, any>;
|
|
201
530
|
options: Record<string, string>;
|
|
@@ -204,7 +533,11 @@ interface HeadlessPageInstance extends Record<string, any> {
|
|
|
204
533
|
selectComponent?: (selector: string) => any;
|
|
205
534
|
setData: (patch: Record<string, any>, callback?: () => void) => void;
|
|
206
535
|
}
|
|
207
|
-
declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string
|
|
536
|
+
declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>, pageState?: {
|
|
537
|
+
background?: HeadlessBackgroundSnapshot;
|
|
538
|
+
backgroundTextStyle?: HeadlessBackgroundTextStyle;
|
|
539
|
+
navigationBar?: HeadlessNavigationBarSnapshot;
|
|
540
|
+
}): HeadlessPageInstance;
|
|
208
541
|
//#endregion
|
|
209
542
|
//#region src/browser/render.d.ts
|
|
210
543
|
interface DomNodeLike$3 {
|
|
@@ -257,13 +590,47 @@ interface HeadlessAppInstance extends Record<string, any> {
|
|
|
257
590
|
declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
|
|
258
591
|
//#endregion
|
|
259
592
|
//#region src/runtime/wxState.d.ts
|
|
593
|
+
interface HeadlessWxLoadingSnapshot {
|
|
594
|
+
mask: boolean;
|
|
595
|
+
title: string;
|
|
596
|
+
}
|
|
260
597
|
interface HeadlessWxToastSnapshot {
|
|
261
598
|
duration: number;
|
|
262
599
|
icon: string;
|
|
263
600
|
mask: boolean;
|
|
264
601
|
title: string;
|
|
265
602
|
}
|
|
603
|
+
interface HeadlessWxNetworkSnapshot extends HeadlessWxNetworkStatusChangeResult {}
|
|
604
|
+
interface HeadlessWxShareMenuSnapshot {
|
|
605
|
+
isUpdatableMessage: boolean;
|
|
606
|
+
menus: string[];
|
|
607
|
+
visible: boolean;
|
|
608
|
+
withShareTicket: boolean;
|
|
609
|
+
}
|
|
610
|
+
interface HeadlessWxActionSheetMockDefinition {
|
|
611
|
+
cancel?: boolean;
|
|
612
|
+
tapIndex?: number;
|
|
613
|
+
}
|
|
614
|
+
interface HeadlessWxActionSheetLogEntry {
|
|
615
|
+
itemList: string[];
|
|
616
|
+
result?: HeadlessWxShowActionSheetResult;
|
|
617
|
+
}
|
|
618
|
+
interface HeadlessWxModalMockDefinition {
|
|
619
|
+
cancel?: boolean;
|
|
620
|
+
confirm?: boolean;
|
|
621
|
+
}
|
|
622
|
+
interface HeadlessWxModalLogEntry {
|
|
623
|
+
cancelColor: string;
|
|
624
|
+
cancelText: string;
|
|
625
|
+
confirmColor: string;
|
|
626
|
+
confirmText: string;
|
|
627
|
+
content: string;
|
|
628
|
+
result: HeadlessWxShowModalResult;
|
|
629
|
+
showCancel: boolean;
|
|
630
|
+
title: string;
|
|
631
|
+
}
|
|
266
632
|
interface HeadlessWxRequestMockDefinition {
|
|
633
|
+
delay?: number;
|
|
267
634
|
header?: Record<string, string>;
|
|
268
635
|
method?: string;
|
|
269
636
|
response: unknown | ((option: HeadlessWxRequestOption) => unknown);
|
|
@@ -280,6 +647,28 @@ interface HeadlessWxRequestLogEntry {
|
|
|
280
647
|
}
|
|
281
648
|
declare function createHeadlessWxState(): {
|
|
282
649
|
clearStorageSync(): void;
|
|
650
|
+
getActionSheetLogs(): {
|
|
651
|
+
itemList: string[];
|
|
652
|
+
result: {
|
|
653
|
+
errMsg: string;
|
|
654
|
+
tapIndex: number;
|
|
655
|
+
} | undefined;
|
|
656
|
+
}[];
|
|
657
|
+
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
658
|
+
getModalLogs(): {
|
|
659
|
+
result: {
|
|
660
|
+
cancel: boolean;
|
|
661
|
+
confirm: boolean;
|
|
662
|
+
errMsg: string;
|
|
663
|
+
};
|
|
664
|
+
cancelColor: string;
|
|
665
|
+
cancelText: string;
|
|
666
|
+
confirmColor: string;
|
|
667
|
+
confirmText: string;
|
|
668
|
+
content: string;
|
|
669
|
+
showCancel: boolean;
|
|
670
|
+
title: string;
|
|
671
|
+
}[];
|
|
283
672
|
getRequestLogs(): {
|
|
284
673
|
data: unknown;
|
|
285
674
|
header: {
|
|
@@ -298,26 +687,67 @@ declare function createHeadlessWxState(): {
|
|
|
298
687
|
method: string;
|
|
299
688
|
url: string;
|
|
300
689
|
}[];
|
|
690
|
+
getStorageInfoSync(): {
|
|
691
|
+
currentSize: number;
|
|
692
|
+
errMsg: string;
|
|
693
|
+
keys: string[];
|
|
694
|
+
limitSize: number;
|
|
695
|
+
};
|
|
301
696
|
getStorageSnapshot(): {
|
|
302
697
|
[k: string]: unknown;
|
|
303
698
|
};
|
|
304
699
|
getStorageSync(key: string): unknown;
|
|
700
|
+
getShareMenu(): {
|
|
701
|
+
isUpdatableMessage: boolean;
|
|
702
|
+
menus: string[];
|
|
703
|
+
visible: boolean;
|
|
704
|
+
withShareTicket: boolean;
|
|
705
|
+
};
|
|
706
|
+
getLoading(): {
|
|
707
|
+
mask: boolean;
|
|
708
|
+
title: string;
|
|
709
|
+
} | null;
|
|
710
|
+
hideShareMenu(): {
|
|
711
|
+
errMsg: string;
|
|
712
|
+
};
|
|
305
713
|
getToast(): {
|
|
306
714
|
duration: number;
|
|
307
715
|
icon: string;
|
|
308
716
|
mask: boolean;
|
|
309
717
|
title: string;
|
|
310
718
|
} | null;
|
|
719
|
+
hideLoading(): {
|
|
720
|
+
errMsg: string;
|
|
721
|
+
};
|
|
311
722
|
hideToast(): {
|
|
312
723
|
errMsg: string;
|
|
313
724
|
};
|
|
725
|
+
offNetworkStatusChange(callback?: HeadlessWxNetworkStatusChangeCallback): void;
|
|
314
726
|
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
727
|
+
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
728
|
+
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
729
|
+
onNetworkStatusChange(callback: HeadlessWxNetworkStatusChangeCallback): void;
|
|
315
730
|
removeStorageSync(key: string): void;
|
|
316
|
-
request(option: HeadlessWxRequestOption):
|
|
731
|
+
request(option: HeadlessWxRequestOption): HeadlessWxRequestTask;
|
|
317
732
|
setStorageSync(key: string, value: unknown): void;
|
|
733
|
+
setNetworkType(nextNetworkType: HeadlessWxNetworkType): {
|
|
734
|
+
errMsg: string;
|
|
735
|
+
networkType: HeadlessWxNetworkType;
|
|
736
|
+
};
|
|
737
|
+
showActionSheet(option: HeadlessWxShowActionSheetOption): HeadlessWxShowActionSheetResult;
|
|
738
|
+
showShareMenu(option?: HeadlessWxShareMenuOption): {
|
|
739
|
+
errMsg: string;
|
|
740
|
+
};
|
|
741
|
+
showLoading(option: HeadlessWxShowLoadingOption): {
|
|
742
|
+
errMsg: string;
|
|
743
|
+
};
|
|
744
|
+
showModal(option: HeadlessWxShowModalOption): HeadlessWxShowModalResult;
|
|
318
745
|
showToast(option: HeadlessWxShowToastOption): {
|
|
319
746
|
errMsg: string;
|
|
320
747
|
};
|
|
748
|
+
updateShareMenu(option?: HeadlessWxShareMenuOption): {
|
|
749
|
+
errMsg: string;
|
|
750
|
+
};
|
|
321
751
|
};
|
|
322
752
|
//#endregion
|
|
323
753
|
//#region src/browser/session.d.ts
|
|
@@ -325,15 +755,6 @@ interface BrowserHeadlessSessionOptions {
|
|
|
325
755
|
files: BrowserVirtualFiles;
|
|
326
756
|
project?: HeadlessProjectDescriptor;
|
|
327
757
|
}
|
|
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;
|
|
336
|
-
}
|
|
337
758
|
declare class BrowserHeadlessSession {
|
|
338
759
|
readonly files: BrowserVirtualFiles;
|
|
339
760
|
readonly project: HeadlessProjectDescriptor;
|
|
@@ -348,10 +769,39 @@ declare class BrowserHeadlessSession {
|
|
|
348
769
|
private readonly tabBarRoutes;
|
|
349
770
|
private readonly tabPages;
|
|
350
771
|
private readonly tabBarItems;
|
|
772
|
+
private readonly tabBarState;
|
|
773
|
+
private tabBarVisible;
|
|
774
|
+
private readonly systemInfo;
|
|
775
|
+
private enterOptions;
|
|
776
|
+
private launchOptions;
|
|
351
777
|
private readonly wxState;
|
|
352
778
|
constructor(options: BrowserHeadlessSessionOptions);
|
|
353
779
|
getApp(): HeadlessAppInstance | null;
|
|
354
780
|
getCurrentPages(): HeadlessPageInstance[];
|
|
781
|
+
getCurrentPageNavigationBarTitle(): string | null;
|
|
782
|
+
getCurrentPageNavigationBar(): {
|
|
783
|
+
animation: {
|
|
784
|
+
duration?: number;
|
|
785
|
+
timingFunction?: string;
|
|
786
|
+
} | null;
|
|
787
|
+
backgroundColor: string;
|
|
788
|
+
frontColor: string;
|
|
789
|
+
loading: boolean;
|
|
790
|
+
title: string;
|
|
791
|
+
} | null;
|
|
792
|
+
getCurrentPageBackground(): {
|
|
793
|
+
backgroundColor: string;
|
|
794
|
+
backgroundColorBottom: string;
|
|
795
|
+
backgroundColorTop: string;
|
|
796
|
+
textStyle: HeadlessBackgroundTextStyle;
|
|
797
|
+
} | null;
|
|
798
|
+
getActionSheetLogs(): {
|
|
799
|
+
itemList: string[];
|
|
800
|
+
result: {
|
|
801
|
+
errMsg: string;
|
|
802
|
+
tapIndex: number;
|
|
803
|
+
} | undefined;
|
|
804
|
+
}[];
|
|
355
805
|
getRequestLogs(): {
|
|
356
806
|
data: unknown;
|
|
357
807
|
header: {
|
|
@@ -373,13 +823,153 @@ declare class BrowserHeadlessSession {
|
|
|
373
823
|
getStorageSnapshot(): {
|
|
374
824
|
[k: string]: unknown;
|
|
375
825
|
};
|
|
826
|
+
getShareMenu(): {
|
|
827
|
+
isUpdatableMessage: boolean;
|
|
828
|
+
menus: string[];
|
|
829
|
+
visible: boolean;
|
|
830
|
+
withShareTicket: boolean;
|
|
831
|
+
};
|
|
832
|
+
getTabBar(): {
|
|
833
|
+
visible: boolean;
|
|
834
|
+
};
|
|
835
|
+
getTabBarSnapshot(): {
|
|
836
|
+
items: {
|
|
837
|
+
badge: string | null;
|
|
838
|
+
index: number;
|
|
839
|
+
pagePath: string;
|
|
840
|
+
redDot: boolean;
|
|
841
|
+
text: string | undefined;
|
|
842
|
+
}[];
|
|
843
|
+
visible: boolean;
|
|
844
|
+
};
|
|
845
|
+
getStorageInfo(): {
|
|
846
|
+
currentSize: number;
|
|
847
|
+
errMsg: string;
|
|
848
|
+
keys: string[];
|
|
849
|
+
limitSize: number;
|
|
850
|
+
};
|
|
851
|
+
getSystemInfo(): {
|
|
852
|
+
SDKVersion: string;
|
|
853
|
+
brand: string;
|
|
854
|
+
language: string;
|
|
855
|
+
model: string;
|
|
856
|
+
pixelRatio: number;
|
|
857
|
+
platform: string;
|
|
858
|
+
screenHeight: number;
|
|
859
|
+
screenWidth: number;
|
|
860
|
+
system: string;
|
|
861
|
+
version: string;
|
|
862
|
+
windowHeight: number;
|
|
863
|
+
windowWidth: number;
|
|
864
|
+
};
|
|
865
|
+
getWindowInfo(): HeadlessWxWindowInfoResult;
|
|
866
|
+
getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
|
|
867
|
+
getLaunchOptions(): {
|
|
868
|
+
query: {
|
|
869
|
+
[x: string]: string;
|
|
870
|
+
};
|
|
871
|
+
referrerInfo: {
|
|
872
|
+
extraData: {
|
|
873
|
+
[x: string]: never;
|
|
874
|
+
};
|
|
875
|
+
appId: string;
|
|
876
|
+
};
|
|
877
|
+
path: string;
|
|
878
|
+
scene: number;
|
|
879
|
+
};
|
|
880
|
+
getEnterOptions(): {
|
|
881
|
+
query: {
|
|
882
|
+
[x: string]: string;
|
|
883
|
+
};
|
|
884
|
+
referrerInfo: {
|
|
885
|
+
extraData: {
|
|
886
|
+
[x: string]: never;
|
|
887
|
+
};
|
|
888
|
+
appId: string;
|
|
889
|
+
};
|
|
890
|
+
path: string;
|
|
891
|
+
scene: number;
|
|
892
|
+
};
|
|
893
|
+
getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
|
|
894
|
+
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
895
|
+
getLoading(): {
|
|
896
|
+
mask: boolean;
|
|
897
|
+
title: string;
|
|
898
|
+
} | null;
|
|
899
|
+
getModalLogs(): {
|
|
900
|
+
result: {
|
|
901
|
+
cancel: boolean;
|
|
902
|
+
confirm: boolean;
|
|
903
|
+
errMsg: string;
|
|
904
|
+
};
|
|
905
|
+
cancelColor: string;
|
|
906
|
+
cancelText: string;
|
|
907
|
+
confirmColor: string;
|
|
908
|
+
confirmText: string;
|
|
909
|
+
content: string;
|
|
910
|
+
showCancel: boolean;
|
|
911
|
+
title: string;
|
|
912
|
+
}[];
|
|
376
913
|
getToast(): {
|
|
377
914
|
duration: number;
|
|
378
915
|
icon: string;
|
|
379
916
|
mask: boolean;
|
|
380
917
|
title: string;
|
|
381
918
|
} | null;
|
|
919
|
+
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
920
|
+
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
382
921
|
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
922
|
+
setNetworkType(networkType: HeadlessWxNetworkType): {
|
|
923
|
+
errMsg: string;
|
|
924
|
+
networkType: HeadlessWxNetworkType;
|
|
925
|
+
};
|
|
926
|
+
setBackgroundTextStyle(textStyle: string): {
|
|
927
|
+
errMsg: string;
|
|
928
|
+
};
|
|
929
|
+
setBackgroundColor(option: {
|
|
930
|
+
backgroundColor?: string;
|
|
931
|
+
backgroundColorBottom?: string;
|
|
932
|
+
backgroundColorTop?: string;
|
|
933
|
+
}): {
|
|
934
|
+
errMsg: string;
|
|
935
|
+
};
|
|
936
|
+
setNavigationBarTitle(title: string): {
|
|
937
|
+
errMsg: string;
|
|
938
|
+
};
|
|
939
|
+
setNavigationBarColor(option: {
|
|
940
|
+
animation?: {
|
|
941
|
+
duration?: number;
|
|
942
|
+
timingFunction?: string;
|
|
943
|
+
};
|
|
944
|
+
backgroundColor?: string;
|
|
945
|
+
frontColor?: string;
|
|
946
|
+
}): {
|
|
947
|
+
errMsg: string;
|
|
948
|
+
};
|
|
949
|
+
showNavigationBarLoading(): {
|
|
950
|
+
errMsg: string;
|
|
951
|
+
};
|
|
952
|
+
hideNavigationBarLoading(): {
|
|
953
|
+
errMsg: string;
|
|
954
|
+
};
|
|
955
|
+
hideTabBar(): {
|
|
956
|
+
errMsg: string;
|
|
957
|
+
};
|
|
958
|
+
hideTabBarRedDot(index: number): {
|
|
959
|
+
errMsg: string;
|
|
960
|
+
};
|
|
961
|
+
showTabBar(): {
|
|
962
|
+
errMsg: string;
|
|
963
|
+
};
|
|
964
|
+
showTabBarRedDot(index: number): {
|
|
965
|
+
errMsg: string;
|
|
966
|
+
};
|
|
967
|
+
removeTabBarBadge(index: number): {
|
|
968
|
+
errMsg: string;
|
|
969
|
+
};
|
|
970
|
+
setTabBarBadge(index: number, text: string): {
|
|
971
|
+
errMsg: string;
|
|
972
|
+
};
|
|
383
973
|
getScopeSnapshot(scopeId: string): {
|
|
384
974
|
data: any;
|
|
385
975
|
methods: string[];
|
|
@@ -419,7 +1009,7 @@ declare class BrowserHeadlessSession {
|
|
|
419
1009
|
id?: string;
|
|
420
1010
|
};
|
|
421
1011
|
}): any;
|
|
422
|
-
bootstrap(launchOptions?:
|
|
1012
|
+
bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
|
|
423
1013
|
reLaunch(url: string): HeadlessPageInstance;
|
|
424
1014
|
navigateTo(url: string): HeadlessPageInstance;
|
|
425
1015
|
redirectTo(url: string): HeadlessPageInstance;
|
|
@@ -438,6 +1028,7 @@ declare class BrowserHeadlessSession {
|
|
|
438
1028
|
private removePageInstance;
|
|
439
1029
|
private resolveNavigationTarget;
|
|
440
1030
|
private resolveTabBarItem;
|
|
1031
|
+
private requireTabBarItem;
|
|
441
1032
|
private unloadAllPages;
|
|
442
1033
|
private unloadPage;
|
|
443
1034
|
private requireCurrentPage;
|
|
@@ -453,15 +1044,6 @@ declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
|
|
|
453
1044
|
interface HeadlessSessionOptions {
|
|
454
1045
|
projectPath: string;
|
|
455
1046
|
}
|
|
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;
|
|
464
|
-
}
|
|
465
1047
|
declare class HeadlessSession {
|
|
466
1048
|
readonly project: HeadlessProjectDescriptor;
|
|
467
1049
|
private appDefinition;
|
|
@@ -473,10 +1055,39 @@ declare class HeadlessSession {
|
|
|
473
1055
|
private readonly tabBarRoutes;
|
|
474
1056
|
private readonly tabPages;
|
|
475
1057
|
private readonly tabBarItems;
|
|
1058
|
+
private readonly tabBarState;
|
|
1059
|
+
private tabBarVisible;
|
|
1060
|
+
private readonly systemInfo;
|
|
1061
|
+
private enterOptions;
|
|
1062
|
+
private launchOptions;
|
|
476
1063
|
private readonly wxState;
|
|
477
1064
|
constructor(options: HeadlessSessionOptions);
|
|
478
1065
|
getApp(): HeadlessAppInstance | null;
|
|
479
1066
|
getCurrentPages(): HeadlessPageInstance[];
|
|
1067
|
+
getCurrentPageNavigationBarTitle(): string | null;
|
|
1068
|
+
getCurrentPageNavigationBar(): {
|
|
1069
|
+
animation: {
|
|
1070
|
+
duration?: number;
|
|
1071
|
+
timingFunction?: string;
|
|
1072
|
+
} | null;
|
|
1073
|
+
backgroundColor: string;
|
|
1074
|
+
frontColor: string;
|
|
1075
|
+
loading: boolean;
|
|
1076
|
+
title: string;
|
|
1077
|
+
} | null;
|
|
1078
|
+
getCurrentPageBackground(): {
|
|
1079
|
+
backgroundColor: string;
|
|
1080
|
+
backgroundColorBottom: string;
|
|
1081
|
+
backgroundColorTop: string;
|
|
1082
|
+
textStyle: HeadlessBackgroundTextStyle;
|
|
1083
|
+
} | null;
|
|
1084
|
+
getActionSheetLogs(): {
|
|
1085
|
+
itemList: string[];
|
|
1086
|
+
result: {
|
|
1087
|
+
errMsg: string;
|
|
1088
|
+
tapIndex: number;
|
|
1089
|
+
} | undefined;
|
|
1090
|
+
}[];
|
|
480
1091
|
getRequestLogs(): {
|
|
481
1092
|
data: unknown;
|
|
482
1093
|
header: {
|
|
@@ -498,14 +1109,154 @@ declare class HeadlessSession {
|
|
|
498
1109
|
getStorageSnapshot(): {
|
|
499
1110
|
[k: string]: unknown;
|
|
500
1111
|
};
|
|
1112
|
+
getShareMenu(): {
|
|
1113
|
+
isUpdatableMessage: boolean;
|
|
1114
|
+
menus: string[];
|
|
1115
|
+
visible: boolean;
|
|
1116
|
+
withShareTicket: boolean;
|
|
1117
|
+
};
|
|
1118
|
+
getTabBar(): {
|
|
1119
|
+
visible: boolean;
|
|
1120
|
+
};
|
|
1121
|
+
getTabBarSnapshot(): {
|
|
1122
|
+
items: {
|
|
1123
|
+
badge: string | null;
|
|
1124
|
+
index: number;
|
|
1125
|
+
pagePath: string;
|
|
1126
|
+
redDot: boolean;
|
|
1127
|
+
text: string | undefined;
|
|
1128
|
+
}[];
|
|
1129
|
+
visible: boolean;
|
|
1130
|
+
};
|
|
1131
|
+
getStorageInfo(): {
|
|
1132
|
+
currentSize: number;
|
|
1133
|
+
errMsg: string;
|
|
1134
|
+
keys: string[];
|
|
1135
|
+
limitSize: number;
|
|
1136
|
+
};
|
|
1137
|
+
getSystemInfo(): {
|
|
1138
|
+
SDKVersion: string;
|
|
1139
|
+
brand: string;
|
|
1140
|
+
language: string;
|
|
1141
|
+
model: string;
|
|
1142
|
+
pixelRatio: number;
|
|
1143
|
+
platform: string;
|
|
1144
|
+
screenHeight: number;
|
|
1145
|
+
screenWidth: number;
|
|
1146
|
+
system: string;
|
|
1147
|
+
version: string;
|
|
1148
|
+
windowHeight: number;
|
|
1149
|
+
windowWidth: number;
|
|
1150
|
+
};
|
|
1151
|
+
getWindowInfo(): HeadlessWxWindowInfoResult;
|
|
1152
|
+
getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
|
|
1153
|
+
getLaunchOptions(): {
|
|
1154
|
+
query: {
|
|
1155
|
+
[x: string]: string;
|
|
1156
|
+
};
|
|
1157
|
+
referrerInfo: {
|
|
1158
|
+
extraData: {
|
|
1159
|
+
[x: string]: never;
|
|
1160
|
+
};
|
|
1161
|
+
appId: string;
|
|
1162
|
+
};
|
|
1163
|
+
path: string;
|
|
1164
|
+
scene: number;
|
|
1165
|
+
};
|
|
1166
|
+
getEnterOptions(): {
|
|
1167
|
+
query: {
|
|
1168
|
+
[x: string]: string;
|
|
1169
|
+
};
|
|
1170
|
+
referrerInfo: {
|
|
1171
|
+
extraData: {
|
|
1172
|
+
[x: string]: never;
|
|
1173
|
+
};
|
|
1174
|
+
appId: string;
|
|
1175
|
+
};
|
|
1176
|
+
path: string;
|
|
1177
|
+
scene: number;
|
|
1178
|
+
};
|
|
1179
|
+
getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
|
|
1180
|
+
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
1181
|
+
getLoading(): {
|
|
1182
|
+
mask: boolean;
|
|
1183
|
+
title: string;
|
|
1184
|
+
} | null;
|
|
1185
|
+
getModalLogs(): {
|
|
1186
|
+
result: {
|
|
1187
|
+
cancel: boolean;
|
|
1188
|
+
confirm: boolean;
|
|
1189
|
+
errMsg: string;
|
|
1190
|
+
};
|
|
1191
|
+
cancelColor: string;
|
|
1192
|
+
cancelText: string;
|
|
1193
|
+
confirmColor: string;
|
|
1194
|
+
confirmText: string;
|
|
1195
|
+
content: string;
|
|
1196
|
+
showCancel: boolean;
|
|
1197
|
+
title: string;
|
|
1198
|
+
}[];
|
|
501
1199
|
getToast(): {
|
|
502
1200
|
duration: number;
|
|
503
1201
|
icon: string;
|
|
504
1202
|
mask: boolean;
|
|
505
1203
|
title: string;
|
|
506
1204
|
} | null;
|
|
1205
|
+
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
1206
|
+
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
507
1207
|
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
508
|
-
|
|
1208
|
+
setNetworkType(networkType: HeadlessWxNetworkType): {
|
|
1209
|
+
errMsg: string;
|
|
1210
|
+
networkType: HeadlessWxNetworkType;
|
|
1211
|
+
};
|
|
1212
|
+
setBackgroundTextStyle(textStyle: string): {
|
|
1213
|
+
errMsg: string;
|
|
1214
|
+
};
|
|
1215
|
+
setBackgroundColor(option: {
|
|
1216
|
+
backgroundColor?: string;
|
|
1217
|
+
backgroundColorBottom?: string;
|
|
1218
|
+
backgroundColorTop?: string;
|
|
1219
|
+
}): {
|
|
1220
|
+
errMsg: string;
|
|
1221
|
+
};
|
|
1222
|
+
setNavigationBarTitle(title: string): {
|
|
1223
|
+
errMsg: string;
|
|
1224
|
+
};
|
|
1225
|
+
setNavigationBarColor(option: {
|
|
1226
|
+
animation?: {
|
|
1227
|
+
duration?: number;
|
|
1228
|
+
timingFunction?: string;
|
|
1229
|
+
};
|
|
1230
|
+
backgroundColor?: string;
|
|
1231
|
+
frontColor?: string;
|
|
1232
|
+
}): {
|
|
1233
|
+
errMsg: string;
|
|
1234
|
+
};
|
|
1235
|
+
showNavigationBarLoading(): {
|
|
1236
|
+
errMsg: string;
|
|
1237
|
+
};
|
|
1238
|
+
hideNavigationBarLoading(): {
|
|
1239
|
+
errMsg: string;
|
|
1240
|
+
};
|
|
1241
|
+
hideTabBar(): {
|
|
1242
|
+
errMsg: string;
|
|
1243
|
+
};
|
|
1244
|
+
hideTabBarRedDot(index: number): {
|
|
1245
|
+
errMsg: string;
|
|
1246
|
+
};
|
|
1247
|
+
showTabBar(): {
|
|
1248
|
+
errMsg: string;
|
|
1249
|
+
};
|
|
1250
|
+
showTabBarRedDot(index: number): {
|
|
1251
|
+
errMsg: string;
|
|
1252
|
+
};
|
|
1253
|
+
removeTabBarBadge(index: number): {
|
|
1254
|
+
errMsg: string;
|
|
1255
|
+
};
|
|
1256
|
+
setTabBarBadge(index: number, text: string): {
|
|
1257
|
+
errMsg: string;
|
|
1258
|
+
};
|
|
1259
|
+
bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
|
|
509
1260
|
reLaunch(url: string): HeadlessPageInstance;
|
|
510
1261
|
navigateTo(url: string): HeadlessPageInstance;
|
|
511
1262
|
redirectTo(url: string): HeadlessPageInstance;
|
|
@@ -527,6 +1278,7 @@ declare class HeadlessSession {
|
|
|
527
1278
|
private createFreshPage;
|
|
528
1279
|
private isTabBarRoute;
|
|
529
1280
|
private resolveTabBarItem;
|
|
1281
|
+
private requireTabBarItem;
|
|
530
1282
|
private removePageInstance;
|
|
531
1283
|
private resolveNavigationTarget;
|
|
532
1284
|
private unloadAllPages;
|
|
@@ -544,14 +1296,43 @@ interface DomNodeLike$2 {
|
|
|
544
1296
|
parent?: DomNodeLike$2 | null;
|
|
545
1297
|
type?: string;
|
|
546
1298
|
}
|
|
1299
|
+
interface HeadlessTestingNodeEventInit {
|
|
1300
|
+
currentTarget?: {
|
|
1301
|
+
dataset?: Record<string, string>;
|
|
1302
|
+
id?: string;
|
|
1303
|
+
};
|
|
1304
|
+
dataset?: Record<string, string>;
|
|
1305
|
+
detail?: unknown;
|
|
1306
|
+
id?: string;
|
|
1307
|
+
mark?: Record<string, unknown>;
|
|
1308
|
+
target?: {
|
|
1309
|
+
dataset?: Record<string, string>;
|
|
1310
|
+
id?: string;
|
|
1311
|
+
};
|
|
1312
|
+
}
|
|
1313
|
+
interface HeadlessTestingNodeValueEventInit extends HeadlessTestingNodeEventInit {
|
|
1314
|
+
detail?: {
|
|
1315
|
+
value?: string;
|
|
1316
|
+
[key: string]: unknown;
|
|
1317
|
+
};
|
|
1318
|
+
}
|
|
1319
|
+
interface HeadlessTestingNodeInteractionHandlers {
|
|
1320
|
+
callMethod: (methodName: string, event: Record<string, any>) => unknown;
|
|
1321
|
+
}
|
|
547
1322
|
declare class HeadlessTestingNodeHandle {
|
|
548
1323
|
private readonly node;
|
|
549
|
-
|
|
1324
|
+
private readonly interactions?;
|
|
1325
|
+
constructor(node: DomNodeLike$2, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
|
|
550
1326
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
551
1327
|
$$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
552
1328
|
attr(name: string): Promise<string | undefined>;
|
|
553
|
-
dataset(): Promise<Record<string,
|
|
1329
|
+
dataset(): Promise<Record<string, string>>;
|
|
554
1330
|
text(): Promise<string>;
|
|
1331
|
+
trigger(eventName: string, event?: HeadlessTestingNodeEventInit): Promise<unknown>;
|
|
1332
|
+
tap(event?: HeadlessTestingNodeEventInit): Promise<unknown>;
|
|
1333
|
+
input(value: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
|
|
1334
|
+
change(value: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
|
|
1335
|
+
blur(value?: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
|
|
555
1336
|
wxml(): Promise<string>;
|
|
556
1337
|
}
|
|
557
1338
|
//#endregion
|
|
@@ -582,15 +1363,29 @@ interface DomNodeLike {
|
|
|
582
1363
|
declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
|
|
583
1364
|
//#endregion
|
|
584
1365
|
//#region src/testing/pageHandle.d.ts
|
|
1366
|
+
interface HeadlessTestingWaitOptions {
|
|
1367
|
+
interval?: number;
|
|
1368
|
+
timeout?: number;
|
|
1369
|
+
}
|
|
1370
|
+
type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
|
|
1371
|
+
interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
|
|
1372
|
+
state?: 'attached' | 'detached';
|
|
1373
|
+
}
|
|
585
1374
|
declare class HeadlessTestingPageHandle {
|
|
586
1375
|
private readonly project;
|
|
587
1376
|
private readonly page;
|
|
588
1377
|
constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance);
|
|
1378
|
+
private resolveDataByPath;
|
|
1379
|
+
private pollUntil;
|
|
589
1380
|
callMethod(methodName: string, ...args: any[]): Promise<any>;
|
|
590
1381
|
data(path?: string): Promise<any>;
|
|
591
1382
|
waitFor(ms?: number): Promise<void>;
|
|
592
1383
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
593
1384
|
$$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
1385
|
+
waitForSelector(selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<HeadlessTestingNodeHandle | null>;
|
|
1386
|
+
waitForText(text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
|
|
1387
|
+
waitForTextGone(text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
|
|
1388
|
+
waitForData(path: string, matcher?: HeadlessTestingDataMatcher, options?: HeadlessTestingWaitOptions): Promise<any>;
|
|
594
1389
|
wxml(): Promise<string>;
|
|
595
1390
|
}
|
|
596
1391
|
//#endregion
|
|
@@ -599,10 +1394,13 @@ declare class HeadlessTestingSessionHandle {
|
|
|
599
1394
|
private readonly project;
|
|
600
1395
|
private readonly session;
|
|
601
1396
|
constructor(project: HeadlessProjectDescriptor, session: HeadlessSession);
|
|
1397
|
+
private waitFor;
|
|
1398
|
+
private pollUntil;
|
|
602
1399
|
close(): Promise<void>;
|
|
603
1400
|
currentPage(): Promise<HeadlessTestingPageHandle | null>;
|
|
604
1401
|
getCurrentPages(): Promise<HeadlessTestingPageHandle[]>;
|
|
605
1402
|
reLaunch(route: string): Promise<HeadlessTestingPageHandle>;
|
|
1403
|
+
waitForCurrentPage(route?: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingPageHandle>;
|
|
606
1404
|
pageScrollTo(scrollTop: number): Promise<void>;
|
|
607
1405
|
triggerPullDownRefresh(): Promise<void>;
|
|
608
1406
|
triggerReachBottom(): Promise<void>;
|
|
@@ -616,4 +1414,4 @@ interface HeadlessTestingLaunchOptions {
|
|
|
616
1414
|
}
|
|
617
1415
|
declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
|
|
618
1416
|
//#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 };
|
|
1417
|
+
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, HeadlessTestingDataMatcher, HeadlessTestingLaunchOptions, HeadlessTestingNodeHandle, HeadlessTestingPageHandle, 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, HeadlessWxSetBackgroundColorOption, HeadlessWxSetBackgroundTextStyleOption, HeadlessWxSetNavigationBarColorOption, HeadlessWxSetNavigationBarTitleOption, HeadlessWxSetStorageOption, HeadlessWxSetTabBarBadgeOption, HeadlessWxShareMenuOption, HeadlessWxShareMenuSnapshot, HeadlessWxShowActionSheetOption, HeadlessWxShowActionSheetResult, HeadlessWxShowLoadingOption, HeadlessWxShowModalOption, HeadlessWxShowModalResult, HeadlessWxShowNavigationBarLoadingOption, HeadlessWxShowToastOption, HeadlessWxStorageInfoResult, HeadlessWxStorageResult, HeadlessWxSystemInfoResult, HeadlessWxTabBarItemOption, HeadlessWxTabBarOption, HeadlessWxToastSnapshot, HeadlessWxWindowInfoResult, 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 };
|