@mpcore/simulator 0.0.2 → 0.1.0
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/dist/index.d.mts +660 -79
- package/dist/index.mjs +2995 -1181
- package/package.json +6 -3
package/dist/index.d.mts
CHANGED
|
@@ -37,6 +37,48 @@ interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
|
|
|
37
37
|
scrollTop?: number;
|
|
38
38
|
selector?: string;
|
|
39
39
|
}
|
|
40
|
+
interface HeadlessWxSelectorQueryBoundingClientRectResult {
|
|
41
|
+
bottom: number;
|
|
42
|
+
height: number;
|
|
43
|
+
left: number;
|
|
44
|
+
right: number;
|
|
45
|
+
top: number;
|
|
46
|
+
width: number;
|
|
47
|
+
}
|
|
48
|
+
interface HeadlessWxSelectorQueryScrollOffsetResult {
|
|
49
|
+
scrollLeft: number;
|
|
50
|
+
scrollTop: number;
|
|
51
|
+
}
|
|
52
|
+
interface HeadlessWxSelectorQueryFieldsOption {
|
|
53
|
+
computedStyle?: string[];
|
|
54
|
+
context?: boolean;
|
|
55
|
+
dataset?: boolean;
|
|
56
|
+
id?: boolean;
|
|
57
|
+
mark?: boolean;
|
|
58
|
+
node?: boolean;
|
|
59
|
+
properties?: string[];
|
|
60
|
+
rect?: boolean;
|
|
61
|
+
scrollOffset?: boolean;
|
|
62
|
+
size?: boolean;
|
|
63
|
+
}
|
|
64
|
+
interface HeadlessWxSelectorQueryRequest {
|
|
65
|
+
fields: HeadlessWxSelectorQueryFieldsOption;
|
|
66
|
+
selector?: string;
|
|
67
|
+
single: boolean;
|
|
68
|
+
target: 'selector' | 'viewport';
|
|
69
|
+
}
|
|
70
|
+
interface HeadlessWxSelectorQueryNode {
|
|
71
|
+
boundingClientRect: (callback?: (result: HeadlessWxSelectorQueryBoundingClientRectResult | HeadlessWxSelectorQueryBoundingClientRectResult[] | null) => void) => HeadlessWxSelectorQuery;
|
|
72
|
+
fields: (fields: HeadlessWxSelectorQueryFieldsOption, callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
|
|
73
|
+
scrollOffset: (callback?: (result: HeadlessWxSelectorQueryScrollOffsetResult | HeadlessWxSelectorQueryScrollOffsetResult[] | null) => void) => HeadlessWxSelectorQuery;
|
|
74
|
+
}
|
|
75
|
+
interface HeadlessWxSelectorQuery {
|
|
76
|
+
exec: (callback?: (result: unknown[]) => void) => unknown[];
|
|
77
|
+
in: (component: Record<string, any>) => HeadlessWxSelectorQuery;
|
|
78
|
+
select: (selector: string) => HeadlessWxSelectorQueryNode;
|
|
79
|
+
selectAll: (selector: string) => HeadlessWxSelectorQueryNode;
|
|
80
|
+
selectViewport: () => HeadlessWxSelectorQueryNode;
|
|
81
|
+
}
|
|
40
82
|
interface HeadlessWxStorageResult {
|
|
41
83
|
errMsg: string;
|
|
42
84
|
}
|
|
@@ -228,8 +270,152 @@ interface HeadlessWxRequestOption extends HeadlessWxCallbackOption<HeadlessWxReq
|
|
|
228
270
|
interface HeadlessWxRequestTask {
|
|
229
271
|
abort: () => void;
|
|
230
272
|
}
|
|
273
|
+
interface HeadlessWxDownloadFileSuccessResult {
|
|
274
|
+
errMsg: string;
|
|
275
|
+
statusCode: number;
|
|
276
|
+
tempFilePath: string;
|
|
277
|
+
}
|
|
278
|
+
interface HeadlessWxDownloadFileOption extends HeadlessWxCallbackOption<HeadlessWxDownloadFileSuccessResult> {
|
|
279
|
+
filePath?: string;
|
|
280
|
+
header?: Record<string, string>;
|
|
281
|
+
url: string;
|
|
282
|
+
}
|
|
283
|
+
interface HeadlessWxUploadFileSuccessResult {
|
|
284
|
+
data: string;
|
|
285
|
+
errMsg: string;
|
|
286
|
+
statusCode: number;
|
|
287
|
+
}
|
|
288
|
+
interface HeadlessWxUploadFileOption extends HeadlessWxCallbackOption<HeadlessWxUploadFileSuccessResult> {
|
|
289
|
+
fileName?: string;
|
|
290
|
+
filePath: string;
|
|
291
|
+
formData?: Record<string, unknown>;
|
|
292
|
+
header?: Record<string, string>;
|
|
293
|
+
name: string;
|
|
294
|
+
url: string;
|
|
295
|
+
}
|
|
296
|
+
interface HeadlessWxSaveFileSuccessResult {
|
|
297
|
+
errMsg: string;
|
|
298
|
+
savedFilePath: string;
|
|
299
|
+
}
|
|
300
|
+
interface HeadlessWxSaveFileOption extends HeadlessWxCallbackOption<HeadlessWxSaveFileSuccessResult> {
|
|
301
|
+
filePath?: string;
|
|
302
|
+
tempFilePath: string;
|
|
303
|
+
}
|
|
304
|
+
interface HeadlessWxSavedFileInfo {
|
|
305
|
+
createTime: number;
|
|
306
|
+
filePath: string;
|
|
307
|
+
size: number;
|
|
308
|
+
}
|
|
309
|
+
interface HeadlessWxGetSavedFileListSuccessResult {
|
|
310
|
+
errMsg: string;
|
|
311
|
+
fileList: HeadlessWxSavedFileInfo[];
|
|
312
|
+
}
|
|
313
|
+
interface HeadlessWxGetSavedFileListOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileListSuccessResult> {}
|
|
314
|
+
interface HeadlessWxGetSavedFileInfoSuccessResult {
|
|
315
|
+
createTime: number;
|
|
316
|
+
errMsg: string;
|
|
317
|
+
size: number;
|
|
318
|
+
}
|
|
319
|
+
interface HeadlessWxGetSavedFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileInfoSuccessResult> {
|
|
320
|
+
filePath: string;
|
|
321
|
+
}
|
|
322
|
+
interface HeadlessWxRemoveSavedFileOption extends HeadlessWxCallbackOption<{
|
|
323
|
+
errMsg: string;
|
|
324
|
+
}> {
|
|
325
|
+
filePath: string;
|
|
326
|
+
}
|
|
327
|
+
interface HeadlessWxFileSystemResult {
|
|
328
|
+
errMsg: string;
|
|
329
|
+
}
|
|
330
|
+
interface HeadlessWxReadFileSuccessResult {
|
|
331
|
+
data: string;
|
|
332
|
+
errMsg: string;
|
|
333
|
+
}
|
|
334
|
+
interface HeadlessWxReadFileOption extends HeadlessWxCallbackOption<HeadlessWxReadFileSuccessResult> {
|
|
335
|
+
encoding?: string;
|
|
336
|
+
filePath: string;
|
|
337
|
+
}
|
|
338
|
+
interface HeadlessWxWriteFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
339
|
+
data: string;
|
|
340
|
+
encoding?: string;
|
|
341
|
+
filePath: string;
|
|
342
|
+
}
|
|
343
|
+
interface HeadlessWxAccessFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
344
|
+
path: string;
|
|
345
|
+
}
|
|
346
|
+
interface HeadlessWxAppendFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
347
|
+
data: string;
|
|
348
|
+
encoding?: string;
|
|
349
|
+
filePath: string;
|
|
350
|
+
}
|
|
351
|
+
interface HeadlessWxUnlinkOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
352
|
+
filePath: string;
|
|
353
|
+
}
|
|
354
|
+
interface HeadlessWxCopyFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
355
|
+
destPath: string;
|
|
356
|
+
srcPath: string;
|
|
357
|
+
}
|
|
358
|
+
interface HeadlessWxRenameOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
359
|
+
newPath: string;
|
|
360
|
+
oldPath: string;
|
|
361
|
+
}
|
|
362
|
+
interface HeadlessWxMkdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
363
|
+
dirPath: string;
|
|
364
|
+
recursive?: boolean;
|
|
365
|
+
}
|
|
366
|
+
interface HeadlessWxRmdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
367
|
+
dirPath: string;
|
|
368
|
+
recursive?: boolean;
|
|
369
|
+
}
|
|
370
|
+
interface HeadlessWxReadDirSuccessResult {
|
|
371
|
+
errMsg: string;
|
|
372
|
+
files: string[];
|
|
373
|
+
}
|
|
374
|
+
interface HeadlessWxReadDirOption extends HeadlessWxCallbackOption<HeadlessWxReadDirSuccessResult> {
|
|
375
|
+
dirPath: string;
|
|
376
|
+
}
|
|
377
|
+
interface HeadlessWxStats {
|
|
378
|
+
isDirectory: () => boolean;
|
|
379
|
+
isFile: () => boolean;
|
|
380
|
+
size: number;
|
|
381
|
+
}
|
|
382
|
+
interface HeadlessWxStatSuccessResult {
|
|
383
|
+
errMsg: string;
|
|
384
|
+
stats: HeadlessWxStats;
|
|
385
|
+
}
|
|
386
|
+
interface HeadlessWxStatOption extends HeadlessWxCallbackOption<HeadlessWxStatSuccessResult> {
|
|
387
|
+
path: string;
|
|
388
|
+
}
|
|
389
|
+
interface HeadlessWxFileSystemManager {
|
|
390
|
+
access: (option: HeadlessWxAccessFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
391
|
+
accessSync: (path: string) => void;
|
|
392
|
+
appendFile: (option: HeadlessWxAppendFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
393
|
+
appendFileSync: (filePath: string, data: string, encoding?: string) => void;
|
|
394
|
+
copyFile: (option: HeadlessWxCopyFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
395
|
+
copyFileSync: (srcPath: string, destPath: string) => void;
|
|
396
|
+
mkdir: (option: HeadlessWxMkdirOption) => HeadlessWxFileSystemResult | undefined;
|
|
397
|
+
mkdirSync: (dirPath: string, recursive?: boolean) => void;
|
|
398
|
+
readFile: (option: HeadlessWxReadFileOption) => HeadlessWxReadFileSuccessResult | undefined;
|
|
399
|
+
readFileSync: (filePath: string, encoding?: string) => string;
|
|
400
|
+
readdir: (option: HeadlessWxReadDirOption) => HeadlessWxReadDirSuccessResult | undefined;
|
|
401
|
+
readdirSync: (dirPath: string) => string[];
|
|
402
|
+
rmdir: (option: HeadlessWxRmdirOption) => HeadlessWxFileSystemResult | undefined;
|
|
403
|
+
rmdirSync: (dirPath: string, recursive?: boolean) => void;
|
|
404
|
+
rename: (option: HeadlessWxRenameOption) => HeadlessWxFileSystemResult | undefined;
|
|
405
|
+
renameSync: (oldPath: string, newPath: string) => void;
|
|
406
|
+
stat: (option: HeadlessWxStatOption) => HeadlessWxStatSuccessResult | undefined;
|
|
407
|
+
statSync: (path: string) => HeadlessWxStats;
|
|
408
|
+
unlink: (option: HeadlessWxUnlinkOption) => HeadlessWxFileSystemResult | undefined;
|
|
409
|
+
unlinkSync: (filePath: string) => void;
|
|
410
|
+
writeFile: (option: HeadlessWxWriteFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
411
|
+
writeFileSync: (filePath: string, data: string, encoding?: string) => void;
|
|
412
|
+
}
|
|
231
413
|
interface HeadlessWxDriver {
|
|
414
|
+
executeSelectorQuery: (requests: HeadlessWxSelectorQueryRequest[], scope?: Record<string, any>) => unknown[];
|
|
232
415
|
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
416
|
+
getFileSystemManager: () => HeadlessWxFileSystemManager;
|
|
417
|
+
getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult;
|
|
418
|
+
getSavedFileList: (option?: HeadlessWxGetSavedFileListOption) => HeadlessWxGetSavedFileListSuccessResult;
|
|
233
419
|
clearStorageSync: () => void;
|
|
234
420
|
getEnterOptionsSync: () => HeadlessWxLaunchOptions;
|
|
235
421
|
getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
|
|
@@ -245,6 +431,7 @@ interface HeadlessWxDriver {
|
|
|
245
431
|
hideToast: () => {
|
|
246
432
|
errMsg: string;
|
|
247
433
|
};
|
|
434
|
+
downloadFile: (option: HeadlessWxDownloadFileOption) => HeadlessWxRequestTask;
|
|
248
435
|
navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
|
|
249
436
|
navigateTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
250
437
|
nextTick: (callback?: () => void) => void;
|
|
@@ -255,6 +442,10 @@ interface HeadlessWxDriver {
|
|
|
255
442
|
redirectTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
256
443
|
removeStorageSync: (key: string) => void;
|
|
257
444
|
request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
|
|
445
|
+
removeSavedFile: (option: HeadlessWxRemoveSavedFileOption) => {
|
|
446
|
+
errMsg: string;
|
|
447
|
+
};
|
|
448
|
+
saveFile: (option: HeadlessWxSaveFileOption) => HeadlessWxSaveFileSuccessResult;
|
|
258
449
|
setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
|
|
259
450
|
errMsg: string;
|
|
260
451
|
};
|
|
@@ -302,6 +493,7 @@ interface HeadlessWxDriver {
|
|
|
302
493
|
};
|
|
303
494
|
stopPullDownRefresh: () => void;
|
|
304
495
|
switchTab: (option: HeadlessWxNavigateOption) => unknown;
|
|
496
|
+
uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
|
|
305
497
|
removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
|
|
306
498
|
errMsg: string;
|
|
307
499
|
};
|
|
@@ -316,6 +508,10 @@ interface HeadlessWx {
|
|
|
316
508
|
canIUse: (schema: string) => boolean;
|
|
317
509
|
clearStorage: (option?: HeadlessWxClearStorageOption) => HeadlessWxStorageResult | undefined;
|
|
318
510
|
clearStorageSync: () => void;
|
|
511
|
+
createSelectorQuery: () => HeadlessWxSelectorQuery;
|
|
512
|
+
getFileSystemManager: () => HeadlessWxFileSystemManager;
|
|
513
|
+
getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult | undefined;
|
|
514
|
+
getSavedFileList: (option?: HeadlessWxGetSavedFileListOption) => HeadlessWxGetSavedFileListSuccessResult | undefined;
|
|
319
515
|
getEnterOptionsSync: () => HeadlessWxLaunchOptions;
|
|
320
516
|
getAppBaseInfo: (option?: HeadlessWxGetAppBaseInfoOption) => HeadlessWxAppBaseInfoResult | undefined;
|
|
321
517
|
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
@@ -336,6 +532,7 @@ interface HeadlessWx {
|
|
|
336
532
|
hideToast: () => {
|
|
337
533
|
errMsg: string;
|
|
338
534
|
};
|
|
535
|
+
downloadFile: (option: HeadlessWxDownloadFileOption) => HeadlessWxRequestTask;
|
|
339
536
|
navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
|
|
340
537
|
navigateTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
341
538
|
nextTick: (callback?: () => void) => void;
|
|
@@ -344,9 +541,13 @@ interface HeadlessWx {
|
|
|
344
541
|
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
345
542
|
reLaunch: (option: HeadlessWxNavigateOption) => unknown;
|
|
346
543
|
redirectTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
544
|
+
removeSavedFile: (option: HeadlessWxRemoveSavedFileOption) => {
|
|
545
|
+
errMsg: string;
|
|
546
|
+
} | undefined;
|
|
347
547
|
removeStorage: (option: HeadlessWxRemoveStorageOption) => HeadlessWxStorageResult | undefined;
|
|
348
548
|
removeStorageSync: (key: string) => void;
|
|
349
549
|
request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
|
|
550
|
+
saveFile: (option: HeadlessWxSaveFileOption) => HeadlessWxSaveFileSuccessResult | undefined;
|
|
350
551
|
setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
|
|
351
552
|
errMsg: string;
|
|
352
553
|
} | undefined;
|
|
@@ -397,6 +598,7 @@ interface HeadlessWx {
|
|
|
397
598
|
} | undefined;
|
|
398
599
|
stopPullDownRefresh: () => void;
|
|
399
600
|
switchTab: (option: HeadlessWxNavigateOption) => unknown;
|
|
601
|
+
uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
|
|
400
602
|
removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
|
|
401
603
|
errMsg: string;
|
|
402
604
|
} | undefined;
|
|
@@ -526,6 +728,7 @@ interface HeadlessPageInstance extends Record<string, any> {
|
|
|
526
728
|
__navigationBar__?: HeadlessNavigationBarSnapshot;
|
|
527
729
|
__navigationBarTitle__?: string;
|
|
528
730
|
__route__: string;
|
|
731
|
+
__scrollTop__?: number;
|
|
529
732
|
data: Record<string, any>;
|
|
530
733
|
options: Record<string, string>;
|
|
531
734
|
route: string;
|
|
@@ -540,12 +743,12 @@ declare function createPageInstance(route: string, definition: HeadlessPageDefin
|
|
|
540
743
|
}): HeadlessPageInstance;
|
|
541
744
|
//#endregion
|
|
542
745
|
//#region src/browser/render.d.ts
|
|
543
|
-
interface DomNodeLike$
|
|
746
|
+
interface DomNodeLike$5 {
|
|
544
747
|
attribs?: Record<string, string>;
|
|
545
|
-
children?: DomNodeLike$
|
|
748
|
+
children?: DomNodeLike$5[];
|
|
546
749
|
data?: string;
|
|
547
750
|
name?: string;
|
|
548
|
-
parent?: DomNodeLike$
|
|
751
|
+
parent?: DomNodeLike$5 | null;
|
|
549
752
|
type?: string;
|
|
550
753
|
}
|
|
551
754
|
interface BrowserRenderScope {
|
|
@@ -565,7 +768,7 @@ interface BrowserRenderScope {
|
|
|
565
768
|
ownerScopeId?: string;
|
|
566
769
|
}
|
|
567
770
|
interface BrowserRenderedPageTree {
|
|
568
|
-
root: DomNodeLike$
|
|
771
|
+
root: DomNodeLike$5;
|
|
569
772
|
wxml: string;
|
|
570
773
|
}
|
|
571
774
|
interface BrowserRendererContext {
|
|
@@ -589,6 +792,59 @@ interface HeadlessAppInstance extends Record<string, any> {
|
|
|
589
792
|
}
|
|
590
793
|
declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
|
|
591
794
|
//#endregion
|
|
795
|
+
//#region src/project/loadProject.d.ts
|
|
796
|
+
declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
|
|
797
|
+
//#endregion
|
|
798
|
+
//#region src/runtime/moduleLoader.d.ts
|
|
799
|
+
interface HeadlessModuleLoader {
|
|
800
|
+
executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
|
|
801
|
+
executeAppModule: (filePath: string) => HeadlessAppDefinition;
|
|
802
|
+
executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
|
|
803
|
+
}
|
|
804
|
+
//#endregion
|
|
805
|
+
//#region src/runtime/render.d.ts
|
|
806
|
+
interface DomNodeLike$4 {
|
|
807
|
+
attribs?: Record<string, string>;
|
|
808
|
+
children?: DomNodeLike$4[];
|
|
809
|
+
data?: string;
|
|
810
|
+
name?: string;
|
|
811
|
+
parent?: DomNodeLike$4 | null;
|
|
812
|
+
type?: string;
|
|
813
|
+
}
|
|
814
|
+
interface RuntimeRenderScope {
|
|
815
|
+
alias?: string;
|
|
816
|
+
classList?: string[];
|
|
817
|
+
data: Record<string, any>;
|
|
818
|
+
dataset?: Record<string, string>;
|
|
819
|
+
eventBindings?: Map<string, {
|
|
820
|
+
method: string;
|
|
821
|
+
stopAfter: boolean;
|
|
822
|
+
}>;
|
|
823
|
+
getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
|
|
824
|
+
getScopeId: () => string;
|
|
825
|
+
hostId?: string;
|
|
826
|
+
listenerScopeId?: string;
|
|
827
|
+
id?: string;
|
|
828
|
+
ownerScopeId?: string;
|
|
829
|
+
}
|
|
830
|
+
interface RuntimeRenderedPageTree {
|
|
831
|
+
root: DomNodeLike$4;
|
|
832
|
+
wxml: string;
|
|
833
|
+
}
|
|
834
|
+
interface RuntimeRendererContext {
|
|
835
|
+
changedPageKeys: string[];
|
|
836
|
+
componentCache: Map<string, HeadlessComponentInstance>;
|
|
837
|
+
componentScopes: Map<string, RuntimeRenderScope>;
|
|
838
|
+
moduleLoader: HeadlessModuleLoader;
|
|
839
|
+
project: HeadlessProjectDescriptor;
|
|
840
|
+
session: {
|
|
841
|
+
selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
|
|
842
|
+
selectComponentWithin: (scopeId: string, selector: string) => any;
|
|
843
|
+
selectOwnerComponent: (scopeId: string) => any;
|
|
844
|
+
};
|
|
845
|
+
}
|
|
846
|
+
declare function renderRuntimePageTree(context: RuntimeRendererContext, page: HeadlessPageInstance): RuntimeRenderedPageTree;
|
|
847
|
+
//#endregion
|
|
592
848
|
//#region src/runtime/wxState.d.ts
|
|
593
849
|
interface HeadlessWxLoadingSnapshot {
|
|
594
850
|
mask: boolean;
|
|
@@ -645,8 +901,44 @@ interface HeadlessWxRequestLogEntry {
|
|
|
645
901
|
response?: HeadlessWxRequestSuccessResult;
|
|
646
902
|
url: string;
|
|
647
903
|
}
|
|
904
|
+
interface HeadlessWxDownloadFileMockDefinition {
|
|
905
|
+
delay?: number;
|
|
906
|
+
fileContent: string | ((option: HeadlessWxDownloadFileOption) => string);
|
|
907
|
+
header?: Record<string, string>;
|
|
908
|
+
statusCode?: number;
|
|
909
|
+
url: RegExp | string;
|
|
910
|
+
}
|
|
911
|
+
interface HeadlessWxDownloadFileLogEntry {
|
|
912
|
+
header: Record<string, string>;
|
|
913
|
+
matched: boolean;
|
|
914
|
+
response?: HeadlessWxDownloadFileSuccessResult;
|
|
915
|
+
tempFilePath?: string;
|
|
916
|
+
url: string;
|
|
917
|
+
}
|
|
918
|
+
interface HeadlessWxUploadFileMockDefinition {
|
|
919
|
+
delay?: number;
|
|
920
|
+
header?: Record<string, string>;
|
|
921
|
+
method?: string;
|
|
922
|
+
response: string | Partial<HeadlessWxUploadFileSuccessResult> | ((option: HeadlessWxUploadFileOption & {
|
|
923
|
+
fileContent: string;
|
|
924
|
+
}) => string | Partial<HeadlessWxUploadFileSuccessResult>);
|
|
925
|
+
statusCode?: number;
|
|
926
|
+
url: RegExp | string;
|
|
927
|
+
}
|
|
928
|
+
interface HeadlessWxUploadFileLogEntry {
|
|
929
|
+
fileContent: string;
|
|
930
|
+
fileName?: string;
|
|
931
|
+
filePath: string;
|
|
932
|
+
formData: Record<string, unknown>;
|
|
933
|
+
header: Record<string, string>;
|
|
934
|
+
matched: boolean;
|
|
935
|
+
name: string;
|
|
936
|
+
response?: HeadlessWxUploadFileSuccessResult;
|
|
937
|
+
url: string;
|
|
938
|
+
}
|
|
648
939
|
declare function createHeadlessWxState(): {
|
|
649
940
|
clearStorageSync(): void;
|
|
941
|
+
downloadFile(option: HeadlessWxDownloadFileOption): HeadlessWxRequestTask;
|
|
650
942
|
getActionSheetLogs(): {
|
|
651
943
|
itemList: string[];
|
|
652
944
|
result: {
|
|
@@ -654,6 +946,27 @@ declare function createHeadlessWxState(): {
|
|
|
654
946
|
tapIndex: number;
|
|
655
947
|
} | undefined;
|
|
656
948
|
}[];
|
|
949
|
+
getDownloadFileLogs(): {
|
|
950
|
+
header: {
|
|
951
|
+
[x: string]: string;
|
|
952
|
+
};
|
|
953
|
+
response: {
|
|
954
|
+
errMsg: string;
|
|
955
|
+
statusCode: number;
|
|
956
|
+
tempFilePath: string;
|
|
957
|
+
} | undefined;
|
|
958
|
+
matched: boolean;
|
|
959
|
+
tempFilePath?: string;
|
|
960
|
+
url: string;
|
|
961
|
+
}[];
|
|
962
|
+
getFileSnapshot(): {
|
|
963
|
+
[k: string]: string;
|
|
964
|
+
};
|
|
965
|
+
getDirectorySnapshot(): string[];
|
|
966
|
+
getFileSystemManager(): HeadlessWxFileSystemManager;
|
|
967
|
+
getSavedFileInfo(option: HeadlessWxGetSavedFileInfoOption): HeadlessWxGetSavedFileInfoSuccessResult;
|
|
968
|
+
getSavedFileList(): HeadlessWxGetSavedFileListSuccessResult;
|
|
969
|
+
getFileText(filePath: string): string | null;
|
|
657
970
|
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
658
971
|
getModalLogs(): {
|
|
659
972
|
result: {
|
|
@@ -716,6 +1029,23 @@ declare function createHeadlessWxState(): {
|
|
|
716
1029
|
mask: boolean;
|
|
717
1030
|
title: string;
|
|
718
1031
|
} | null;
|
|
1032
|
+
getUploadFileLogs(): {
|
|
1033
|
+
formData: Record<string, unknown>;
|
|
1034
|
+
header: {
|
|
1035
|
+
[x: string]: string;
|
|
1036
|
+
};
|
|
1037
|
+
response: {
|
|
1038
|
+
data: string;
|
|
1039
|
+
errMsg: string;
|
|
1040
|
+
statusCode: number;
|
|
1041
|
+
} | undefined;
|
|
1042
|
+
fileContent: string;
|
|
1043
|
+
fileName?: string;
|
|
1044
|
+
filePath: string;
|
|
1045
|
+
matched: boolean;
|
|
1046
|
+
name: string;
|
|
1047
|
+
url: string;
|
|
1048
|
+
}[];
|
|
719
1049
|
hideLoading(): {
|
|
720
1050
|
errMsg: string;
|
|
721
1051
|
};
|
|
@@ -724,12 +1054,19 @@ declare function createHeadlessWxState(): {
|
|
|
724
1054
|
};
|
|
725
1055
|
offNetworkStatusChange(callback?: HeadlessWxNetworkStatusChangeCallback): void;
|
|
726
1056
|
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
1057
|
+
mockDownloadFile(definition: HeadlessWxDownloadFileMockDefinition): void;
|
|
727
1058
|
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
1059
|
+
mockUploadFile(definition: HeadlessWxUploadFileMockDefinition): void;
|
|
728
1060
|
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
729
1061
|
onNetworkStatusChange(callback: HeadlessWxNetworkStatusChangeCallback): void;
|
|
730
1062
|
removeStorageSync(key: string): void;
|
|
731
1063
|
request(option: HeadlessWxRequestOption): HeadlessWxRequestTask;
|
|
1064
|
+
removeSavedFile(option: HeadlessWxRemoveSavedFileOption): {
|
|
1065
|
+
errMsg: string;
|
|
1066
|
+
};
|
|
1067
|
+
saveFile(option: HeadlessWxSaveFileOption): HeadlessWxSaveFileSuccessResult;
|
|
732
1068
|
setStorageSync(key: string, value: unknown): void;
|
|
1069
|
+
setFile(filePath: string, fileContent: string): void;
|
|
733
1070
|
setNetworkType(nextNetworkType: HeadlessWxNetworkType): {
|
|
734
1071
|
errMsg: string;
|
|
735
1072
|
networkType: HeadlessWxNetworkType;
|
|
@@ -745,18 +1082,17 @@ declare function createHeadlessWxState(): {
|
|
|
745
1082
|
showToast(option: HeadlessWxShowToastOption): {
|
|
746
1083
|
errMsg: string;
|
|
747
1084
|
};
|
|
1085
|
+
uploadFile(option: HeadlessWxUploadFileOption): HeadlessWxRequestTask;
|
|
748
1086
|
updateShareMenu(option?: HeadlessWxShareMenuOption): {
|
|
749
1087
|
errMsg: string;
|
|
750
1088
|
};
|
|
751
1089
|
};
|
|
752
1090
|
//#endregion
|
|
753
|
-
//#region src/
|
|
754
|
-
interface
|
|
755
|
-
|
|
756
|
-
project?: HeadlessProjectDescriptor;
|
|
1091
|
+
//#region src/runtime/session.d.ts
|
|
1092
|
+
interface HeadlessSessionOptions {
|
|
1093
|
+
projectPath: string;
|
|
757
1094
|
}
|
|
758
|
-
declare class
|
|
759
|
-
readonly files: BrowserVirtualFiles;
|
|
1095
|
+
declare class HeadlessSession {
|
|
760
1096
|
readonly project: HeadlessProjectDescriptor;
|
|
761
1097
|
private appDefinition;
|
|
762
1098
|
private appInstance;
|
|
@@ -775,7 +1111,8 @@ declare class BrowserHeadlessSession {
|
|
|
775
1111
|
private enterOptions;
|
|
776
1112
|
private launchOptions;
|
|
777
1113
|
private readonly wxState;
|
|
778
|
-
|
|
1114
|
+
private pullDownRefreshState;
|
|
1115
|
+
constructor(options: HeadlessSessionOptions);
|
|
779
1116
|
getApp(): HeadlessAppInstance | null;
|
|
780
1117
|
getCurrentPages(): HeadlessPageInstance[];
|
|
781
1118
|
getCurrentPageNavigationBarTitle(): string | null;
|
|
@@ -820,6 +1157,65 @@ declare class BrowserHeadlessSession {
|
|
|
820
1157
|
method: string;
|
|
821
1158
|
url: string;
|
|
822
1159
|
}[];
|
|
1160
|
+
getDownloadFileLogs(): {
|
|
1161
|
+
header: {
|
|
1162
|
+
[x: string]: string;
|
|
1163
|
+
};
|
|
1164
|
+
response: {
|
|
1165
|
+
errMsg: string;
|
|
1166
|
+
statusCode: number;
|
|
1167
|
+
tempFilePath: string;
|
|
1168
|
+
} | undefined;
|
|
1169
|
+
matched: boolean;
|
|
1170
|
+
tempFilePath?: string;
|
|
1171
|
+
url: string;
|
|
1172
|
+
}[];
|
|
1173
|
+
getUploadFileLogs(): {
|
|
1174
|
+
formData: Record<string, unknown>;
|
|
1175
|
+
header: {
|
|
1176
|
+
[x: string]: string;
|
|
1177
|
+
};
|
|
1178
|
+
response: {
|
|
1179
|
+
data: string;
|
|
1180
|
+
errMsg: string;
|
|
1181
|
+
statusCode: number;
|
|
1182
|
+
} | undefined;
|
|
1183
|
+
fileContent: string;
|
|
1184
|
+
fileName?: string;
|
|
1185
|
+
filePath: string;
|
|
1186
|
+
matched: boolean;
|
|
1187
|
+
name: string;
|
|
1188
|
+
url: string;
|
|
1189
|
+
}[];
|
|
1190
|
+
getFileSnapshot(): {
|
|
1191
|
+
[k: string]: string;
|
|
1192
|
+
};
|
|
1193
|
+
getDirectorySnapshot(): string[];
|
|
1194
|
+
getFileText(filePath: string): string | null;
|
|
1195
|
+
getSavedFileListSnapshot(): HeadlessWxSavedFileInfo[];
|
|
1196
|
+
renderCurrentPage(): RuntimeRenderedPageTree;
|
|
1197
|
+
getScopeSnapshot(scopeId: string): {
|
|
1198
|
+
data: Record<string, any>;
|
|
1199
|
+
methods: string[];
|
|
1200
|
+
properties: Record<string, any>;
|
|
1201
|
+
scopeId: string;
|
|
1202
|
+
type: "component";
|
|
1203
|
+
} | {
|
|
1204
|
+
data: Record<string, any>;
|
|
1205
|
+
methods: string[];
|
|
1206
|
+
properties: Record<string, string>;
|
|
1207
|
+
scopeId: string;
|
|
1208
|
+
type: "page";
|
|
1209
|
+
} | {
|
|
1210
|
+
data: any;
|
|
1211
|
+
methods: string[];
|
|
1212
|
+
properties: {};
|
|
1213
|
+
scopeId: string;
|
|
1214
|
+
type: "scope";
|
|
1215
|
+
} | null;
|
|
1216
|
+
getScopeIdForComponent(component: HeadlessComponentInstance | null | undefined): string | null;
|
|
1217
|
+
callScopeMethod(scopeId: string | null, methodName: string, event: Record<string, any>): any;
|
|
1218
|
+
callScopeMethodDirect(scopeId: string, methodName: string, ...args: any[]): any;
|
|
823
1219
|
getStorageSnapshot(): {
|
|
824
1220
|
[k: string]: unknown;
|
|
825
1221
|
};
|
|
@@ -829,6 +1225,11 @@ declare class BrowserHeadlessSession {
|
|
|
829
1225
|
visible: boolean;
|
|
830
1226
|
withShareTicket: boolean;
|
|
831
1227
|
};
|
|
1228
|
+
selectComponent(selector: string): HeadlessComponentInstance | null;
|
|
1229
|
+
selectAllComponents(selector: string): (HeadlessComponentInstance | undefined)[];
|
|
1230
|
+
selectComponentWithin(scopeId: string, selector: string): HeadlessComponentInstance | null;
|
|
1231
|
+
selectAllComponentsWithin(scopeId: string, selector: string): (HeadlessComponentInstance | undefined)[];
|
|
1232
|
+
selectOwnerComponent(scopeId: string): HeadlessComponentInstance | null;
|
|
832
1233
|
getTabBar(): {
|
|
833
1234
|
visible: boolean;
|
|
834
1235
|
};
|
|
@@ -848,6 +1249,10 @@ declare class BrowserHeadlessSession {
|
|
|
848
1249
|
keys: string[];
|
|
849
1250
|
limitSize: number;
|
|
850
1251
|
};
|
|
1252
|
+
getPullDownRefreshState(): {
|
|
1253
|
+
active: boolean;
|
|
1254
|
+
stopCalls: number;
|
|
1255
|
+
};
|
|
851
1256
|
getSystemInfo(): {
|
|
852
1257
|
SDKVersion: string;
|
|
853
1258
|
brand: string;
|
|
@@ -919,6 +1324,9 @@ declare class BrowserHeadlessSession {
|
|
|
919
1324
|
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
920
1325
|
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
921
1326
|
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
1327
|
+
mockDownloadFile(definition: HeadlessWxDownloadFileMockDefinition): void;
|
|
1328
|
+
mockUploadFile(definition: HeadlessWxUploadFileMockDefinition): void;
|
|
1329
|
+
setFile(filePath: string, fileContent: string): void;
|
|
922
1330
|
setNetworkType(networkType: HeadlessWxNetworkType): {
|
|
923
1331
|
errMsg: string;
|
|
924
1332
|
networkType: HeadlessWxNetworkType;
|
|
@@ -970,45 +1378,6 @@ declare class BrowserHeadlessSession {
|
|
|
970
1378
|
setTabBarBadge(index: number, text: string): {
|
|
971
1379
|
errMsg: string;
|
|
972
1380
|
};
|
|
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
1381
|
bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
|
|
1013
1382
|
reLaunch(url: string): HeadlessPageInstance;
|
|
1014
1383
|
navigateTo(url: string): HeadlessPageInstance;
|
|
@@ -1017,34 +1386,41 @@ declare class BrowserHeadlessSession {
|
|
|
1017
1386
|
switchTab(url: string): HeadlessPageInstance;
|
|
1018
1387
|
pageScrollTo(option: {
|
|
1019
1388
|
scrollTop?: number;
|
|
1389
|
+
duration?: number;
|
|
1390
|
+
selector?: string;
|
|
1391
|
+
success?: () => void;
|
|
1392
|
+
fail?: (error: Error) => void;
|
|
1393
|
+
complete?: () => void;
|
|
1020
1394
|
}): void;
|
|
1021
1395
|
triggerPullDownRefresh(): HeadlessPageInstance;
|
|
1022
1396
|
triggerReachBottom(): HeadlessPageInstance;
|
|
1023
1397
|
triggerResize(options: Record<string, any>): HeadlessPageInstance;
|
|
1024
1398
|
triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
|
|
1025
1399
|
stopPullDownRefresh(): void;
|
|
1400
|
+
private executeSelectorQuery;
|
|
1026
1401
|
private createFreshPage;
|
|
1027
1402
|
private isTabBarRoute;
|
|
1028
|
-
private removePageInstance;
|
|
1029
|
-
private resolveNavigationTarget;
|
|
1030
1403
|
private resolveTabBarItem;
|
|
1031
1404
|
private requireTabBarItem;
|
|
1405
|
+
private removePageInstance;
|
|
1406
|
+
private resolveNavigationTarget;
|
|
1032
1407
|
private unloadAllPages;
|
|
1033
1408
|
private unloadPage;
|
|
1034
1409
|
private requireCurrentPage;
|
|
1410
|
+
private selectComponentsWithin;
|
|
1035
1411
|
private detachPageComponents;
|
|
1036
1412
|
private runPageComponentLifetime;
|
|
1413
|
+
private getComponentScopeId;
|
|
1037
1414
|
}
|
|
1038
|
-
declare function
|
|
1039
|
-
//#endregion
|
|
1040
|
-
//#region src/project/loadProject.d.ts
|
|
1041
|
-
declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
|
|
1415
|
+
declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
|
|
1042
1416
|
//#endregion
|
|
1043
|
-
//#region src/
|
|
1044
|
-
interface
|
|
1045
|
-
|
|
1417
|
+
//#region src/browser/session.d.ts
|
|
1418
|
+
interface BrowserHeadlessSessionOptions {
|
|
1419
|
+
files: BrowserVirtualFiles;
|
|
1420
|
+
project?: HeadlessProjectDescriptor;
|
|
1046
1421
|
}
|
|
1047
|
-
declare class
|
|
1422
|
+
declare class BrowserHeadlessSession {
|
|
1423
|
+
readonly files: BrowserVirtualFiles;
|
|
1048
1424
|
readonly project: HeadlessProjectDescriptor;
|
|
1049
1425
|
private appDefinition;
|
|
1050
1426
|
private appInstance;
|
|
@@ -1052,6 +1428,8 @@ declare class HeadlessSession {
|
|
|
1052
1428
|
private readonly registries;
|
|
1053
1429
|
private currentPageInstance;
|
|
1054
1430
|
private readonly pages;
|
|
1431
|
+
private readonly componentCache;
|
|
1432
|
+
private readonly componentScopes;
|
|
1055
1433
|
private readonly tabBarRoutes;
|
|
1056
1434
|
private readonly tabPages;
|
|
1057
1435
|
private readonly tabBarItems;
|
|
@@ -1061,7 +1439,8 @@ declare class HeadlessSession {
|
|
|
1061
1439
|
private enterOptions;
|
|
1062
1440
|
private launchOptions;
|
|
1063
1441
|
private readonly wxState;
|
|
1064
|
-
|
|
1442
|
+
private pullDownRefreshState;
|
|
1443
|
+
constructor(options: BrowserHeadlessSessionOptions);
|
|
1065
1444
|
getApp(): HeadlessAppInstance | null;
|
|
1066
1445
|
getCurrentPages(): HeadlessPageInstance[];
|
|
1067
1446
|
getCurrentPageNavigationBarTitle(): string | null;
|
|
@@ -1106,6 +1485,42 @@ declare class HeadlessSession {
|
|
|
1106
1485
|
method: string;
|
|
1107
1486
|
url: string;
|
|
1108
1487
|
}[];
|
|
1488
|
+
getDownloadFileLogs(): {
|
|
1489
|
+
header: {
|
|
1490
|
+
[x: string]: string;
|
|
1491
|
+
};
|
|
1492
|
+
response: {
|
|
1493
|
+
errMsg: string;
|
|
1494
|
+
statusCode: number;
|
|
1495
|
+
tempFilePath: string;
|
|
1496
|
+
} | undefined;
|
|
1497
|
+
matched: boolean;
|
|
1498
|
+
tempFilePath?: string;
|
|
1499
|
+
url: string;
|
|
1500
|
+
}[];
|
|
1501
|
+
getUploadFileLogs(): {
|
|
1502
|
+
formData: Record<string, unknown>;
|
|
1503
|
+
header: {
|
|
1504
|
+
[x: string]: string;
|
|
1505
|
+
};
|
|
1506
|
+
response: {
|
|
1507
|
+
data: string;
|
|
1508
|
+
errMsg: string;
|
|
1509
|
+
statusCode: number;
|
|
1510
|
+
} | undefined;
|
|
1511
|
+
fileContent: string;
|
|
1512
|
+
fileName?: string;
|
|
1513
|
+
filePath: string;
|
|
1514
|
+
matched: boolean;
|
|
1515
|
+
name: string;
|
|
1516
|
+
url: string;
|
|
1517
|
+
}[];
|
|
1518
|
+
getFileSnapshot(): {
|
|
1519
|
+
[k: string]: string;
|
|
1520
|
+
};
|
|
1521
|
+
getDirectorySnapshot(): string[];
|
|
1522
|
+
getFileText(filePath: string): string | null;
|
|
1523
|
+
getSavedFileListSnapshot(): HeadlessWxSavedFileInfo[];
|
|
1109
1524
|
getStorageSnapshot(): {
|
|
1110
1525
|
[k: string]: unknown;
|
|
1111
1526
|
};
|
|
@@ -1134,6 +1549,10 @@ declare class HeadlessSession {
|
|
|
1134
1549
|
keys: string[];
|
|
1135
1550
|
limitSize: number;
|
|
1136
1551
|
};
|
|
1552
|
+
getPullDownRefreshState(): {
|
|
1553
|
+
active: boolean;
|
|
1554
|
+
stopCalls: number;
|
|
1555
|
+
};
|
|
1137
1556
|
getSystemInfo(): {
|
|
1138
1557
|
SDKVersion: string;
|
|
1139
1558
|
brand: string;
|
|
@@ -1205,6 +1624,9 @@ declare class HeadlessSession {
|
|
|
1205
1624
|
mockModal(definition?: HeadlessWxModalMockDefinition): void;
|
|
1206
1625
|
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
1207
1626
|
mockRequest(definition: HeadlessWxRequestMockDefinition): void;
|
|
1627
|
+
mockDownloadFile(definition: HeadlessWxDownloadFileMockDefinition): void;
|
|
1628
|
+
mockUploadFile(definition: HeadlessWxUploadFileMockDefinition): void;
|
|
1629
|
+
setFile(filePath: string, fileContent: string): void;
|
|
1208
1630
|
setNetworkType(networkType: HeadlessWxNetworkType): {
|
|
1209
1631
|
errMsg: string;
|
|
1210
1632
|
networkType: HeadlessWxNetworkType;
|
|
@@ -1256,6 +1678,49 @@ declare class HeadlessSession {
|
|
|
1256
1678
|
setTabBarBadge(index: number, text: string): {
|
|
1257
1679
|
errMsg: string;
|
|
1258
1680
|
};
|
|
1681
|
+
getScopeSnapshot(scopeId: string): {
|
|
1682
|
+
data: any;
|
|
1683
|
+
methods: string[];
|
|
1684
|
+
properties: any;
|
|
1685
|
+
scopeId: string;
|
|
1686
|
+
type: "component";
|
|
1687
|
+
} | {
|
|
1688
|
+
data: Record<string, any>;
|
|
1689
|
+
methods: string[];
|
|
1690
|
+
properties: Record<string, string>;
|
|
1691
|
+
scopeId: string;
|
|
1692
|
+
type: "page";
|
|
1693
|
+
} | {
|
|
1694
|
+
data: any;
|
|
1695
|
+
methods: string[];
|
|
1696
|
+
properties: {};
|
|
1697
|
+
scopeId: string;
|
|
1698
|
+
type: "scope";
|
|
1699
|
+
} | null;
|
|
1700
|
+
getScopeIdForComponent(component: HeadlessComponentInstance | null | undefined): string | null;
|
|
1701
|
+
selectComponent(selector: string): any;
|
|
1702
|
+
selectAllComponents(selector: string): any[];
|
|
1703
|
+
selectComponentWithin(scopeId: string, selector: string): any;
|
|
1704
|
+
selectAllComponentsWithin(scopeId: string, selector: string): any[];
|
|
1705
|
+
selectOwnerComponent(scopeId: string): any;
|
|
1706
|
+
private selectComponentsWithin;
|
|
1707
|
+
renderCurrentPage(): BrowserRenderedPageTree;
|
|
1708
|
+
callScopeMethod(scopeId: string | null, methodName: string, event: Record<string, any>): any;
|
|
1709
|
+
callScopeMethodDirect(scopeId: string, methodName: string, ...args: any[]): any;
|
|
1710
|
+
callTapBinding(scopeId: string, methodName: string): any;
|
|
1711
|
+
callTapBindingWithEvent(scopeId: string, methodName: string, event?: {
|
|
1712
|
+
currentTarget?: {
|
|
1713
|
+
dataset?: Record<string, string>;
|
|
1714
|
+
id?: string;
|
|
1715
|
+
};
|
|
1716
|
+
dataset?: Record<string, string>;
|
|
1717
|
+
id?: string;
|
|
1718
|
+
mark?: Record<string, unknown>;
|
|
1719
|
+
target?: {
|
|
1720
|
+
dataset?: Record<string, string>;
|
|
1721
|
+
id?: string;
|
|
1722
|
+
};
|
|
1723
|
+
}): any;
|
|
1259
1724
|
bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
|
|
1260
1725
|
reLaunch(url: string): HeadlessPageInstance;
|
|
1261
1726
|
navigateTo(url: string): HeadlessPageInstance;
|
|
@@ -1264,36 +1729,35 @@ declare class HeadlessSession {
|
|
|
1264
1729
|
switchTab(url: string): HeadlessPageInstance;
|
|
1265
1730
|
pageScrollTo(option: {
|
|
1266
1731
|
scrollTop?: number;
|
|
1267
|
-
duration?: number;
|
|
1268
|
-
selector?: string;
|
|
1269
|
-
success?: () => void;
|
|
1270
|
-
fail?: (error: Error) => void;
|
|
1271
|
-
complete?: () => void;
|
|
1272
1732
|
}): void;
|
|
1273
1733
|
triggerPullDownRefresh(): HeadlessPageInstance;
|
|
1274
1734
|
triggerReachBottom(): HeadlessPageInstance;
|
|
1275
1735
|
triggerResize(options: Record<string, any>): HeadlessPageInstance;
|
|
1276
1736
|
triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
|
|
1277
1737
|
stopPullDownRefresh(): void;
|
|
1738
|
+
private executeSelectorQuery;
|
|
1278
1739
|
private createFreshPage;
|
|
1279
1740
|
private isTabBarRoute;
|
|
1280
|
-
private resolveTabBarItem;
|
|
1281
|
-
private requireTabBarItem;
|
|
1282
1741
|
private removePageInstance;
|
|
1283
1742
|
private resolveNavigationTarget;
|
|
1743
|
+
private resolveTabBarItem;
|
|
1744
|
+
private requireTabBarItem;
|
|
1284
1745
|
private unloadAllPages;
|
|
1285
1746
|
private unloadPage;
|
|
1286
1747
|
private requireCurrentPage;
|
|
1748
|
+
private detachPageComponents;
|
|
1749
|
+
private runPageComponentLifetime;
|
|
1750
|
+
private getComponentScopeId;
|
|
1287
1751
|
}
|
|
1288
|
-
declare function
|
|
1752
|
+
declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
|
|
1289
1753
|
//#endregion
|
|
1290
1754
|
//#region src/view/nodeHandle.d.ts
|
|
1291
|
-
interface DomNodeLike$
|
|
1755
|
+
interface DomNodeLike$3 {
|
|
1292
1756
|
attribs?: Record<string, string>;
|
|
1293
|
-
children?: DomNodeLike$
|
|
1757
|
+
children?: DomNodeLike$3[];
|
|
1294
1758
|
data?: string;
|
|
1295
1759
|
name?: string;
|
|
1296
|
-
parent?: DomNodeLike$
|
|
1760
|
+
parent?: DomNodeLike$3 | null;
|
|
1297
1761
|
type?: string;
|
|
1298
1762
|
}
|
|
1299
1763
|
interface HeadlessTestingNodeEventInit {
|
|
@@ -1317,16 +1781,43 @@ interface HeadlessTestingNodeValueEventInit extends HeadlessTestingNodeEventInit
|
|
|
1317
1781
|
};
|
|
1318
1782
|
}
|
|
1319
1783
|
interface HeadlessTestingNodeInteractionHandlers {
|
|
1320
|
-
callMethod: (methodName: string, event: Record<string, any>) => unknown;
|
|
1784
|
+
callMethod: (scopeId: string | null, methodName: string, event: Record<string, any>) => unknown;
|
|
1785
|
+
createScopeHandle: (scopeId: string | null) => {
|
|
1786
|
+
scopeId: string;
|
|
1787
|
+
snapshot: () => Promise<unknown>;
|
|
1788
|
+
} | null;
|
|
1789
|
+
createPageHandle: () => {
|
|
1790
|
+
data: (path?: string) => Promise<unknown>;
|
|
1791
|
+
};
|
|
1792
|
+
ownerScopeId: (scopeId: string | null) => string | null;
|
|
1321
1793
|
}
|
|
1322
1794
|
declare class HeadlessTestingNodeHandle {
|
|
1323
1795
|
private readonly node;
|
|
1324
1796
|
private readonly interactions?;
|
|
1325
|
-
constructor(node: DomNodeLike$
|
|
1797
|
+
constructor(node: DomNodeLike$3, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
|
|
1326
1798
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
1327
1799
|
$$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
1328
1800
|
attr(name: string): Promise<string | undefined>;
|
|
1329
1801
|
dataset(): Promise<Record<string, string>>;
|
|
1802
|
+
scope(): Promise<{
|
|
1803
|
+
scopeId: string;
|
|
1804
|
+
snapshot: () => Promise<unknown>;
|
|
1805
|
+
} | null>;
|
|
1806
|
+
componentScope(): Promise<{
|
|
1807
|
+
scopeId: string;
|
|
1808
|
+
snapshot: () => Promise<unknown>;
|
|
1809
|
+
} | null>;
|
|
1810
|
+
pageScope(): Promise<{
|
|
1811
|
+
scopeId: string;
|
|
1812
|
+
snapshot: () => Promise<unknown>;
|
|
1813
|
+
} | null>;
|
|
1814
|
+
page(): Promise<{
|
|
1815
|
+
data: (path?: string) => Promise<unknown>;
|
|
1816
|
+
}>;
|
|
1817
|
+
ownerComponentScope(): Promise<{
|
|
1818
|
+
scopeId: string;
|
|
1819
|
+
snapshot: () => Promise<unknown>;
|
|
1820
|
+
} | null>;
|
|
1330
1821
|
text(): Promise<string>;
|
|
1331
1822
|
trigger(eventName: string, event?: HeadlessTestingNodeEventInit): Promise<unknown>;
|
|
1332
1823
|
tap(event?: HeadlessTestingNodeEventInit): Promise<unknown>;
|
|
@@ -1337,6 +1828,21 @@ declare class HeadlessTestingNodeHandle {
|
|
|
1337
1828
|
}
|
|
1338
1829
|
//#endregion
|
|
1339
1830
|
//#region src/view/render.d.ts
|
|
1831
|
+
interface DomNodeLike$2 {
|
|
1832
|
+
attribs?: Record<string, string>;
|
|
1833
|
+
children?: DomNodeLike$2[];
|
|
1834
|
+
data?: string;
|
|
1835
|
+
name?: string;
|
|
1836
|
+
parent?: DomNodeLike$2 | null;
|
|
1837
|
+
type?: string;
|
|
1838
|
+
}
|
|
1839
|
+
interface RenderedPageTree {
|
|
1840
|
+
root: DomNodeLike$2;
|
|
1841
|
+
wxml: string;
|
|
1842
|
+
}
|
|
1843
|
+
declare function renderPageTree(project: HeadlessProjectDescriptor, page: HeadlessPageInstance): RenderedPageTree;
|
|
1844
|
+
//#endregion
|
|
1845
|
+
//#region src/view/selectorQuery.d.ts
|
|
1340
1846
|
interface DomNodeLike$1 {
|
|
1341
1847
|
attribs?: Record<string, string>;
|
|
1342
1848
|
children?: DomNodeLike$1[];
|
|
@@ -1345,11 +1851,13 @@ interface DomNodeLike$1 {
|
|
|
1345
1851
|
parent?: DomNodeLike$1 | null;
|
|
1346
1852
|
type?: string;
|
|
1347
1853
|
}
|
|
1348
|
-
interface
|
|
1854
|
+
interface HeadlessSelectorQueryResolverOptions {
|
|
1855
|
+
page: HeadlessPageInstance;
|
|
1349
1856
|
root: DomNodeLike$1;
|
|
1350
|
-
|
|
1857
|
+
windowInfo: HeadlessWxWindowInfoResult;
|
|
1351
1858
|
}
|
|
1352
|
-
declare function
|
|
1859
|
+
declare function executeSelectorQueryRequests(requests: HeadlessWxSelectorQueryRequest[], options: HeadlessSelectorQueryResolverOptions): (Record<string, any> | Record<string, any>[] | null)[];
|
|
1860
|
+
declare function resolveSelectorQueryScopeRoot(root: DomNodeLike$1, scopeId?: string | null): DomNodeLike$1;
|
|
1353
1861
|
//#endregion
|
|
1354
1862
|
//#region src/view/selectors.d.ts
|
|
1355
1863
|
interface DomNodeLike {
|
|
@@ -1374,15 +1882,21 @@ interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptio
|
|
|
1374
1882
|
declare class HeadlessTestingPageHandle {
|
|
1375
1883
|
private readonly project;
|
|
1376
1884
|
private readonly page;
|
|
1377
|
-
|
|
1885
|
+
private readonly session?;
|
|
1886
|
+
constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance, session?: HeadlessSession | undefined);
|
|
1378
1887
|
private resolveDataByPath;
|
|
1379
1888
|
private pollUntil;
|
|
1889
|
+
private createScopeHandle;
|
|
1380
1890
|
callMethod(methodName: string, ...args: any[]): Promise<any>;
|
|
1381
1891
|
data(path?: string): Promise<any>;
|
|
1892
|
+
selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
|
|
1893
|
+
selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
|
|
1382
1894
|
waitFor(ms?: number): Promise<void>;
|
|
1383
1895
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
1384
1896
|
$$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
1385
1897
|
waitForSelector(selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<HeadlessTestingNodeHandle | null>;
|
|
1898
|
+
waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
|
|
1899
|
+
waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
|
|
1386
1900
|
waitForText(text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
|
|
1387
1901
|
waitForTextGone(text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
|
|
1388
1902
|
waitForData(path: string, matcher?: HeadlessTestingDataMatcher, options?: HeadlessTestingWaitOptions): Promise<any>;
|
|
@@ -1390,6 +1904,50 @@ declare class HeadlessTestingPageHandle {
|
|
|
1390
1904
|
}
|
|
1391
1905
|
//#endregion
|
|
1392
1906
|
//#region src/testing/sessionHandle.d.ts
|
|
1907
|
+
declare class HeadlessTestingScopeHandle {
|
|
1908
|
+
readonly scopeId: string;
|
|
1909
|
+
private readonly project;
|
|
1910
|
+
private readonly session;
|
|
1911
|
+
constructor(scopeId: string, project: HeadlessProjectDescriptor, session: HeadlessSession);
|
|
1912
|
+
private createScopeHandle;
|
|
1913
|
+
callMethod(methodName: string, ...args: any[]): Promise<any>;
|
|
1914
|
+
snapshot(): Promise<{
|
|
1915
|
+
data: Record<string, any>;
|
|
1916
|
+
methods: string[];
|
|
1917
|
+
properties: Record<string, any>;
|
|
1918
|
+
scopeId: string;
|
|
1919
|
+
type: "component";
|
|
1920
|
+
} | {
|
|
1921
|
+
data: Record<string, any>;
|
|
1922
|
+
methods: string[];
|
|
1923
|
+
properties: Record<string, string>;
|
|
1924
|
+
scopeId: string;
|
|
1925
|
+
type: "page";
|
|
1926
|
+
} | {
|
|
1927
|
+
data: any;
|
|
1928
|
+
methods: string[];
|
|
1929
|
+
properties: {};
|
|
1930
|
+
scopeId: string;
|
|
1931
|
+
type: "scope";
|
|
1932
|
+
} | null>;
|
|
1933
|
+
page(): Promise<HeadlessTestingPageHandle | null>;
|
|
1934
|
+
pageScope(): Promise<HeadlessTestingScopeHandle>;
|
|
1935
|
+
ownerComponent(): Promise<HeadlessTestingScopeHandle | null>;
|
|
1936
|
+
waitForOwnerComponent(options?: {
|
|
1937
|
+
interval?: number;
|
|
1938
|
+
timeout?: number;
|
|
1939
|
+
}): Promise<HeadlessTestingScopeHandle>;
|
|
1940
|
+
selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
|
|
1941
|
+
selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
|
|
1942
|
+
waitForComponent(selector: string, options?: {
|
|
1943
|
+
interval?: number;
|
|
1944
|
+
timeout?: number;
|
|
1945
|
+
}): Promise<HeadlessTestingScopeHandle>;
|
|
1946
|
+
waitForComponents(selector: string, count?: number, options?: {
|
|
1947
|
+
interval?: number;
|
|
1948
|
+
timeout?: number;
|
|
1949
|
+
}): Promise<HeadlessTestingScopeHandle[]>;
|
|
1950
|
+
}
|
|
1393
1951
|
declare class HeadlessTestingSessionHandle {
|
|
1394
1952
|
private readonly project;
|
|
1395
1953
|
private readonly session;
|
|
@@ -1399,6 +1957,29 @@ declare class HeadlessTestingSessionHandle {
|
|
|
1399
1957
|
close(): Promise<void>;
|
|
1400
1958
|
currentPage(): Promise<HeadlessTestingPageHandle | null>;
|
|
1401
1959
|
getCurrentPages(): Promise<HeadlessTestingPageHandle[]>;
|
|
1960
|
+
scopeSnapshot(scopeId: string): Promise<{
|
|
1961
|
+
data: Record<string, any>;
|
|
1962
|
+
methods: string[];
|
|
1963
|
+
properties: Record<string, any>;
|
|
1964
|
+
scopeId: string;
|
|
1965
|
+
type: "component";
|
|
1966
|
+
} | {
|
|
1967
|
+
data: Record<string, any>;
|
|
1968
|
+
methods: string[];
|
|
1969
|
+
properties: Record<string, string>;
|
|
1970
|
+
scopeId: string;
|
|
1971
|
+
type: "page";
|
|
1972
|
+
} | {
|
|
1973
|
+
data: any;
|
|
1974
|
+
methods: string[];
|
|
1975
|
+
properties: {};
|
|
1976
|
+
scopeId: string;
|
|
1977
|
+
type: "scope";
|
|
1978
|
+
} | null>;
|
|
1979
|
+
selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
|
|
1980
|
+
selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
|
|
1981
|
+
waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
|
|
1982
|
+
waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
|
|
1402
1983
|
reLaunch(route: string): Promise<HeadlessTestingPageHandle>;
|
|
1403
1984
|
waitForCurrentPage(route?: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingPageHandle>;
|
|
1404
1985
|
pageScrollTo(scrollTop: number): Promise<void>;
|
|
@@ -1414,4 +1995,4 @@ interface HeadlessTestingLaunchOptions {
|
|
|
1414
1995
|
}
|
|
1415
1996
|
declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
|
|
1416
1997
|
//#endregion
|
|
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 };
|
|
1998
|
+
export { BrowserDirectoryFileLike, BrowserHeadlessSession, BrowserHeadlessSessionOptions, BrowserModuleLoader, BrowserRenderedPageTree, BrowserRendererContext, BrowserVirtualFiles, CreateBrowserProjectOptions, CreateComponentInstanceOptions, CreateProjectDescriptorOptions, HeadlessAppDefinition, HeadlessAppInstance, HeadlessBehaviorDefinition, HeadlessComponentDefinition, HeadlessComponentInstance, HeadlessHostLoadContext, HeadlessHostRegistries, HeadlessPageDefinition, HeadlessPageInstance, HeadlessProjectConfigFile, HeadlessProjectDescriptor, HeadlessRouteRecord, HeadlessSelectorQueryResolverOptions, HeadlessSession, HeadlessSessionOptions, HeadlessTestingDataMatcher, HeadlessTestingLaunchOptions, HeadlessTestingNodeHandle, HeadlessTestingPageHandle, HeadlessTestingScopeHandle, HeadlessTestingSessionHandle, HeadlessTestingWaitForSelectorOptions, HeadlessTestingWaitOptions, HeadlessWx, HeadlessWxAccessFileOption, HeadlessWxActionSheetLogEntry, HeadlessWxActionSheetMockDefinition, HeadlessWxAppBaseInfoResult, HeadlessWxAppendFileOption, HeadlessWxCallbackOption, HeadlessWxClearStorageOption, HeadlessWxCopyFileOption, HeadlessWxDownloadFileLogEntry, HeadlessWxDownloadFileMockDefinition, HeadlessWxDownloadFileOption, HeadlessWxDownloadFileSuccessResult, HeadlessWxDriver, HeadlessWxFileSystemManager, HeadlessWxFileSystemResult, HeadlessWxGetAppBaseInfoOption, HeadlessWxGetNetworkTypeOption, HeadlessWxGetNetworkTypeResult, HeadlessWxGetSavedFileInfoOption, HeadlessWxGetSavedFileInfoSuccessResult, HeadlessWxGetSavedFileListOption, HeadlessWxGetSavedFileListSuccessResult, HeadlessWxGetStorageInfoOption, HeadlessWxGetStorageOption, HeadlessWxGetStorageResult, HeadlessWxGetSystemInfoOption, HeadlessWxGetWindowInfoOption, HeadlessWxHideLoadingOption, HeadlessWxHideNavigationBarLoadingOption, HeadlessWxLaunchOptions, HeadlessWxLoadingSnapshot, HeadlessWxMenuButtonBoundingClientRectResult, HeadlessWxMkdirOption, HeadlessWxModalLogEntry, HeadlessWxModalMockDefinition, HeadlessWxNavigateBackOption, HeadlessWxNavigateOption, HeadlessWxNetworkSnapshot, HeadlessWxNetworkStatusChangeCallback, HeadlessWxNetworkStatusChangeResult, HeadlessWxNetworkType, HeadlessWxPageScrollToOption, HeadlessWxReadDirOption, HeadlessWxReadDirSuccessResult, HeadlessWxReadFileOption, HeadlessWxReadFileSuccessResult, HeadlessWxRemoveSavedFileOption, HeadlessWxRemoveStorageOption, HeadlessWxRenameOption, HeadlessWxRequestLogEntry, HeadlessWxRequestMockDefinition, HeadlessWxRequestOption, HeadlessWxRequestSuccessResult, HeadlessWxRequestTask, HeadlessWxRmdirOption, HeadlessWxSaveFileOption, HeadlessWxSaveFileSuccessResult, HeadlessWxSavedFileInfo, HeadlessWxSelectorQuery, HeadlessWxSelectorQueryBoundingClientRectResult, HeadlessWxSelectorQueryFieldsOption, HeadlessWxSelectorQueryNode, HeadlessWxSelectorQueryRequest, HeadlessWxSelectorQueryScrollOffsetResult, HeadlessWxSetBackgroundColorOption, HeadlessWxSetBackgroundTextStyleOption, HeadlessWxSetNavigationBarColorOption, HeadlessWxSetNavigationBarTitleOption, HeadlessWxSetStorageOption, HeadlessWxSetTabBarBadgeOption, HeadlessWxShareMenuOption, HeadlessWxShareMenuSnapshot, HeadlessWxShowActionSheetOption, HeadlessWxShowActionSheetResult, HeadlessWxShowLoadingOption, HeadlessWxShowModalOption, HeadlessWxShowModalResult, HeadlessWxShowNavigationBarLoadingOption, HeadlessWxShowToastOption, HeadlessWxStatOption, HeadlessWxStatSuccessResult, HeadlessWxStats, HeadlessWxStorageInfoResult, HeadlessWxStorageResult, HeadlessWxSystemInfoResult, HeadlessWxTabBarItemOption, HeadlessWxTabBarOption, HeadlessWxToastSnapshot, HeadlessWxUnlinkOption, HeadlessWxUploadFileLogEntry, HeadlessWxUploadFileMockDefinition, HeadlessWxUploadFileOption, HeadlessWxUploadFileSuccessResult, HeadlessWxWindowInfoResult, HeadlessWxWriteFileOption, RenderedPageTree, RuntimeRenderedPageTree, RuntimeRendererContext, cloneValue, coerceComponentPropertyValue, createAppInstance, createBrowserHeadlessSession, createBrowserModuleLoader, createBrowserProject, createBrowserVirtualFiles, createBrowserVirtualFilesFromDirectory, createComponentInstance, createHeadlessSession, createHeadlessWx, createHeadlessWxState, createHostRegistries, createPageInstance, createProjectDescriptor, executeSelectorQueryRequests, hasBrowserVirtualFile, launch, loadProject, normalizeBrowserFilePath, normalizeComponentPropertyValue, querySelectorAll, readBrowserVirtualFile, registerAppDefinition, registerComponentDefinition, registerPageDefinition, renderBrowserPageTree, renderPageTree, renderRuntimePageTree, resolveRoutesFromAppConfig, resolveSelectorQueryScopeRoot, runComponentLifecycle, runComponentObservers, runComponentPageLifetime };
|