@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.
Files changed (3) hide show
  1. package/dist/index.d.mts +660 -79
  2. package/dist/index.mjs +2995 -1181
  3. 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$3 {
746
+ interface DomNodeLike$5 {
544
747
  attribs?: Record<string, string>;
545
- children?: DomNodeLike$3[];
748
+ children?: DomNodeLike$5[];
546
749
  data?: string;
547
750
  name?: string;
548
- parent?: DomNodeLike$3 | null;
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$3;
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/browser/session.d.ts
754
- interface BrowserHeadlessSessionOptions {
755
- files: BrowserVirtualFiles;
756
- project?: HeadlessProjectDescriptor;
1091
+ //#region src/runtime/session.d.ts
1092
+ interface HeadlessSessionOptions {
1093
+ projectPath: string;
757
1094
  }
758
- declare class BrowserHeadlessSession {
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
- constructor(options: BrowserHeadlessSessionOptions);
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 createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
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/runtime/session.d.ts
1044
- interface HeadlessSessionOptions {
1045
- projectPath: string;
1417
+ //#region src/browser/session.d.ts
1418
+ interface BrowserHeadlessSessionOptions {
1419
+ files: BrowserVirtualFiles;
1420
+ project?: HeadlessProjectDescriptor;
1046
1421
  }
1047
- declare class HeadlessSession {
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
- constructor(options: HeadlessSessionOptions);
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 createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
1752
+ declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
1289
1753
  //#endregion
1290
1754
  //#region src/view/nodeHandle.d.ts
1291
- interface DomNodeLike$2 {
1755
+ interface DomNodeLike$3 {
1292
1756
  attribs?: Record<string, string>;
1293
- children?: DomNodeLike$2[];
1757
+ children?: DomNodeLike$3[];
1294
1758
  data?: string;
1295
1759
  name?: string;
1296
- parent?: DomNodeLike$2 | null;
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$2, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
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 RenderedPageTree {
1854
+ interface HeadlessSelectorQueryResolverOptions {
1855
+ page: HeadlessPageInstance;
1349
1856
  root: DomNodeLike$1;
1350
- wxml: string;
1857
+ windowInfo: HeadlessWxWindowInfoResult;
1351
1858
  }
1352
- declare function renderPageTree(project: HeadlessProjectDescriptor, page: HeadlessPageInstance): RenderedPageTree;
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
- constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance);
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 };