@mpcore/simulator 0.0.0 → 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/LICENSE +21 -0
- package/README.md +3 -0
- package/dist/index.d.mts +1289 -38
- package/dist/index.mjs +3130 -185
- package/package.json +10 -10
package/dist/index.d.mts
CHANGED
|
@@ -1,3 +1,435 @@
|
|
|
1
|
+
//#region src/host/globals.d.ts
|
|
2
|
+
interface HeadlessAppDefinition extends Record<string, any> {}
|
|
3
|
+
interface HeadlessPageDefinition extends Record<string, any> {}
|
|
4
|
+
interface HeadlessComponentDefinition extends Record<string, any> {}
|
|
5
|
+
interface HeadlessBehaviorDefinition extends Record<string, any> {
|
|
6
|
+
__isHeadlessBehavior__?: boolean;
|
|
7
|
+
}
|
|
8
|
+
interface HeadlessHostLoadContext {
|
|
9
|
+
kind: 'app' | 'page' | 'component';
|
|
10
|
+
route?: string;
|
|
11
|
+
}
|
|
12
|
+
interface HeadlessHostRegistries {
|
|
13
|
+
appDefinition: HeadlessAppDefinition | null;
|
|
14
|
+
components: Map<string, HeadlessComponentDefinition>;
|
|
15
|
+
currentLoadContext: HeadlessHostLoadContext | null;
|
|
16
|
+
pages: Map<string, HeadlessPageDefinition>;
|
|
17
|
+
}
|
|
18
|
+
declare function createHostRegistries(): HeadlessHostRegistries;
|
|
19
|
+
declare function registerAppDefinition(registries: HeadlessHostRegistries, definition: HeadlessAppDefinition): HeadlessAppDefinition;
|
|
20
|
+
declare function registerPageDefinition(registries: HeadlessHostRegistries, definition: HeadlessPageDefinition): HeadlessPageDefinition;
|
|
21
|
+
declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition): HeadlessComponentDefinition;
|
|
22
|
+
//#endregion
|
|
23
|
+
//#region src/host/wx.d.ts
|
|
24
|
+
interface HeadlessWxCallbackOption<TResult = void> {
|
|
25
|
+
complete?: (result?: TResult) => void;
|
|
26
|
+
fail?: (error: Error) => void;
|
|
27
|
+
success?: (result: TResult) => void;
|
|
28
|
+
}
|
|
29
|
+
interface HeadlessWxNavigateOption extends HeadlessWxCallbackOption {
|
|
30
|
+
url: string;
|
|
31
|
+
}
|
|
32
|
+
interface HeadlessWxNavigateBackOption extends HeadlessWxCallbackOption {
|
|
33
|
+
delta?: number;
|
|
34
|
+
}
|
|
35
|
+
interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
|
|
36
|
+
duration?: number;
|
|
37
|
+
scrollTop?: number;
|
|
38
|
+
selector?: string;
|
|
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
|
+
}
|
|
201
|
+
interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
|
|
202
|
+
errMsg: string;
|
|
203
|
+
}> {
|
|
204
|
+
duration?: number;
|
|
205
|
+
icon?: string;
|
|
206
|
+
mask?: boolean;
|
|
207
|
+
title: string;
|
|
208
|
+
}
|
|
209
|
+
interface HeadlessWxShowLoadingOption extends HeadlessWxCallbackOption<{
|
|
210
|
+
errMsg: string;
|
|
211
|
+
}> {
|
|
212
|
+
mask?: boolean;
|
|
213
|
+
title: string;
|
|
214
|
+
}
|
|
215
|
+
interface HeadlessWxRequestSuccessResult {
|
|
216
|
+
cookies: string[];
|
|
217
|
+
data: unknown;
|
|
218
|
+
errMsg: string;
|
|
219
|
+
header: Record<string, string>;
|
|
220
|
+
statusCode: number;
|
|
221
|
+
}
|
|
222
|
+
interface HeadlessWxRequestOption extends HeadlessWxCallbackOption<HeadlessWxRequestSuccessResult> {
|
|
223
|
+
data?: unknown;
|
|
224
|
+
header?: Record<string, string>;
|
|
225
|
+
method?: string;
|
|
226
|
+
url: string;
|
|
227
|
+
}
|
|
228
|
+
interface HeadlessWxRequestTask {
|
|
229
|
+
abort: () => void;
|
|
230
|
+
}
|
|
231
|
+
interface HeadlessWxDriver {
|
|
232
|
+
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
233
|
+
clearStorageSync: () => void;
|
|
234
|
+
getEnterOptionsSync: () => HeadlessWxLaunchOptions;
|
|
235
|
+
getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
|
|
236
|
+
getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
|
|
237
|
+
getNetworkType: () => HeadlessWxGetNetworkTypeResult;
|
|
238
|
+
getStorageInfoSync: () => HeadlessWxStorageInfoResult;
|
|
239
|
+
getStorageSync: (key: string) => unknown;
|
|
240
|
+
getSystemInfoSync: () => HeadlessWxSystemInfoResult;
|
|
241
|
+
getWindowInfoSync: () => HeadlessWxWindowInfoResult;
|
|
242
|
+
hideLoading: () => {
|
|
243
|
+
errMsg: string;
|
|
244
|
+
};
|
|
245
|
+
hideToast: () => {
|
|
246
|
+
errMsg: string;
|
|
247
|
+
};
|
|
248
|
+
navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
|
|
249
|
+
navigateTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
250
|
+
nextTick: (callback?: () => void) => void;
|
|
251
|
+
offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
252
|
+
onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
253
|
+
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
254
|
+
reLaunch: (option: HeadlessWxNavigateOption) => unknown;
|
|
255
|
+
redirectTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
256
|
+
removeStorageSync: (key: string) => void;
|
|
257
|
+
request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
|
|
258
|
+
setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
|
|
259
|
+
errMsg: string;
|
|
260
|
+
};
|
|
261
|
+
setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
|
|
262
|
+
errMsg: string;
|
|
263
|
+
};
|
|
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;
|
|
300
|
+
showToast: (option: HeadlessWxShowToastOption) => {
|
|
301
|
+
errMsg: string;
|
|
302
|
+
};
|
|
303
|
+
stopPullDownRefresh: () => void;
|
|
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
|
+
};
|
|
314
|
+
}
|
|
315
|
+
interface HeadlessWx {
|
|
316
|
+
canIUse: (schema: string) => boolean;
|
|
317
|
+
clearStorage: (option?: HeadlessWxClearStorageOption) => HeadlessWxStorageResult | undefined;
|
|
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;
|
|
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;
|
|
336
|
+
hideToast: () => {
|
|
337
|
+
errMsg: string;
|
|
338
|
+
};
|
|
339
|
+
navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
|
|
340
|
+
navigateTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
341
|
+
nextTick: (callback?: () => void) => void;
|
|
342
|
+
offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
343
|
+
onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
344
|
+
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
345
|
+
reLaunch: (option: HeadlessWxNavigateOption) => unknown;
|
|
346
|
+
redirectTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
347
|
+
removeStorage: (option: HeadlessWxRemoveStorageOption) => HeadlessWxStorageResult | undefined;
|
|
348
|
+
removeStorageSync: (key: string) => void;
|
|
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;
|
|
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;
|
|
395
|
+
showToast: (option: HeadlessWxShowToastOption) => {
|
|
396
|
+
errMsg: string;
|
|
397
|
+
} | undefined;
|
|
398
|
+
stopPullDownRefresh: () => void;
|
|
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;
|
|
409
|
+
}
|
|
410
|
+
declare function createHeadlessWx(driver: HeadlessWxDriver): HeadlessWx;
|
|
411
|
+
//#endregion
|
|
412
|
+
//#region src/browser/virtualFiles.d.ts
|
|
413
|
+
interface BrowserDirectoryFileLike {
|
|
414
|
+
name: string;
|
|
415
|
+
text: () => Promise<string>;
|
|
416
|
+
webkitRelativePath?: string;
|
|
417
|
+
}
|
|
418
|
+
type BrowserVirtualFiles = Map<string, string>;
|
|
419
|
+
declare function normalizeBrowserFilePath(filePath: string): string;
|
|
420
|
+
declare function createBrowserVirtualFiles(entries: Iterable<[string, string]>): BrowserVirtualFiles;
|
|
421
|
+
declare function createBrowserVirtualFilesFromDirectory(files: BrowserDirectoryFileLike[]): Promise<BrowserVirtualFiles>;
|
|
422
|
+
declare function readBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): string | undefined;
|
|
423
|
+
declare function hasBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): boolean;
|
|
424
|
+
//#endregion
|
|
425
|
+
//#region src/browser/moduleLoader.d.ts
|
|
426
|
+
interface BrowserModuleLoader {
|
|
427
|
+
executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
|
|
428
|
+
executeAppModule: (filePath: string) => HeadlessAppDefinition;
|
|
429
|
+
executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
|
|
430
|
+
}
|
|
431
|
+
declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0]): BrowserModuleLoader;
|
|
432
|
+
//#endregion
|
|
1
433
|
//#region src/project/resolveRoutes.d.ts
|
|
2
434
|
interface HeadlessRouteRecord {
|
|
3
435
|
kind: 'page';
|
|
@@ -7,7 +439,7 @@ interface HeadlessRouteRecord {
|
|
|
7
439
|
}
|
|
8
440
|
declare function resolveRoutesFromAppConfig(config: Record<string, any>): HeadlessRouteRecord[];
|
|
9
441
|
//#endregion
|
|
10
|
-
//#region src/project/
|
|
442
|
+
//#region src/project/createProjectDescriptor.d.ts
|
|
11
443
|
interface HeadlessProjectConfigFile {
|
|
12
444
|
filePath: string;
|
|
13
445
|
value: Record<string, any>;
|
|
@@ -21,37 +453,135 @@ interface HeadlessProjectDescriptor {
|
|
|
21
453
|
projectConfigFiles: HeadlessProjectConfigFile[];
|
|
22
454
|
routes: HeadlessRouteRecord[];
|
|
23
455
|
}
|
|
24
|
-
|
|
456
|
+
interface CreateProjectDescriptorOptions {
|
|
457
|
+
appConfig: Record<string, any>;
|
|
458
|
+
appConfigPath: string;
|
|
459
|
+
miniprogramRoot: string;
|
|
460
|
+
miniprogramRootPath: string;
|
|
461
|
+
projectPath: string;
|
|
462
|
+
projectConfigFiles?: HeadlessProjectConfigFile[];
|
|
463
|
+
}
|
|
464
|
+
declare function createProjectDescriptor(options: CreateProjectDescriptorOptions): HeadlessProjectDescriptor;
|
|
25
465
|
//#endregion
|
|
26
|
-
//#region src/
|
|
27
|
-
interface
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
route?: string;
|
|
466
|
+
//#region src/browser/project.d.ts
|
|
467
|
+
interface CreateBrowserProjectOptions {
|
|
468
|
+
appConfigPath?: string;
|
|
469
|
+
miniprogramRoot?: string;
|
|
470
|
+
miniprogramRootPath?: string;
|
|
471
|
+
projectPath?: string;
|
|
33
472
|
}
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
473
|
+
declare function createBrowserProject(files: BrowserVirtualFiles, options?: CreateBrowserProjectOptions): HeadlessProjectDescriptor;
|
|
474
|
+
//#endregion
|
|
475
|
+
//#region src/runtime/componentInstance.d.ts
|
|
476
|
+
interface HeadlessComponentInstance extends Record<string, any> {
|
|
477
|
+
__definition__?: HeadlessComponentDefinition;
|
|
478
|
+
__lastInteractionEvent__?: Record<string, any>;
|
|
479
|
+
__propertySnapshots__?: Record<string, any>;
|
|
480
|
+
__ready__?: boolean;
|
|
481
|
+
data: Record<string, any>;
|
|
482
|
+
properties: Record<string, any>;
|
|
483
|
+
selectAllComponents?: (selector: string) => any[];
|
|
484
|
+
selectComponent?: (selector: string) => any;
|
|
485
|
+
selectOwnerComponent?: () => any;
|
|
486
|
+
setData: (patch: Record<string, any>, callback?: () => void) => void;
|
|
487
|
+
triggerEvent: (eventName: string, detail?: unknown, options?: Record<string, any>) => void;
|
|
39
488
|
}
|
|
40
|
-
declare function
|
|
41
|
-
declare function
|
|
42
|
-
|
|
43
|
-
|
|
489
|
+
declare function cloneValue<T>(value: T): T;
|
|
490
|
+
declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
|
|
491
|
+
interface CreateComponentInstanceOptions {
|
|
492
|
+
definition: HeadlessComponentDefinition;
|
|
493
|
+
properties?: Record<string, any>;
|
|
494
|
+
triggerEvent?: (instance: HeadlessComponentInstance, eventName: string, detail?: unknown, options?: Record<string, any>) => void;
|
|
495
|
+
}
|
|
496
|
+
declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
|
|
497
|
+
declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): unknown;
|
|
498
|
+
declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
|
|
499
|
+
declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
|
|
500
|
+
declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
|
|
44
501
|
//#endregion
|
|
45
|
-
//#region src/
|
|
46
|
-
interface
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
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
|
|
521
|
+
//#region src/runtime/pageInstance.d.ts
|
|
522
|
+
interface HeadlessPageInstance extends Record<string, any> {
|
|
523
|
+
__background__?: HeadlessBackgroundSnapshot;
|
|
524
|
+
__backgroundTextStyle__?: HeadlessBackgroundTextStyle;
|
|
525
|
+
__lastChangedKeys__?: string[];
|
|
526
|
+
__navigationBar__?: HeadlessNavigationBarSnapshot;
|
|
527
|
+
__navigationBarTitle__?: string;
|
|
528
|
+
__route__: string;
|
|
529
|
+
data: Record<string, any>;
|
|
530
|
+
options: Record<string, string>;
|
|
531
|
+
route: string;
|
|
532
|
+
selectAllComponents?: (selector: string) => any[];
|
|
533
|
+
selectComponent?: (selector: string) => any;
|
|
534
|
+
setData: (patch: Record<string, any>, callback?: () => void) => void;
|
|
535
|
+
}
|
|
536
|
+
declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>, pageState?: {
|
|
537
|
+
background?: HeadlessBackgroundSnapshot;
|
|
538
|
+
backgroundTextStyle?: HeadlessBackgroundTextStyle;
|
|
539
|
+
navigationBar?: HeadlessNavigationBarSnapshot;
|
|
540
|
+
}): HeadlessPageInstance;
|
|
541
|
+
//#endregion
|
|
542
|
+
//#region src/browser/render.d.ts
|
|
543
|
+
interface DomNodeLike$3 {
|
|
544
|
+
attribs?: Record<string, string>;
|
|
545
|
+
children?: DomNodeLike$3[];
|
|
546
|
+
data?: string;
|
|
547
|
+
name?: string;
|
|
548
|
+
parent?: DomNodeLike$3 | null;
|
|
549
|
+
type?: string;
|
|
550
|
+
}
|
|
551
|
+
interface BrowserRenderScope {
|
|
552
|
+
alias?: string;
|
|
553
|
+
classList?: string[];
|
|
554
|
+
data: Record<string, any>;
|
|
555
|
+
dataset?: Record<string, string>;
|
|
556
|
+
eventBindings?: Map<string, {
|
|
557
|
+
method: string;
|
|
558
|
+
stopAfter: boolean;
|
|
559
|
+
}>;
|
|
560
|
+
getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
|
|
561
|
+
getScopeId: () => string;
|
|
562
|
+
hostId?: string;
|
|
563
|
+
listenerScopeId?: string;
|
|
564
|
+
id?: string;
|
|
565
|
+
ownerScopeId?: string;
|
|
53
566
|
}
|
|
54
|
-
|
|
567
|
+
interface BrowserRenderedPageTree {
|
|
568
|
+
root: DomNodeLike$3;
|
|
569
|
+
wxml: string;
|
|
570
|
+
}
|
|
571
|
+
interface BrowserRendererContext {
|
|
572
|
+
changedPageKeys: string[];
|
|
573
|
+
componentCache: Map<string, HeadlessComponentInstance>;
|
|
574
|
+
componentScopes: Map<string, BrowserRenderScope>;
|
|
575
|
+
files: BrowserVirtualFiles;
|
|
576
|
+
moduleLoader: BrowserModuleLoader;
|
|
577
|
+
project: HeadlessProjectDescriptor;
|
|
578
|
+
session: {
|
|
579
|
+
selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
|
|
580
|
+
selectComponentWithin: (scopeId: string, selector: string) => any;
|
|
581
|
+
selectOwnerComponent: (scopeId: string) => any;
|
|
582
|
+
};
|
|
583
|
+
}
|
|
584
|
+
declare function renderBrowserPageTree(context: BrowserRendererContext, page: HeadlessPageInstance): BrowserRenderedPageTree;
|
|
55
585
|
//#endregion
|
|
56
586
|
//#region src/runtime/appInstance.d.ts
|
|
57
587
|
interface HeadlessAppInstance extends Record<string, any> {
|
|
@@ -59,13 +589,456 @@ interface HeadlessAppInstance extends Record<string, any> {
|
|
|
59
589
|
}
|
|
60
590
|
declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
|
|
61
591
|
//#endregion
|
|
62
|
-
//#region src/runtime/
|
|
63
|
-
interface
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
592
|
+
//#region src/runtime/wxState.d.ts
|
|
593
|
+
interface HeadlessWxLoadingSnapshot {
|
|
594
|
+
mask: boolean;
|
|
595
|
+
title: string;
|
|
596
|
+
}
|
|
597
|
+
interface HeadlessWxToastSnapshot {
|
|
598
|
+
duration: number;
|
|
599
|
+
icon: string;
|
|
600
|
+
mask: boolean;
|
|
601
|
+
title: string;
|
|
602
|
+
}
|
|
603
|
+
interface HeadlessWxNetworkSnapshot extends HeadlessWxNetworkStatusChangeResult {}
|
|
604
|
+
interface HeadlessWxShareMenuSnapshot {
|
|
605
|
+
isUpdatableMessage: boolean;
|
|
606
|
+
menus: string[];
|
|
607
|
+
visible: boolean;
|
|
608
|
+
withShareTicket: boolean;
|
|
67
609
|
}
|
|
68
|
-
|
|
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
|
+
}
|
|
632
|
+
interface HeadlessWxRequestMockDefinition {
|
|
633
|
+
delay?: number;
|
|
634
|
+
header?: Record<string, string>;
|
|
635
|
+
method?: string;
|
|
636
|
+
response: unknown | ((option: HeadlessWxRequestOption) => unknown);
|
|
637
|
+
statusCode?: number;
|
|
638
|
+
url: RegExp | string;
|
|
639
|
+
}
|
|
640
|
+
interface HeadlessWxRequestLogEntry {
|
|
641
|
+
data: unknown;
|
|
642
|
+
header: Record<string, string>;
|
|
643
|
+
matched: boolean;
|
|
644
|
+
method: string;
|
|
645
|
+
response?: HeadlessWxRequestSuccessResult;
|
|
646
|
+
url: string;
|
|
647
|
+
}
|
|
648
|
+
declare function createHeadlessWxState(): {
|
|
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
|
+
}[];
|
|
672
|
+
getRequestLogs(): {
|
|
673
|
+
data: unknown;
|
|
674
|
+
header: {
|
|
675
|
+
[x: string]: string;
|
|
676
|
+
};
|
|
677
|
+
response: {
|
|
678
|
+
cookies: string[];
|
|
679
|
+
data: unknown;
|
|
680
|
+
header: {
|
|
681
|
+
[x: string]: string;
|
|
682
|
+
};
|
|
683
|
+
errMsg: string;
|
|
684
|
+
statusCode: number;
|
|
685
|
+
} | undefined;
|
|
686
|
+
matched: boolean;
|
|
687
|
+
method: string;
|
|
688
|
+
url: string;
|
|
689
|
+
}[];
|
|
690
|
+
getStorageInfoSync(): {
|
|
691
|
+
currentSize: number;
|
|
692
|
+
errMsg: string;
|
|
693
|
+
keys: string[];
|
|
694
|
+
limitSize: number;
|
|
695
|
+
};
|
|
696
|
+
getStorageSnapshot(): {
|
|
697
|
+
[k: string]: unknown;
|
|
698
|
+
};
|
|
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
|
+
};
|
|
713
|
+
getToast(): {
|
|
714
|
+
duration: number;
|
|
715
|
+
icon: string;
|
|
716
|
+
mask: boolean;
|
|
717
|
+
title: string;
|
|
718
|
+
} | null;
|
|
719
|
+
hideLoading(): {
|
|
720
|
+
errMsg: string;
|
|
721
|
+
};
|
|
722
|
+
hideToast(): {
|
|
723
|
+
errMsg: string;
|
|
724
|
+
};
|
|
725
|
+
offNetworkStatusChange(callback?: HeadlessWxNetworkStatusChangeCallback): void;
|
|
726
|
+
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
727
|
+
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
728
|
+
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
729
|
+
onNetworkStatusChange(callback: HeadlessWxNetworkStatusChangeCallback): void;
|
|
730
|
+
removeStorageSync(key: string): void;
|
|
731
|
+
request(option: HeadlessWxRequestOption): HeadlessWxRequestTask;
|
|
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;
|
|
745
|
+
showToast(option: HeadlessWxShowToastOption): {
|
|
746
|
+
errMsg: string;
|
|
747
|
+
};
|
|
748
|
+
updateShareMenu(option?: HeadlessWxShareMenuOption): {
|
|
749
|
+
errMsg: string;
|
|
750
|
+
};
|
|
751
|
+
};
|
|
752
|
+
//#endregion
|
|
753
|
+
//#region src/browser/session.d.ts
|
|
754
|
+
interface BrowserHeadlessSessionOptions {
|
|
755
|
+
files: BrowserVirtualFiles;
|
|
756
|
+
project?: HeadlessProjectDescriptor;
|
|
757
|
+
}
|
|
758
|
+
declare class BrowserHeadlessSession {
|
|
759
|
+
readonly files: BrowserVirtualFiles;
|
|
760
|
+
readonly project: HeadlessProjectDescriptor;
|
|
761
|
+
private appDefinition;
|
|
762
|
+
private appInstance;
|
|
763
|
+
private readonly moduleLoader;
|
|
764
|
+
private readonly registries;
|
|
765
|
+
private currentPageInstance;
|
|
766
|
+
private readonly pages;
|
|
767
|
+
private readonly componentCache;
|
|
768
|
+
private readonly componentScopes;
|
|
769
|
+
private readonly tabBarRoutes;
|
|
770
|
+
private readonly tabPages;
|
|
771
|
+
private readonly tabBarItems;
|
|
772
|
+
private readonly tabBarState;
|
|
773
|
+
private tabBarVisible;
|
|
774
|
+
private readonly systemInfo;
|
|
775
|
+
private enterOptions;
|
|
776
|
+
private launchOptions;
|
|
777
|
+
private readonly wxState;
|
|
778
|
+
constructor(options: BrowserHeadlessSessionOptions);
|
|
779
|
+
getApp(): HeadlessAppInstance | null;
|
|
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
|
+
}[];
|
|
805
|
+
getRequestLogs(): {
|
|
806
|
+
data: unknown;
|
|
807
|
+
header: {
|
|
808
|
+
[x: string]: string;
|
|
809
|
+
};
|
|
810
|
+
response: {
|
|
811
|
+
cookies: string[];
|
|
812
|
+
data: unknown;
|
|
813
|
+
header: {
|
|
814
|
+
[x: string]: string;
|
|
815
|
+
};
|
|
816
|
+
errMsg: string;
|
|
817
|
+
statusCode: number;
|
|
818
|
+
} | undefined;
|
|
819
|
+
matched: boolean;
|
|
820
|
+
method: string;
|
|
821
|
+
url: string;
|
|
822
|
+
}[];
|
|
823
|
+
getStorageSnapshot(): {
|
|
824
|
+
[k: string]: unknown;
|
|
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
|
+
}[];
|
|
913
|
+
getToast(): {
|
|
914
|
+
duration: number;
|
|
915
|
+
icon: string;
|
|
916
|
+
mask: boolean;
|
|
917
|
+
title: string;
|
|
918
|
+
} | null;
|
|
919
|
+
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
920
|
+
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
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
|
+
};
|
|
973
|
+
getScopeSnapshot(scopeId: string): {
|
|
974
|
+
data: any;
|
|
975
|
+
methods: string[];
|
|
976
|
+
properties: any;
|
|
977
|
+
scopeId: string;
|
|
978
|
+
type: "component";
|
|
979
|
+
} | {
|
|
980
|
+
data: Record<string, any>;
|
|
981
|
+
methods: string[];
|
|
982
|
+
properties: Record<string, string>;
|
|
983
|
+
scopeId: string;
|
|
984
|
+
type: "page";
|
|
985
|
+
} | {
|
|
986
|
+
data: any;
|
|
987
|
+
methods: string[];
|
|
988
|
+
properties: {};
|
|
989
|
+
scopeId: string;
|
|
990
|
+
type: "scope";
|
|
991
|
+
} | null;
|
|
992
|
+
selectComponent(selector: string): any;
|
|
993
|
+
selectAllComponents(selector: string): any[];
|
|
994
|
+
selectComponentWithin(scopeId: string, selector: string): any;
|
|
995
|
+
selectAllComponentsWithin(scopeId: string, selector: string): any[];
|
|
996
|
+
selectOwnerComponent(scopeId: string): any;
|
|
997
|
+
private selectComponentsWithin;
|
|
998
|
+
renderCurrentPage(): BrowserRenderedPageTree;
|
|
999
|
+
callTapBinding(scopeId: string, methodName: string): any;
|
|
1000
|
+
callTapBindingWithEvent(scopeId: string, methodName: string, event?: {
|
|
1001
|
+
currentTarget?: {
|
|
1002
|
+
dataset?: Record<string, string>;
|
|
1003
|
+
id?: string;
|
|
1004
|
+
};
|
|
1005
|
+
dataset?: Record<string, string>;
|
|
1006
|
+
id?: string;
|
|
1007
|
+
target?: {
|
|
1008
|
+
dataset?: Record<string, string>;
|
|
1009
|
+
id?: string;
|
|
1010
|
+
};
|
|
1011
|
+
}): any;
|
|
1012
|
+
bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
|
|
1013
|
+
reLaunch(url: string): HeadlessPageInstance;
|
|
1014
|
+
navigateTo(url: string): HeadlessPageInstance;
|
|
1015
|
+
redirectTo(url: string): HeadlessPageInstance;
|
|
1016
|
+
navigateBack(delta?: number): HeadlessPageInstance | null;
|
|
1017
|
+
switchTab(url: string): HeadlessPageInstance;
|
|
1018
|
+
pageScrollTo(option: {
|
|
1019
|
+
scrollTop?: number;
|
|
1020
|
+
}): void;
|
|
1021
|
+
triggerPullDownRefresh(): HeadlessPageInstance;
|
|
1022
|
+
triggerReachBottom(): HeadlessPageInstance;
|
|
1023
|
+
triggerResize(options: Record<string, any>): HeadlessPageInstance;
|
|
1024
|
+
triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
|
|
1025
|
+
stopPullDownRefresh(): void;
|
|
1026
|
+
private createFreshPage;
|
|
1027
|
+
private isTabBarRoute;
|
|
1028
|
+
private removePageInstance;
|
|
1029
|
+
private resolveNavigationTarget;
|
|
1030
|
+
private resolveTabBarItem;
|
|
1031
|
+
private requireTabBarItem;
|
|
1032
|
+
private unloadAllPages;
|
|
1033
|
+
private unloadPage;
|
|
1034
|
+
private requireCurrentPage;
|
|
1035
|
+
private detachPageComponents;
|
|
1036
|
+
private runPageComponentLifetime;
|
|
1037
|
+
}
|
|
1038
|
+
declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
|
|
1039
|
+
//#endregion
|
|
1040
|
+
//#region src/project/loadProject.d.ts
|
|
1041
|
+
declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
|
|
69
1042
|
//#endregion
|
|
70
1043
|
//#region src/runtime/session.d.ts
|
|
71
1044
|
interface HeadlessSessionOptions {
|
|
@@ -79,11 +1052,238 @@ declare class HeadlessSession {
|
|
|
79
1052
|
private readonly registries;
|
|
80
1053
|
private currentPageInstance;
|
|
81
1054
|
private readonly pages;
|
|
1055
|
+
private readonly tabBarRoutes;
|
|
1056
|
+
private readonly tabPages;
|
|
1057
|
+
private readonly tabBarItems;
|
|
1058
|
+
private readonly tabBarState;
|
|
1059
|
+
private tabBarVisible;
|
|
1060
|
+
private readonly systemInfo;
|
|
1061
|
+
private enterOptions;
|
|
1062
|
+
private launchOptions;
|
|
1063
|
+
private readonly wxState;
|
|
82
1064
|
constructor(options: HeadlessSessionOptions);
|
|
83
1065
|
getApp(): HeadlessAppInstance | null;
|
|
84
1066
|
getCurrentPages(): HeadlessPageInstance[];
|
|
85
|
-
|
|
86
|
-
|
|
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
|
+
}[];
|
|
1091
|
+
getRequestLogs(): {
|
|
1092
|
+
data: unknown;
|
|
1093
|
+
header: {
|
|
1094
|
+
[x: string]: string;
|
|
1095
|
+
};
|
|
1096
|
+
response: {
|
|
1097
|
+
cookies: string[];
|
|
1098
|
+
data: unknown;
|
|
1099
|
+
header: {
|
|
1100
|
+
[x: string]: string;
|
|
1101
|
+
};
|
|
1102
|
+
errMsg: string;
|
|
1103
|
+
statusCode: number;
|
|
1104
|
+
} | undefined;
|
|
1105
|
+
matched: boolean;
|
|
1106
|
+
method: string;
|
|
1107
|
+
url: string;
|
|
1108
|
+
}[];
|
|
1109
|
+
getStorageSnapshot(): {
|
|
1110
|
+
[k: string]: unknown;
|
|
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
|
+
}[];
|
|
1199
|
+
getToast(): {
|
|
1200
|
+
duration: number;
|
|
1201
|
+
icon: string;
|
|
1202
|
+
mask: boolean;
|
|
1203
|
+
title: string;
|
|
1204
|
+
} | null;
|
|
1205
|
+
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
1206
|
+
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
1207
|
+
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
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;
|
|
1260
|
+
reLaunch(url: string): HeadlessPageInstance;
|
|
1261
|
+
navigateTo(url: string): HeadlessPageInstance;
|
|
1262
|
+
redirectTo(url: string): HeadlessPageInstance;
|
|
1263
|
+
navigateBack(delta?: number): HeadlessPageInstance | null;
|
|
1264
|
+
switchTab(url: string): HeadlessPageInstance;
|
|
1265
|
+
pageScrollTo(option: {
|
|
1266
|
+
scrollTop?: number;
|
|
1267
|
+
duration?: number;
|
|
1268
|
+
selector?: string;
|
|
1269
|
+
success?: () => void;
|
|
1270
|
+
fail?: (error: Error) => void;
|
|
1271
|
+
complete?: () => void;
|
|
1272
|
+
}): void;
|
|
1273
|
+
triggerPullDownRefresh(): HeadlessPageInstance;
|
|
1274
|
+
triggerReachBottom(): HeadlessPageInstance;
|
|
1275
|
+
triggerResize(options: Record<string, any>): HeadlessPageInstance;
|
|
1276
|
+
triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
|
|
1277
|
+
stopPullDownRefresh(): void;
|
|
1278
|
+
private createFreshPage;
|
|
1279
|
+
private isTabBarRoute;
|
|
1280
|
+
private resolveTabBarItem;
|
|
1281
|
+
private requireTabBarItem;
|
|
1282
|
+
private removePageInstance;
|
|
1283
|
+
private resolveNavigationTarget;
|
|
1284
|
+
private unloadAllPages;
|
|
1285
|
+
private unloadPage;
|
|
1286
|
+
private requireCurrentPage;
|
|
87
1287
|
}
|
|
88
1288
|
declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
|
|
89
1289
|
//#endregion
|
|
@@ -96,14 +1296,43 @@ interface DomNodeLike$2 {
|
|
|
96
1296
|
parent?: DomNodeLike$2 | null;
|
|
97
1297
|
type?: string;
|
|
98
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
|
+
}
|
|
99
1322
|
declare class HeadlessTestingNodeHandle {
|
|
100
1323
|
private readonly node;
|
|
101
|
-
|
|
1324
|
+
private readonly interactions?;
|
|
1325
|
+
constructor(node: DomNodeLike$2, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
|
|
102
1326
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
103
1327
|
$$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
104
1328
|
attr(name: string): Promise<string | undefined>;
|
|
105
|
-
dataset(): Promise<Record<string,
|
|
1329
|
+
dataset(): Promise<Record<string, string>>;
|
|
106
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>;
|
|
107
1336
|
wxml(): Promise<string>;
|
|
108
1337
|
}
|
|
109
1338
|
//#endregion
|
|
@@ -134,15 +1363,29 @@ interface DomNodeLike {
|
|
|
134
1363
|
declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
|
|
135
1364
|
//#endregion
|
|
136
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
|
+
}
|
|
137
1374
|
declare class HeadlessTestingPageHandle {
|
|
138
1375
|
private readonly project;
|
|
139
1376
|
private readonly page;
|
|
140
1377
|
constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance);
|
|
1378
|
+
private resolveDataByPath;
|
|
1379
|
+
private pollUntil;
|
|
141
1380
|
callMethod(methodName: string, ...args: any[]): Promise<any>;
|
|
142
1381
|
data(path?: string): Promise<any>;
|
|
143
1382
|
waitFor(ms?: number): Promise<void>;
|
|
144
1383
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
145
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>;
|
|
146
1389
|
wxml(): Promise<string>;
|
|
147
1390
|
}
|
|
148
1391
|
//#endregion
|
|
@@ -151,10 +1394,18 @@ declare class HeadlessTestingSessionHandle {
|
|
|
151
1394
|
private readonly project;
|
|
152
1395
|
private readonly session;
|
|
153
1396
|
constructor(project: HeadlessProjectDescriptor, session: HeadlessSession);
|
|
1397
|
+
private waitFor;
|
|
1398
|
+
private pollUntil;
|
|
154
1399
|
close(): Promise<void>;
|
|
155
1400
|
currentPage(): Promise<HeadlessTestingPageHandle | null>;
|
|
156
1401
|
getCurrentPages(): Promise<HeadlessTestingPageHandle[]>;
|
|
157
1402
|
reLaunch(route: string): Promise<HeadlessTestingPageHandle>;
|
|
1403
|
+
waitForCurrentPage(route?: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingPageHandle>;
|
|
1404
|
+
pageScrollTo(scrollTop: number): Promise<void>;
|
|
1405
|
+
triggerPullDownRefresh(): Promise<void>;
|
|
1406
|
+
triggerReachBottom(): Promise<void>;
|
|
1407
|
+
triggerResize(options: Record<string, any>): Promise<void>;
|
|
1408
|
+
triggerRouteDone(options?: Record<string, any>): Promise<void>;
|
|
158
1409
|
}
|
|
159
1410
|
//#endregion
|
|
160
1411
|
//#region src/testing/launch.d.ts
|
|
@@ -163,4 +1414,4 @@ interface HeadlessTestingLaunchOptions {
|
|
|
163
1414
|
}
|
|
164
1415
|
declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
|
|
165
1416
|
//#endregion
|
|
166
|
-
export { HeadlessAppDefinition, HeadlessAppInstance, HeadlessComponentDefinition, HeadlessHostLoadContext, HeadlessHostRegistries, HeadlessPageDefinition, HeadlessPageInstance, HeadlessProjectConfigFile, HeadlessProjectDescriptor, HeadlessRouteRecord, HeadlessSession, HeadlessSessionOptions, HeadlessTestingLaunchOptions, HeadlessTestingNodeHandle, HeadlessTestingPageHandle, HeadlessTestingSessionHandle, HeadlessWx, RenderedPageTree, createAppInstance, createHeadlessSession, createHeadlessWx, createHostRegistries, createPageInstance, launch, loadProject, querySelectorAll, registerAppDefinition, registerComponentDefinition, registerPageDefinition, renderPageTree, resolveRoutesFromAppConfig };
|
|
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 };
|