@mpcore/simulator 0.1.4 → 0.3.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 CHANGED
@@ -18,14 +18,25 @@ interface HeadlessHostRegistries {
18
18
  declare function createHostRegistries(): HeadlessHostRegistries;
19
19
  declare function registerAppDefinition(registries: HeadlessHostRegistries, definition: HeadlessAppDefinition): HeadlessAppDefinition;
20
20
  declare function registerPageDefinition(registries: HeadlessHostRegistries, definition: HeadlessPageDefinition): HeadlessPageDefinition;
21
- declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition): HeadlessComponentDefinition;
21
+ declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition): HeadlessPageDefinition;
22
+ declare function registerExportedComponentDefinition(registries: HeadlessHostRegistries, id: string, moduleExports: Record<string, any>, registeredDefinition?: HeadlessComponentDefinition): HeadlessComponentDefinition | null;
22
23
  //#endregion
23
- //#region src/host/wx.d.ts
24
+ //#region src/host/wx/core.d.ts
24
25
  interface HeadlessWxCallbackOption<TResult = void> {
25
26
  complete?: (result?: TResult) => void;
26
27
  fail?: (error: Error) => void;
27
28
  success?: (result: TResult) => void;
28
29
  }
30
+ interface HeadlessWxLoadFontFaceResult {
31
+ errMsg: string;
32
+ }
33
+ interface HeadlessWxLoadFontFaceOption extends HeadlessWxCallbackOption<HeadlessWxLoadFontFaceResult> {
34
+ descriptors?: Record<string, string>;
35
+ family: string;
36
+ global?: boolean;
37
+ scopes?: string[];
38
+ source: string;
39
+ }
29
40
  interface HeadlessWxNavigateOption extends HeadlessWxCallbackOption {
30
41
  url: string;
31
42
  }
@@ -218,6 +229,7 @@ interface HeadlessWxSelectorQueryRequest {
218
229
  interface HeadlessWxSelectorQueryNode {
219
230
  boundingClientRect: (callback?: (result: HeadlessWxSelectorQueryBoundingClientRectResult | HeadlessWxSelectorQueryBoundingClientRectResult[] | null) => void) => HeadlessWxSelectorQuery;
220
231
  fields: (fields: HeadlessWxSelectorQueryFieldsOption, callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
232
+ node: (callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
221
233
  scrollOffset: (callback?: (result: HeadlessWxSelectorQueryScrollOffsetResult | HeadlessWxSelectorQueryScrollOffsetResult[] | null) => void) => HeadlessWxSelectorQuery;
222
234
  }
223
235
  interface HeadlessWxSelectorQuery {
@@ -243,6 +255,16 @@ interface HeadlessWxGetNetworkTypeResult {
243
255
  errMsg: string;
244
256
  networkType: HeadlessWxNetworkType;
245
257
  }
258
+ interface HeadlessWxGetLocationResult {
259
+ accuracy: number;
260
+ altitude: number;
261
+ errMsg: string;
262
+ horizontalAccuracy: number;
263
+ latitude: number;
264
+ longitude: number;
265
+ speed: number;
266
+ verticalAccuracy: number;
267
+ }
246
268
  interface HeadlessWxNetworkStatusChangeResult {
247
269
  isConnected: boolean;
248
270
  networkType: HeadlessWxNetworkType;
@@ -255,6 +277,8 @@ interface HeadlessWxSystemInfoResult {
255
277
  model: string;
256
278
  pixelRatio: number;
257
279
  platform: string;
280
+ safeArea: HeadlessWxSafeArea;
281
+ safeAreaInsets: HeadlessWxSafeAreaInsets;
258
282
  screenHeight: number;
259
283
  screenWidth: number;
260
284
  system: string;
@@ -262,6 +286,20 @@ interface HeadlessWxSystemInfoResult {
262
286
  windowHeight: number;
263
287
  windowWidth: number;
264
288
  }
289
+ interface HeadlessWxSafeArea {
290
+ bottom: number;
291
+ height: number;
292
+ left: number;
293
+ right: number;
294
+ top: number;
295
+ width: number;
296
+ }
297
+ interface HeadlessWxSafeAreaInsets {
298
+ bottom: number;
299
+ left: number;
300
+ right: number;
301
+ top: number;
302
+ }
265
303
  interface HeadlessWxAppBaseInfoResult {
266
304
  SDKVersion: string;
267
305
  enableDebug: boolean;
@@ -272,8 +310,21 @@ interface HeadlessWxAppBaseInfoResult {
272
310
  platform: string;
273
311
  version: string;
274
312
  }
313
+ interface HeadlessWxDeviceInfoResult {
314
+ abi: string;
315
+ benchmarkLevel: number;
316
+ brand: string;
317
+ cpuType: string;
318
+ deviceAbi: string;
319
+ memorySize: number;
320
+ model: string;
321
+ platform: string;
322
+ system: string;
323
+ }
275
324
  interface HeadlessWxWindowInfoResult {
276
325
  pixelRatio: number;
326
+ safeArea: HeadlessWxSafeArea;
327
+ safeAreaInsets: HeadlessWxSafeAreaInsets;
277
328
  screenHeight: number;
278
329
  screenWidth: number;
279
330
  statusBarHeight: number;
@@ -317,9 +368,115 @@ interface HeadlessWxGetStorageOption extends HeadlessWxCallbackOption<HeadlessWx
317
368
  }
318
369
  interface HeadlessWxGetStorageInfoOption extends HeadlessWxCallbackOption<HeadlessWxStorageInfoResult> {}
319
370
  interface HeadlessWxGetNetworkTypeOption extends HeadlessWxCallbackOption<HeadlessWxGetNetworkTypeResult> {}
371
+ interface HeadlessWxGetLocationOption extends HeadlessWxCallbackOption<HeadlessWxGetLocationResult> {
372
+ altitude?: boolean;
373
+ highAccuracyExpireTime?: number;
374
+ isHighAccuracy?: boolean;
375
+ type?: 'gcj02' | 'wgs84';
376
+ }
320
377
  interface HeadlessWxGetSystemInfoOption extends HeadlessWxCallbackOption<HeadlessWxSystemInfoResult> {}
321
378
  interface HeadlessWxGetWindowInfoOption extends HeadlessWxCallbackOption<HeadlessWxWindowInfoResult> {}
322
379
  interface HeadlessWxGetAppBaseInfoOption extends HeadlessWxCallbackOption<HeadlessWxAppBaseInfoResult> {}
380
+ //#endregion
381
+ //#region src/host/wx/eventBus.d.ts
382
+ type HeadlessUniEventHandler = (...args: any[]) => void;
383
+ interface HeadlessUniEventBus {
384
+ $emit: (eventName: string, ...args: any[]) => void;
385
+ $off: (eventName?: string, handler?: HeadlessUniEventHandler) => void;
386
+ $on: (eventName: string, handler: HeadlessUniEventHandler) => void;
387
+ $once: (eventName: string, handler: HeadlessUniEventHandler) => void;
388
+ }
389
+ declare function createHeadlessUniEventBus(): HeadlessUniEventBus;
390
+ //#endregion
391
+ //#region src/host/wx/fileSystem.d.ts
392
+ interface HeadlessWxFileSystemResult {
393
+ errMsg: string;
394
+ }
395
+ interface HeadlessWxReadFileSuccessResult {
396
+ data: string;
397
+ errMsg: string;
398
+ }
399
+ interface HeadlessWxReadFileOption extends HeadlessWxCallbackOption<HeadlessWxReadFileSuccessResult> {
400
+ encoding?: string;
401
+ filePath: string;
402
+ }
403
+ interface HeadlessWxWriteFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
404
+ data: string;
405
+ encoding?: string;
406
+ filePath: string;
407
+ }
408
+ interface HeadlessWxAccessFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
409
+ path: string;
410
+ }
411
+ interface HeadlessWxAppendFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
412
+ data: string;
413
+ encoding?: string;
414
+ filePath: string;
415
+ }
416
+ interface HeadlessWxUnlinkOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
417
+ filePath: string;
418
+ }
419
+ interface HeadlessWxCopyFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
420
+ destPath: string;
421
+ srcPath: string;
422
+ }
423
+ interface HeadlessWxRenameOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
424
+ newPath: string;
425
+ oldPath: string;
426
+ }
427
+ interface HeadlessWxMkdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
428
+ dirPath: string;
429
+ recursive?: boolean;
430
+ }
431
+ interface HeadlessWxRmdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
432
+ dirPath: string;
433
+ recursive?: boolean;
434
+ }
435
+ interface HeadlessWxReadDirSuccessResult {
436
+ errMsg: string;
437
+ files: string[];
438
+ }
439
+ interface HeadlessWxReadDirOption extends HeadlessWxCallbackOption<HeadlessWxReadDirSuccessResult> {
440
+ dirPath: string;
441
+ }
442
+ interface HeadlessWxStats {
443
+ isDirectory: () => boolean;
444
+ isFile: () => boolean;
445
+ size: number;
446
+ }
447
+ interface HeadlessWxStatSuccessResult {
448
+ errMsg: string;
449
+ stats: HeadlessWxStats;
450
+ }
451
+ interface HeadlessWxStatOption extends HeadlessWxCallbackOption<HeadlessWxStatSuccessResult> {
452
+ path: string;
453
+ }
454
+ interface HeadlessWxFileSystemManager {
455
+ access: (option: HeadlessWxAccessFileOption) => HeadlessWxFileSystemResult | undefined;
456
+ accessSync: (path: string) => void;
457
+ appendFile: (option: HeadlessWxAppendFileOption) => HeadlessWxFileSystemResult | undefined;
458
+ appendFileSync: (filePath: string, data: string, encoding?: string) => void;
459
+ copyFile: (option: HeadlessWxCopyFileOption) => HeadlessWxFileSystemResult | undefined;
460
+ copyFileSync: (srcPath: string, destPath: string) => void;
461
+ mkdir: (option: HeadlessWxMkdirOption) => HeadlessWxFileSystemResult | undefined;
462
+ mkdirSync: (dirPath: string, recursive?: boolean) => void;
463
+ readFile: (option: HeadlessWxReadFileOption) => HeadlessWxReadFileSuccessResult | undefined;
464
+ readFileSync: (filePath: string, encoding?: string) => string;
465
+ readdir: (option: HeadlessWxReadDirOption) => HeadlessWxReadDirSuccessResult | undefined;
466
+ readdirSync: (dirPath: string) => string[];
467
+ rmdir: (option: HeadlessWxRmdirOption) => HeadlessWxFileSystemResult | undefined;
468
+ rmdirSync: (dirPath: string, recursive?: boolean) => void;
469
+ rename: (option: HeadlessWxRenameOption) => HeadlessWxFileSystemResult | undefined;
470
+ renameSync: (oldPath: string, newPath: string) => void;
471
+ stat: (option: HeadlessWxStatOption) => HeadlessWxStatSuccessResult | undefined;
472
+ statSync: (path: string) => HeadlessWxStats;
473
+ unlink: (option: HeadlessWxUnlinkOption) => HeadlessWxFileSystemResult | undefined;
474
+ unlinkSync: (filePath: string) => void;
475
+ writeFile: (option: HeadlessWxWriteFileOption) => HeadlessWxFileSystemResult | undefined;
476
+ writeFileSync: (filePath: string, data: string, encoding?: string) => void;
477
+ }
478
+ //#endregion
479
+ //#region src/host/wx/media.d.ts
323
480
  interface HeadlessWxGetImageInfoResult {
324
481
  errMsg: string;
325
482
  height: number;
@@ -639,116 +796,19 @@ interface HeadlessWxRemoveSavedFileOption extends HeadlessWxCallbackOption<{
639
796
  }> {
640
797
  filePath: string;
641
798
  }
642
- interface HeadlessWxFileSystemResult {
643
- errMsg: string;
644
- }
645
- interface HeadlessWxReadFileSuccessResult {
646
- data: string;
647
- errMsg: string;
648
- }
649
- interface HeadlessWxReadFileOption extends HeadlessWxCallbackOption<HeadlessWxReadFileSuccessResult> {
650
- encoding?: string;
651
- filePath: string;
652
- }
653
- interface HeadlessWxWriteFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
654
- data: string;
655
- encoding?: string;
656
- filePath: string;
657
- }
658
- interface HeadlessWxAccessFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
659
- path: string;
660
- }
661
- interface HeadlessWxAppendFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
662
- data: string;
663
- encoding?: string;
664
- filePath: string;
665
- }
666
- interface HeadlessWxUnlinkOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
667
- filePath: string;
668
- }
669
- interface HeadlessWxCopyFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
670
- destPath: string;
671
- srcPath: string;
672
- }
673
- interface HeadlessWxRenameOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
674
- newPath: string;
675
- oldPath: string;
676
- }
677
- interface HeadlessWxMkdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
678
- dirPath: string;
679
- recursive?: boolean;
680
- }
681
- interface HeadlessWxRmdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
682
- dirPath: string;
683
- recursive?: boolean;
684
- }
685
- interface HeadlessWxReadDirSuccessResult {
686
- errMsg: string;
687
- files: string[];
688
- }
689
- interface HeadlessWxReadDirOption extends HeadlessWxCallbackOption<HeadlessWxReadDirSuccessResult> {
690
- dirPath: string;
691
- }
692
- interface HeadlessWxStats {
693
- isDirectory: () => boolean;
694
- isFile: () => boolean;
695
- size: number;
696
- }
697
- interface HeadlessWxStatSuccessResult {
698
- errMsg: string;
699
- stats: HeadlessWxStats;
700
- }
701
- interface HeadlessWxStatOption extends HeadlessWxCallbackOption<HeadlessWxStatSuccessResult> {
702
- path: string;
703
- }
704
- interface HeadlessWxFileSystemManager {
705
- access: (option: HeadlessWxAccessFileOption) => HeadlessWxFileSystemResult | undefined;
706
- accessSync: (path: string) => void;
707
- appendFile: (option: HeadlessWxAppendFileOption) => HeadlessWxFileSystemResult | undefined;
708
- appendFileSync: (filePath: string, data: string, encoding?: string) => void;
709
- copyFile: (option: HeadlessWxCopyFileOption) => HeadlessWxFileSystemResult | undefined;
710
- copyFileSync: (srcPath: string, destPath: string) => void;
711
- mkdir: (option: HeadlessWxMkdirOption) => HeadlessWxFileSystemResult | undefined;
712
- mkdirSync: (dirPath: string, recursive?: boolean) => void;
713
- readFile: (option: HeadlessWxReadFileOption) => HeadlessWxReadFileSuccessResult | undefined;
714
- readFileSync: (filePath: string, encoding?: string) => string;
715
- readdir: (option: HeadlessWxReadDirOption) => HeadlessWxReadDirSuccessResult | undefined;
716
- readdirSync: (dirPath: string) => string[];
717
- rmdir: (option: HeadlessWxRmdirOption) => HeadlessWxFileSystemResult | undefined;
718
- rmdirSync: (dirPath: string, recursive?: boolean) => void;
719
- rename: (option: HeadlessWxRenameOption) => HeadlessWxFileSystemResult | undefined;
720
- renameSync: (oldPath: string, newPath: string) => void;
721
- stat: (option: HeadlessWxStatOption) => HeadlessWxStatSuccessResult | undefined;
722
- statSync: (path: string) => HeadlessWxStats;
723
- unlink: (option: HeadlessWxUnlinkOption) => HeadlessWxFileSystemResult | undefined;
724
- unlinkSync: (filePath: string) => void;
725
- writeFile: (option: HeadlessWxWriteFileOption) => HeadlessWxFileSystemResult | undefined;
726
- writeFileSync: (filePath: string, data: string, encoding?: string) => void;
727
- }
728
- interface HeadlessWxDriver {
729
- chooseImage: (option: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult;
730
- chooseMessageFile: (option: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult;
731
- chooseMedia: (option: HeadlessWxChooseMediaOption) => HeadlessWxChooseMediaResult;
732
- chooseVideo: (option: HeadlessWxChooseVideoOption) => HeadlessWxChooseVideoResult;
733
- compressImage: (option: HeadlessWxCompressImageOption) => HeadlessWxCompressImageResult;
799
+ interface HeadlessWxDriverCapabilities {
800
+ clearStorageSync: () => void;
734
801
  createAnimation: (option?: HeadlessWxAnimationStepOption) => HeadlessWxAnimation;
735
802
  createCanvasContext: (canvasId: string, scope?: Record<string, any>) => HeadlessWxCanvasContext;
736
- canvasToTempFilePath: (option: HeadlessWxCanvasToTempFilePathOption) => HeadlessWxCanvasToTempFilePathSuccessResult;
737
803
  createIntersectionObserver: (scope: Record<string, any> | undefined, options?: HeadlessWxCreateIntersectionObserverOption) => HeadlessWxIntersectionObserver;
738
804
  createVideoContext: (videoId: string, scope?: Record<string, any>) => HeadlessWxVideoContext;
739
805
  executeSelectorQuery: (requests: HeadlessWxSelectorQueryRequest[], scope?: Record<string, any>) => unknown[];
740
806
  getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
741
- getFileInfo: (option: HeadlessWxGetFileInfoOption) => HeadlessWxGetFileInfoResult;
742
- getImageInfo: (option: HeadlessWxGetImageInfoOption) => HeadlessWxGetImageInfoResult;
743
- getVideoInfo: (option: HeadlessWxGetVideoInfoOption) => HeadlessWxGetVideoInfoResult;
744
- getFileSystemManager: () => HeadlessWxFileSystemManager;
745
- getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult;
746
- getSavedFileList: (option?: HeadlessWxGetSavedFileListOption) => HeadlessWxGetSavedFileListSuccessResult;
747
- clearStorageSync: () => void;
807
+ getDeviceInfo: () => HeadlessWxDeviceInfoResult;
808
+ getClipboardData: () => HeadlessWxGetClipboardDataResult;
748
809
  getEnterOptionsSync: () => HeadlessWxLaunchOptions;
749
810
  getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
750
811
  getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
751
- getClipboardData: () => HeadlessWxGetClipboardDataResult;
752
812
  getNetworkType: () => HeadlessWxGetNetworkTypeResult;
753
813
  getStorageInfoSync: () => HeadlessWxStorageInfoResult;
754
814
  getStorageSync: (key: string) => unknown;
@@ -760,25 +820,28 @@ interface HeadlessWxDriver {
760
820
  hideToast: () => {
761
821
  errMsg: string;
762
822
  };
763
- downloadFile: (option: HeadlessWxDownloadFileOption) => HeadlessWxRequestTask;
823
+ hideNavigationBarLoading: () => {
824
+ errMsg: string;
825
+ };
826
+ hideShareMenu: () => {
827
+ errMsg: string;
828
+ };
829
+ hideTabBar: () => {
830
+ errMsg: string;
831
+ };
832
+ hideTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
833
+ errMsg: string;
834
+ };
764
835
  navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
765
836
  navigateTo: (option: HeadlessWxNavigateOption) => unknown;
766
837
  nextTick: (callback?: () => void) => void;
767
838
  offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
768
839
  onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
769
- openDocument: (option: HeadlessWxOpenDocumentOption) => HeadlessWxOpenDocumentResult;
770
840
  pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
771
841
  reLaunch: (option: HeadlessWxNavigateOption) => unknown;
772
842
  redirectTo: (option: HeadlessWxNavigateOption) => unknown;
773
843
  removeStorageSync: (key: string) => void;
774
- request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
775
- previewImage: (option: HeadlessWxPreviewImageOption) => HeadlessWxPreviewImageResult;
776
- removeSavedFile: (option: HeadlessWxRemoveSavedFileOption) => {
777
- errMsg: string;
778
- };
779
- saveImageToPhotosAlbum: (option: HeadlessWxSaveImageToPhotosAlbumOption) => HeadlessWxSaveImageToPhotosAlbumResult;
780
- saveVideoToPhotosAlbum: (option: HeadlessWxSaveVideoToPhotosAlbumOption) => HeadlessWxSaveVideoToPhotosAlbumResult;
781
- saveFile: (option: HeadlessWxSaveFileOption) => HeadlessWxSaveFileSuccessResult;
844
+ setStorageSync: (key: string, value: unknown) => void;
782
845
  setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
783
846
  errMsg: string;
784
847
  };
@@ -786,42 +849,29 @@ interface HeadlessWxDriver {
786
849
  errMsg: string;
787
850
  };
788
851
  setClipboardData: (option: HeadlessWxSetClipboardDataOption) => HeadlessWxSetClipboardDataResult;
789
- setStorageSync: (key: string, value: unknown) => void;
790
852
  setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
791
853
  errMsg: string;
792
854
  };
793
855
  setNavigationBarTitle: (option: HeadlessWxSetNavigationBarTitleOption) => {
794
856
  errMsg: string;
795
857
  };
796
- hideShareMenu: () => {
797
- errMsg: string;
798
- };
799
- hideNavigationBarLoading: () => {
800
- errMsg: string;
801
- };
802
- hideTabBar: () => {
858
+ showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult;
859
+ showLoading: (option: HeadlessWxShowLoadingOption) => {
803
860
  errMsg: string;
804
861
  };
805
- hideTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
862
+ showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult;
863
+ showNavigationBarLoading: () => {
806
864
  errMsg: string;
807
865
  };
808
866
  showShareMenu: (option: HeadlessWxShareMenuOption) => {
809
867
  errMsg: string;
810
868
  };
811
- showNavigationBarLoading: () => {
812
- errMsg: string;
813
- };
814
869
  showTabBar: () => {
815
870
  errMsg: string;
816
871
  };
817
872
  showTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
818
873
  errMsg: string;
819
874
  };
820
- showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult;
821
- showLoading: (option: HeadlessWxShowLoadingOption) => {
822
- errMsg: string;
823
- };
824
- showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult;
825
875
  showToast: (option: HeadlessWxShowToastOption) => {
826
876
  errMsg: string;
827
877
  };
@@ -830,7 +880,6 @@ interface HeadlessWxDriver {
830
880
  };
831
881
  stopPullDownRefresh: () => void;
832
882
  switchTab: (option: HeadlessWxNavigateOption) => unknown;
833
- uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
834
883
  removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
835
884
  errMsg: string;
836
885
  };
@@ -841,7 +890,35 @@ interface HeadlessWxDriver {
841
890
  errMsg: string;
842
891
  };
843
892
  }
844
- interface HeadlessWx {
893
+ //#endregion
894
+ //#region src/host/wx/api.d.ts
895
+ interface HeadlessWxDriver extends HeadlessWxDriverCapabilities {
896
+ chooseImage: (option: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult;
897
+ chooseMessageFile: (option: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult;
898
+ chooseMedia: (option: HeadlessWxChooseMediaOption) => HeadlessWxChooseMediaResult;
899
+ chooseVideo: (option: HeadlessWxChooseVideoOption) => HeadlessWxChooseVideoResult;
900
+ compressImage: (option: HeadlessWxCompressImageOption) => HeadlessWxCompressImageResult;
901
+ getFileInfo: (option: HeadlessWxGetFileInfoOption) => HeadlessWxGetFileInfoResult;
902
+ getImageInfo: (option: HeadlessWxGetImageInfoOption) => HeadlessWxGetImageInfoResult;
903
+ getLocation: (option?: HeadlessWxGetLocationOption) => HeadlessWxGetLocationResult;
904
+ getVideoInfo: (option: HeadlessWxGetVideoInfoOption) => HeadlessWxGetVideoInfoResult;
905
+ getFileSystemManager: () => HeadlessWxFileSystemManager;
906
+ getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult;
907
+ getSavedFileList: (option?: HeadlessWxGetSavedFileListOption) => HeadlessWxGetSavedFileListSuccessResult;
908
+ downloadFile: (option: HeadlessWxDownloadFileOption) => HeadlessWxRequestTask;
909
+ openDocument: (option: HeadlessWxOpenDocumentOption) => HeadlessWxOpenDocumentResult;
910
+ previewImage: (option: HeadlessWxPreviewImageOption) => HeadlessWxPreviewImageResult;
911
+ removeSavedFile: (option: HeadlessWxRemoveSavedFileOption) => {
912
+ errMsg: string;
913
+ };
914
+ request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
915
+ saveFile: (option: HeadlessWxSaveFileOption) => HeadlessWxSaveFileSuccessResult;
916
+ saveImageToPhotosAlbum: (option: HeadlessWxSaveImageToPhotosAlbumOption) => HeadlessWxSaveImageToPhotosAlbumResult;
917
+ saveVideoToPhotosAlbum: (option: HeadlessWxSaveVideoToPhotosAlbumOption) => HeadlessWxSaveVideoToPhotosAlbumResult;
918
+ canvasToTempFilePath: (option: HeadlessWxCanvasToTempFilePathOption) => HeadlessWxCanvasToTempFilePathSuccessResult;
919
+ uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
920
+ }
921
+ interface HeadlessWx extends HeadlessUniEventBus {
845
922
  canIUse: (schema: string) => boolean;
846
923
  chooseImage: (option?: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult | undefined;
847
924
  chooseMessageFile: (option?: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult | undefined;
@@ -858,6 +935,7 @@ interface HeadlessWx {
858
935
  createSelectorQuery: () => HeadlessWxSelectorQuery;
859
936
  getFileInfo: (option: HeadlessWxGetFileInfoOption) => HeadlessWxGetFileInfoResult | undefined;
860
937
  getImageInfo: (option: HeadlessWxGetImageInfoOption) => HeadlessWxGetImageInfoResult | undefined;
938
+ getLocale: () => string;
861
939
  getVideoInfo: (option: HeadlessWxGetVideoInfoOption) => HeadlessWxGetVideoInfoResult | undefined;
862
940
  getFileSystemManager: () => HeadlessWxFileSystemManager;
863
941
  getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult | undefined;
@@ -865,9 +943,11 @@ interface HeadlessWx {
865
943
  getEnterOptionsSync: () => HeadlessWxLaunchOptions;
866
944
  getAppBaseInfo: (option?: HeadlessWxGetAppBaseInfoOption) => HeadlessWxAppBaseInfoResult | undefined;
867
945
  getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
946
+ getDeviceInfo: () => HeadlessWxDeviceInfoResult;
868
947
  getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
869
948
  getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
870
949
  getClipboardData: (option?: HeadlessWxGetClipboardDataOption) => HeadlessWxGetClipboardDataResult | undefined;
950
+ getLocation: (option?: HeadlessWxGetLocationOption) => HeadlessWxGetLocationResult | undefined;
871
951
  getNetworkType: (option?: HeadlessWxGetNetworkTypeOption) => HeadlessWxGetNetworkTypeResult | undefined;
872
952
  getStorageInfo: (option?: HeadlessWxGetStorageInfoOption) => HeadlessWxStorageInfoResult | undefined;
873
953
  getStorageInfoSync: () => HeadlessWxStorageInfoResult;
@@ -877,6 +957,7 @@ interface HeadlessWx {
877
957
  getSystemInfoSync: () => HeadlessWxSystemInfoResult;
878
958
  getWindowInfo: (option?: HeadlessWxGetWindowInfoOption) => HeadlessWxWindowInfoResult | undefined;
879
959
  getWindowInfoSync: () => HeadlessWxWindowInfoResult;
960
+ loadFontFace: (option: HeadlessWxLoadFontFaceOption) => HeadlessWxLoadFontFaceResult | undefined;
880
961
  hideLoading: (option?: HeadlessWxHideLoadingOption) => {
881
962
  errMsg: string;
882
963
  } | undefined;
@@ -901,6 +982,7 @@ interface HeadlessWx {
901
982
  saveVideoToPhotosAlbum: (option: HeadlessWxSaveVideoToPhotosAlbumOption) => HeadlessWxSaveVideoToPhotosAlbumResult | undefined;
902
983
  removeStorage: (option: HeadlessWxRemoveStorageOption) => HeadlessWxStorageResult | undefined;
903
984
  removeStorageSync: (key: string) => void;
985
+ rpx2px: (value: number) => number;
904
986
  request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
905
987
  saveFile: (option: HeadlessWxSaveFileOption) => HeadlessWxSaveFileSuccessResult | undefined;
906
988
  setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
@@ -967,9 +1049,73 @@ interface HeadlessWx {
967
1049
  updateShareMenu: (option?: HeadlessWxShareMenuOption) => {
968
1050
  errMsg: string;
969
1051
  } | undefined;
1052
+ upx2px: (value: number) => number;
970
1053
  }
1054
+ //#endregion
1055
+ //#region src/host/wx/index.d.ts
971
1056
  declare function createHeadlessWx(driver: HeadlessWxDriver): HeadlessWx;
972
1057
  //#endregion
1058
+ //#region src/kernel/artifactSource.d.ts
1059
+ interface ArtifactSource {
1060
+ has: (filePath: string) => boolean;
1061
+ readText: (filePath: string) => string | undefined;
1062
+ }
1063
+ declare function createFileSystemArtifactSource(): ArtifactSource;
1064
+ declare function createMemoryArtifactSource(entries: Iterable<[string, string]>): ArtifactSource;
1065
+ declare function createOverlayArtifactSource(overlay: ArtifactSource, fallback: ArtifactSource): ArtifactSource;
1066
+ //#endregion
1067
+ //#region src/kernel/diagnostics.d.ts
1068
+ type RuntimeDiagnosticLevel = 'error' | 'exception' | 'warn';
1069
+ interface RuntimeDiagnosticEntry {
1070
+ args: unknown[];
1071
+ level: RuntimeDiagnosticLevel;
1072
+ timestamp: number;
1073
+ }
1074
+ declare class RuntimeDiagnostics {
1075
+ private readonly entries;
1076
+ clear(): void;
1077
+ getEntries(): {
1078
+ args: unknown[];
1079
+ level: RuntimeDiagnosticLevel;
1080
+ timestamp: number;
1081
+ }[];
1082
+ record(level: RuntimeDiagnosticLevel, args: unknown[]): void;
1083
+ createConsole(baseConsole?: Console): Console;
1084
+ }
1085
+ //#endregion
1086
+ //#region src/kernel/platform.d.ts
1087
+ interface PlatformAdapter {
1088
+ readonly name: string;
1089
+ }
1090
+ declare function wechat(): PlatformAdapter;
1091
+ //#endregion
1092
+ //#region src/kernel/scheduler.d.ts
1093
+ type TimeoutHandle = ReturnType<typeof setTimeout>;
1094
+ type IntervalHandle = ReturnType<typeof setInterval>;
1095
+ declare class RuntimeScheduler {
1096
+ private readonly intervals;
1097
+ private readonly timeouts;
1098
+ private closed;
1099
+ private readonly onError;
1100
+ constructor(onError: (error: unknown) => void);
1101
+ clearInterval(handle: IntervalHandle): void;
1102
+ clearTimeout(handle: TimeoutHandle): void;
1103
+ close(): void;
1104
+ queueMicrotask(handler: () => void): void;
1105
+ setInterval(handler: (...args: any[]) => void, timeout?: number, ...args: any[]): NodeJS.Timeout;
1106
+ setTimeout(handler: (...args: any[]) => void, timeout?: number, ...args: any[]): NodeJS.Timeout;
1107
+ }
1108
+ //#endregion
1109
+ //#region src/kernel/runtimeKernel.d.ts
1110
+ declare class RuntimeKernel {
1111
+ readonly diagnostics: RuntimeDiagnostics;
1112
+ readonly scheduler: RuntimeScheduler;
1113
+ private closed;
1114
+ assertActive(): void;
1115
+ close(): void;
1116
+ get isClosed(): boolean;
1117
+ }
1118
+ //#endregion
973
1119
  //#region src/browser/virtualFiles.d.ts
974
1120
  interface BrowserDirectoryFileLike {
975
1121
  name: string;
@@ -985,11 +1131,16 @@ declare function hasBrowserVirtualFile(files: BrowserVirtualFiles, filePath: str
985
1131
  //#endregion
986
1132
  //#region src/browser/moduleLoader.d.ts
987
1133
  interface BrowserModuleLoader {
1134
+ close: () => void;
988
1135
  executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
989
1136
  executeAppModule: (filePath: string) => HeadlessAppDefinition;
990
1137
  executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
1138
+ wx: HeadlessWx;
991
1139
  }
992
- declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0]): BrowserModuleLoader;
1140
+ declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0], options: {
1141
+ globals?: Record<string, unknown>;
1142
+ kernel: RuntimeKernel;
1143
+ }): BrowserModuleLoader;
993
1144
  //#endregion
994
1145
  //#region src/project/resolveRoutes.d.ts
995
1146
  interface HeadlessRouteRecord {
@@ -1006,6 +1157,7 @@ interface HeadlessProjectConfigFile {
1006
1157
  value: Record<string, any>;
1007
1158
  }
1008
1159
  interface HeadlessProjectDescriptor {
1160
+ artifactSource: ArtifactSource;
1009
1161
  appConfig: Record<string, any>;
1010
1162
  appConfigPath: string;
1011
1163
  miniprogramRoot: string;
@@ -1015,6 +1167,7 @@ interface HeadlessProjectDescriptor {
1015
1167
  routes: HeadlessRouteRecord[];
1016
1168
  }
1017
1169
  interface CreateProjectDescriptorOptions {
1170
+ artifactSource?: ArtifactSource;
1018
1171
  appConfig: Record<string, any>;
1019
1172
  appConfigPath: string;
1020
1173
  miniprogramRoot: string;
@@ -1033,35 +1186,6 @@ interface CreateBrowserProjectOptions {
1033
1186
  }
1034
1187
  declare function createBrowserProject(files: BrowserVirtualFiles, options?: CreateBrowserProjectOptions): HeadlessProjectDescriptor;
1035
1188
  //#endregion
1036
- //#region src/runtime/componentInstance.d.ts
1037
- interface HeadlessComponentInstance extends Record<string, any> {
1038
- __definition__?: HeadlessComponentDefinition;
1039
- __lastInteractionEvent__?: Record<string, any>;
1040
- __propertySnapshots__?: Record<string, any>;
1041
- __ready__?: boolean;
1042
- createIntersectionObserver?: (options?: Record<string, any>) => any;
1043
- createMediaQueryObserver?: () => HeadlessWxMediaQueryObserver;
1044
- data: Record<string, any>;
1045
- properties: Record<string, any>;
1046
- selectAllComponents?: (selector: string) => any[];
1047
- selectComponent?: (selector: string) => any;
1048
- selectOwnerComponent?: () => any;
1049
- setData: (patch: Record<string, any>, callback?: () => void) => void;
1050
- triggerEvent: (eventName: string, detail?: unknown, options?: Record<string, any>) => void;
1051
- }
1052
- declare function cloneValue<T>(value: T): T;
1053
- declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
1054
- interface CreateComponentInstanceOptions {
1055
- definition: HeadlessComponentDefinition;
1056
- properties?: Record<string, any>;
1057
- triggerEvent?: (instance: HeadlessComponentInstance, eventName: string, detail?: unknown, options?: Record<string, any>) => void;
1058
- }
1059
- declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
1060
- declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): unknown;
1061
- declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
1062
- declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
1063
- declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
1064
- //#endregion
1065
1189
  //#region src/project/pageConfig.d.ts
1066
1190
  interface HeadlessNavigationBarSnapshot {
1067
1191
  animation: {
@@ -1105,7 +1229,46 @@ declare function createPageInstance(route: string, definition: HeadlessPageDefin
1105
1229
  navigationBar?: HeadlessNavigationBarSnapshot;
1106
1230
  }): HeadlessPageInstance;
1107
1231
  //#endregion
1108
- //#region src/browser/render.d.ts
1232
+ //#region src/runtime/componentInstance/types.d.ts
1233
+ interface HeadlessComponentInstance extends Record<string, any> {
1234
+ __definition__?: HeadlessComponentDefinition;
1235
+ __lastInteractionEvent__?: Record<string, any>;
1236
+ __propertySnapshots__?: Record<string, any>;
1237
+ __ready__?: boolean;
1238
+ createIntersectionObserver?: (options?: Record<string, any>) => any;
1239
+ createMediaQueryObserver?: () => HeadlessWxMediaQueryObserver;
1240
+ data: Record<string, any>;
1241
+ properties: Record<string, any>;
1242
+ selectAllComponents?: (selector: string) => any[];
1243
+ selectComponent?: (selector: string) => any;
1244
+ selectOwnerComponent?: () => any;
1245
+ setData: (patch: Record<string, any>, callback?: () => void) => void;
1246
+ triggerEvent: (eventName: string, detail?: unknown, options?: Record<string, any>) => void;
1247
+ }
1248
+ interface CreateComponentInstanceOptions {
1249
+ definition: HeadlessComponentDefinition;
1250
+ properties?: Record<string, any>;
1251
+ requestRender?: (callback?: () => void) => void;
1252
+ triggerEvent?: (instance: HeadlessComponentInstance, eventName: string, detail?: unknown, options?: Record<string, any>) => void;
1253
+ }
1254
+ //#endregion
1255
+ //#region src/runtime/componentInstance/observers.d.ts
1256
+ declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
1257
+ //#endregion
1258
+ //#region src/runtime/componentInstance/properties.d.ts
1259
+ declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
1260
+ declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): any;
1261
+ //#endregion
1262
+ //#region src/runtime/componentInstance/shared.d.ts
1263
+ declare function cloneValue<T>(value: T): T;
1264
+ declare function hasComponentPropertyValueChanged(currentValue: unknown, previousSnapshot: unknown, nextValue: unknown, bindingAffected: boolean): boolean;
1265
+ //#endregion
1266
+ //#region src/runtime/componentInstance/index.d.ts
1267
+ declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
1268
+ declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
1269
+ declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
1270
+ //#endregion
1271
+ //#region src/browser/render/types.d.ts
1109
1272
  interface DomNodeLike$5 {
1110
1273
  attribs?: Record<string, string>;
1111
1274
  children?: DomNodeLike$5[];
@@ -1125,10 +1288,19 @@ interface BrowserRenderScope {
1125
1288
  }>;
1126
1289
  getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
1127
1290
  getScopeId: () => string;
1291
+ genericComponents?: Map<string, string>;
1128
1292
  hostId?: string;
1129
1293
  listenerScopeId?: string;
1130
1294
  id?: string;
1131
1295
  ownerScopeId?: string;
1296
+ slots?: Map<string, BrowserSlotContent[]>;
1297
+ }
1298
+ interface BrowserSlotContent {
1299
+ instancePath: string;
1300
+ node: DomNodeLike$5;
1301
+ ownerFilePath: string;
1302
+ ownerJsonPath: string;
1303
+ scope: BrowserRenderScope;
1132
1304
  }
1133
1305
  interface BrowserRenderedPageTree {
1134
1306
  root: DomNodeLike$5;
@@ -1144,11 +1316,14 @@ interface BrowserRendererContext {
1144
1316
  session: {
1145
1317
  createIntersectionObserver: (scope: any, options?: Record<string, any>) => any;
1146
1318
  createMediaQueryObserver: (scope: any) => any;
1319
+ requestRender: (callback?: () => void) => void;
1147
1320
  selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
1148
1321
  selectComponentWithin: (scopeId: string, selector: string) => any;
1149
1322
  selectOwnerComponent: (scopeId: string) => any;
1150
1323
  };
1151
1324
  }
1325
+ //#endregion
1326
+ //#region src/browser/render/index.d.ts
1152
1327
  declare function renderBrowserPageTree(context: BrowserRendererContext, page: HeadlessPageInstance): BrowserRenderedPageTree;
1153
1328
  //#endregion
1154
1329
  //#region src/runtime/appInstance.d.ts
@@ -1157,17 +1332,28 @@ interface HeadlessAppInstance extends Record<string, any> {
1157
1332
  }
1158
1333
  declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
1159
1334
  //#endregion
1335
+ //#region src/project/createArtifactProject.d.ts
1336
+ interface CreateArtifactProjectOptions {
1337
+ appConfigPath?: string;
1338
+ artifactSource?: ArtifactSource;
1339
+ miniprogramRootPath: string;
1340
+ projectPath?: string;
1341
+ }
1342
+ declare function createArtifactProject(options: CreateArtifactProjectOptions): HeadlessProjectDescriptor;
1343
+ //#endregion
1160
1344
  //#region src/project/loadProject.d.ts
1161
1345
  declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
1162
1346
  //#endregion
1163
1347
  //#region src/runtime/moduleLoader.d.ts
1164
1348
  interface HeadlessModuleLoader {
1349
+ close: () => void;
1165
1350
  executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
1166
1351
  executeAppModule: (filePath: string) => HeadlessAppDefinition;
1167
1352
  executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
1353
+ wx: HeadlessWx;
1168
1354
  }
1169
1355
  //#endregion
1170
- //#region src/runtime/render.d.ts
1356
+ //#region src/runtime/render/types.d.ts
1171
1357
  interface DomNodeLike$4 {
1172
1358
  attribs?: Record<string, string>;
1173
1359
  children?: DomNodeLike$4[];
@@ -1187,16 +1373,26 @@ interface RuntimeRenderScope {
1187
1373
  }>;
1188
1374
  getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
1189
1375
  getScopeId: () => string;
1376
+ genericComponents?: Map<string, string>;
1190
1377
  hostId?: string;
1191
1378
  listenerScopeId?: string;
1192
1379
  id?: string;
1193
1380
  ownerScopeId?: string;
1381
+ slots?: Map<string, RuntimeSlotContent[]>;
1382
+ }
1383
+ interface RuntimeSlotContent {
1384
+ instancePath: string;
1385
+ node: DomNodeLike$4;
1386
+ ownerFilePath: string;
1387
+ ownerJsonPath: string;
1388
+ scope: RuntimeRenderScope;
1194
1389
  }
1195
1390
  interface RuntimeRenderedPageTree {
1196
1391
  root: DomNodeLike$4;
1197
1392
  wxml: string;
1198
1393
  }
1199
1394
  interface RuntimeRendererContext {
1395
+ artifactSource: ArtifactSource;
1200
1396
  changedPageKeys: string[];
1201
1397
  componentCache: Map<string, HeadlessComponentInstance>;
1202
1398
  componentScopes: Map<string, RuntimeRenderScope>;
@@ -1205,11 +1401,14 @@ interface RuntimeRendererContext {
1205
1401
  session: {
1206
1402
  createIntersectionObserver: (scope: any, options?: Record<string, any>) => any;
1207
1403
  createMediaQueryObserver: (scope: any) => any;
1404
+ requestRender: (callback?: () => void) => void;
1208
1405
  selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
1209
1406
  selectComponentWithin: (scopeId: string, selector: string) => any;
1210
1407
  selectOwnerComponent: (scopeId: string) => any;
1211
1408
  };
1212
1409
  }
1410
+ //#endregion
1411
+ //#region src/runtime/render/index.d.ts
1213
1412
  declare function renderRuntimePageTree(context: RuntimeRendererContext, page: HeadlessPageInstance): RuntimeRenderedPageTree;
1214
1413
  //#endregion
1215
1414
  //#region src/runtime/wxState.d.ts
@@ -1317,7 +1516,11 @@ interface HeadlessWxUploadFileLogEntry {
1317
1516
  response?: HeadlessWxUploadFileSuccessResult;
1318
1517
  url: string;
1319
1518
  }
1320
- declare function createHeadlessWxState(): {
1519
+ interface HeadlessWxStateOptions {
1520
+ strictMocks?: boolean;
1521
+ }
1522
+ declare function createHeadlessWxState(scheduler?: Pick<RuntimeScheduler, 'clearTimeout' | 'setTimeout'>, options?: HeadlessWxStateOptions): {
1523
+ close(): void;
1321
1524
  clearStorageSync(): void;
1322
1525
  downloadFile(option: HeadlessWxDownloadFileOption): HeadlessWxRequestTask;
1323
1526
  getActionSheetLogs(): {
@@ -1590,10 +1793,14 @@ declare function createHeadlessWxState(): {
1590
1793
  //#endregion
1591
1794
  //#region src/runtime/session.d.ts
1592
1795
  interface HeadlessSessionOptions {
1593
- projectPath: string;
1796
+ globals?: Record<string, unknown>;
1797
+ project?: HeadlessProjectDescriptor;
1798
+ projectPath?: string;
1799
+ strictHostMocks?: boolean;
1594
1800
  }
1595
1801
  declare class HeadlessSession {
1596
1802
  readonly project: HeadlessProjectDescriptor;
1803
+ private readonly kernel;
1597
1804
  private appDefinition;
1598
1805
  private appInstance;
1599
1806
  private readonly moduleLoader;
@@ -1602,6 +1809,9 @@ declare class HeadlessSession {
1602
1809
  private readonly pages;
1603
1810
  private readonly componentCache;
1604
1811
  private readonly componentScopes;
1812
+ private readonly selectorQueryScopeSnapshots;
1813
+ private renderRequestPending;
1814
+ private readonly renderRequestCallbacks;
1605
1815
  private readonly tabBarRoutes;
1606
1816
  private readonly tabPages;
1607
1817
  private readonly tabBarItems;
@@ -1615,8 +1825,13 @@ declare class HeadlessSession {
1615
1825
  private readonly wxState;
1616
1826
  private pullDownRefreshState;
1617
1827
  constructor(options: HeadlessSessionOptions);
1828
+ assertActive(): void;
1829
+ close(): void;
1830
+ getDiagnostics(): RuntimeDiagnosticEntry[];
1831
+ get isClosed(): boolean;
1618
1832
  getApp(): HeadlessAppInstance | null;
1619
1833
  getCurrentPages(): HeadlessPageInstance[];
1834
+ callWxMethod(methodName: string, ...args: any[]): any;
1620
1835
  getCurrentPageNavigationBarTitle(): string | null;
1621
1836
  getCurrentPageNavigationBar(): {
1622
1837
  animation: {
@@ -1696,6 +1911,7 @@ declare class HeadlessSession {
1696
1911
  getFileText(filePath: string): string | null;
1697
1912
  getSavedFileListSnapshot(): HeadlessWxSavedFileInfo[];
1698
1913
  renderCurrentPage(): RuntimeRenderedPageTree;
1914
+ requestRender(callback?: () => void): void;
1699
1915
  getScopeSnapshot(scopeId: string): {
1700
1916
  data: Record<string, any>;
1701
1917
  methods: string[];
@@ -1769,6 +1985,8 @@ declare class HeadlessSession {
1769
1985
  model: string;
1770
1986
  pixelRatio: number;
1771
1987
  platform: string;
1988
+ safeArea: HeadlessWxSafeArea;
1989
+ safeAreaInsets: HeadlessWxSafeAreaInsets;
1772
1990
  screenHeight: number;
1773
1991
  screenWidth: number;
1774
1992
  system: string;
@@ -1778,6 +1996,7 @@ declare class HeadlessSession {
1778
1996
  };
1779
1997
  getWindowInfo(): HeadlessWxWindowInfoResult;
1780
1998
  getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
1999
+ getDeviceInfo(): HeadlessWxDeviceInfoResult;
1781
2000
  getLaunchOptions(): {
1782
2001
  query: {
1783
2002
  [x: string]: string;
@@ -1805,6 +2024,7 @@ declare class HeadlessSession {
1805
2024
  scene: number;
1806
2025
  };
1807
2026
  getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
2027
+ getLocation(): HeadlessWxGetLocationResult;
1808
2028
  getNetworkType(): HeadlessWxGetNetworkTypeResult;
1809
2029
  getLoading(): {
1810
2030
  mask: boolean;
@@ -1911,8 +2131,8 @@ declare class HeadlessSession {
1911
2131
  stopPullDownRefresh(): void;
1912
2132
  private executeSelectorQuery;
1913
2133
  private createFreshPage;
2134
+ private runInitialPageLifecycles;
1914
2135
  private isTabBarRoute;
1915
- private resolveTabBarItem;
1916
2136
  private requireTabBarItem;
1917
2137
  private removePageInstance;
1918
2138
  private resolveNavigationTarget;
@@ -1938,7 +2158,10 @@ declare function createHeadlessSession(options: HeadlessSessionOptions): Headles
1938
2158
  //#region src/browser/session.d.ts
1939
2159
  interface BrowserHeadlessSessionOptions {
1940
2160
  files: BrowserVirtualFiles;
2161
+ globals?: Record<string, unknown>;
2162
+ onRender?: () => void;
1941
2163
  project?: HeadlessProjectDescriptor;
2164
+ strictHostMocks?: boolean;
1942
2165
  }
1943
2166
  declare class BrowserHeadlessSession {
1944
2167
  readonly files: BrowserVirtualFiles;
@@ -1946,11 +2169,15 @@ declare class BrowserHeadlessSession {
1946
2169
  private appDefinition;
1947
2170
  private appInstance;
1948
2171
  private readonly moduleLoader;
2172
+ private readonly onRender?;
1949
2173
  private readonly registries;
1950
2174
  private currentPageInstance;
1951
2175
  private readonly pages;
1952
2176
  private readonly componentCache;
1953
2177
  private readonly componentScopes;
2178
+ private readonly selectorQueryScopeSnapshots;
2179
+ private renderRequestPending;
2180
+ private readonly renderRequestCallbacks;
1954
2181
  private readonly tabBarRoutes;
1955
2182
  private readonly tabPages;
1956
2183
  private readonly tabBarItems;
@@ -1961,9 +2188,14 @@ declare class BrowserHeadlessSession {
1961
2188
  private readonly canvasContexts;
1962
2189
  private enterOptions;
1963
2190
  private launchOptions;
2191
+ private readonly kernel;
1964
2192
  private readonly wxState;
1965
2193
  private pullDownRefreshState;
1966
2194
  constructor(options: BrowserHeadlessSessionOptions);
2195
+ assertActive(): void;
2196
+ close(): void;
2197
+ getDiagnostics(): RuntimeDiagnosticEntry[];
2198
+ get isClosed(): boolean;
1967
2199
  getApp(): HeadlessAppInstance | null;
1968
2200
  getCurrentPages(): HeadlessPageInstance[];
1969
2201
  getCurrentPageNavigationBarTitle(): string | null;
@@ -2090,6 +2322,8 @@ declare class BrowserHeadlessSession {
2090
2322
  model: string;
2091
2323
  pixelRatio: number;
2092
2324
  platform: string;
2325
+ safeArea: HeadlessWxSafeArea;
2326
+ safeAreaInsets: HeadlessWxSafeAreaInsets;
2093
2327
  screenHeight: number;
2094
2328
  screenWidth: number;
2095
2329
  system: string;
@@ -2099,6 +2333,7 @@ declare class BrowserHeadlessSession {
2099
2333
  };
2100
2334
  getWindowInfo(): HeadlessWxWindowInfoResult;
2101
2335
  getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
2336
+ getDeviceInfo(): HeadlessWxDeviceInfoResult;
2102
2337
  getLaunchOptions(): {
2103
2338
  query: {
2104
2339
  [x: string]: string;
@@ -2126,6 +2361,7 @@ declare class BrowserHeadlessSession {
2126
2361
  scene: number;
2127
2362
  };
2128
2363
  getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
2364
+ getLocation(): HeadlessWxGetLocationResult;
2129
2365
  getNetworkType(): HeadlessWxGetNetworkTypeResult;
2130
2366
  getLoading(): {
2131
2367
  mask: boolean;
@@ -2235,6 +2471,7 @@ declare class BrowserHeadlessSession {
2235
2471
  selectOwnerComponent(scopeId: string): any;
2236
2472
  private selectComponentsWithin;
2237
2473
  renderCurrentPage(): BrowserRenderedPageTree;
2474
+ requestRender(callback?: () => void): void;
2238
2475
  callScopeMethod(scopeId: string | null, methodName: string, event: Record<string, any>): any;
2239
2476
  callScopeMethodDirect(scopeId: string, methodName: string, ...args: any[]): any;
2240
2477
  callTapBinding(scopeId: string, methodName: string): any;
@@ -2272,10 +2509,10 @@ declare class BrowserHeadlessSession {
2272
2509
  stopPullDownRefresh(): void;
2273
2510
  private executeSelectorQuery;
2274
2511
  private createFreshPage;
2512
+ private runInitialPageLifecycles;
2275
2513
  private isTabBarRoute;
2276
2514
  private removePageInstance;
2277
2515
  private resolveNavigationTarget;
2278
- private resolveTabBarItem;
2279
2516
  private requireTabBarItem;
2280
2517
  private unloadAllPages;
2281
2518
  private unloadPage;
@@ -2295,6 +2532,38 @@ declare class BrowserHeadlessSession {
2295
2532
  }
2296
2533
  declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
2297
2534
  //#endregion
2535
+ //#region src/testing/pageWait.d.ts
2536
+ interface HeadlessTestingWaitOptions {
2537
+ interval?: number;
2538
+ timeout?: number;
2539
+ }
2540
+ type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
2541
+ interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
2542
+ state?: 'attached' | 'detached';
2543
+ }
2544
+ interface HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle> {
2545
+ data: (path?: string) => Promise<unknown>;
2546
+ findOne: (selector: string) => Promise<NodeHandle | null>;
2547
+ selectComponent: (selector: string) => Promise<ScopeHandle | null>;
2548
+ selectComponents: (selector: string) => Promise<ScopeHandle[]>;
2549
+ waitFor: (ms?: number) => Promise<void>;
2550
+ wxml: () => Promise<string>;
2551
+ }
2552
+ declare function waitForPageSelector<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<NonNullable<Awaited<NodeHandle>> | null>;
2553
+ declare function waitForPageComponent<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitOptions): Promise<NonNullable<Awaited<ScopeHandle>>>;
2554
+ declare function waitForPageComponents<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<ScopeHandle[]>;
2555
+ declare function waitForPageText<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
2556
+ declare function waitForPageTextGone<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
2557
+ declare function waitForPageData<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, path: string, matcher: HeadlessTestingDataMatcher, hasMatcher: boolean, options?: HeadlessTestingWaitOptions): Promise<{}>;
2558
+ //#endregion
2559
+ //#region src/view/eventBinding.d.ts
2560
+ interface MiniProgramEventBinding {
2561
+ method: string;
2562
+ stopAfter: boolean;
2563
+ }
2564
+ declare function collectMiniProgramEventBindings(attributes?: Record<string, string>): Map<string, MiniProgramEventBinding>;
2565
+ declare function resolveMiniProgramEventBinding(attributes: Record<string, string> | undefined, eventName: string): MiniProgramEventBinding | null;
2566
+ //#endregion
2298
2567
  //#region src/view/nodeHandle.d.ts
2299
2568
  interface DomNodeLike$3 {
2300
2569
  attribs?: Record<string, string>;
@@ -2325,6 +2594,7 @@ interface HeadlessTestingNodeValueEventInit extends HeadlessTestingNodeEventInit
2325
2594
  };
2326
2595
  }
2327
2596
  interface HeadlessTestingNodeInteractionHandlers {
2597
+ assertActive?: () => void;
2328
2598
  callMethod: (scopeId: string | null, methodName: string, event: Record<string, any>) => unknown;
2329
2599
  createScopeHandle: (scopeId: string | null) => {
2330
2600
  scopeId: string;
@@ -2339,6 +2609,7 @@ declare class HeadlessTestingNodeHandle {
2339
2609
  private readonly node;
2340
2610
  private readonly interactions?;
2341
2611
  constructor(node: DomNodeLike$3, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
2612
+ private assertActive;
2342
2613
  $(selector: string): Promise<HeadlessTestingNodeHandle | null>;
2343
2614
  $$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
2344
2615
  attr(name: string): Promise<string | undefined>;
@@ -2363,6 +2634,7 @@ declare class HeadlessTestingNodeHandle {
2363
2634
  snapshot: () => Promise<unknown>;
2364
2635
  } | null>;
2365
2636
  text(): Promise<string>;
2637
+ tagName(): Promise<string | undefined>;
2366
2638
  trigger(eventName: string, event?: HeadlessTestingNodeEventInit): Promise<unknown>;
2367
2639
  tap(event?: HeadlessTestingNodeEventInit): Promise<unknown>;
2368
2640
  input(value: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
@@ -2416,40 +2688,100 @@ interface DomNodeLike {
2416
2688
  }
2417
2689
  declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
2418
2690
  //#endregion
2691
+ //#region src/testing/rendered.d.ts
2692
+ interface HeadlessTestingPageQueryOptions extends HeadlessTestingWaitOptions {
2693
+ componentSelectors?: string[];
2694
+ fallback?: boolean;
2695
+ routeOnly?: boolean;
2696
+ }
2697
+ interface HeadlessTestingRenderedOptions extends HeadlessTestingWaitOptions {
2698
+ componentSelectors?: string[];
2699
+ dataset?: Record<string, boolean | number | string>;
2700
+ predicate?: (wxml: string) => boolean;
2701
+ selector?: string;
2702
+ text?: string;
2703
+ }
2704
+ interface HeadlessTestingRenderedNodeSnapshot {
2705
+ bottom?: number;
2706
+ dataset?: Record<string, unknown>;
2707
+ height?: number;
2708
+ id?: string;
2709
+ left?: number;
2710
+ right?: number;
2711
+ top?: number;
2712
+ width?: number;
2713
+ }
2714
+ type HeadlessTestingRenderedSelectorNodesSnapshot = Record<string, HeadlessTestingRenderedNodeSnapshot[]>;
2715
+ interface HeadlessTestingRenderedPageAccess {
2716
+ assertActive: () => void;
2717
+ findAll: (selector: string) => Promise<HeadlessTestingNodeHandle[]>;
2718
+ waitFor: (ms?: number) => Promise<void>;
2719
+ wxml: () => Promise<string>;
2720
+ }
2721
+ declare function readRenderedNodes(access: HeadlessTestingRenderedPageAccess, selector: string, _options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedNodeSnapshot[]>;
2722
+ declare function readRenderedSelectorNodes(access: HeadlessTestingRenderedPageAccess, selectors: string[], options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedSelectorNodesSnapshot>;
2723
+ declare function waitForRenderedPage(access: HeadlessTestingRenderedPageAccess, options?: HeadlessTestingRenderedOptions): Promise<string>;
2724
+ //#endregion
2725
+ //#region src/testing/logicalSnapshot.d.ts
2726
+ interface HeadlessTestingLogicalNode {
2727
+ attrs: Record<string, string>;
2728
+ children: HeadlessTestingLogicalNode[];
2729
+ nodeId?: string;
2730
+ tag?: string;
2731
+ text: string;
2732
+ type: 'element' | 'text';
2733
+ }
2734
+ interface HeadlessTestingPageSnapshot {
2735
+ data: Record<string, any>;
2736
+ path: string;
2737
+ query: Record<string, string>;
2738
+ root: HeadlessTestingLogicalNode;
2739
+ wxml: string;
2740
+ }
2741
+ declare function createLogicalNode(node: any): HeadlessTestingLogicalNode;
2742
+ //#endregion
2419
2743
  //#region src/testing/pageHandle.d.ts
2420
- interface HeadlessTestingWaitOptions {
2421
- interval?: number;
2744
+ interface HeadlessTestingPageCallMethodOptions {
2745
+ fallback?: boolean;
2746
+ routeOnly?: boolean;
2422
2747
  timeout?: number;
2423
2748
  }
2424
- type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
2425
- interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
2426
- state?: 'attached' | 'detached';
2427
- }
2428
2749
  declare class HeadlessTestingPageHandle {
2429
2750
  private readonly project;
2430
2751
  private readonly page;
2431
2752
  private readonly session?;
2432
2753
  constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance, session?: HeadlessSession | undefined);
2754
+ get path(): string;
2755
+ get query(): {
2756
+ [x: string]: string;
2757
+ };
2433
2758
  private resolveDataByPath;
2434
- private pollUntil;
2759
+ assertActive(): void;
2435
2760
  private createScopeHandle;
2436
2761
  callMethod(methodName: string, ...args: any[]): Promise<any>;
2762
+ callMethodWithOptions(methodName: string, options?: HeadlessTestingPageCallMethodOptions, ...args: any[]): Promise<any>;
2437
2763
  data(path?: string): Promise<any>;
2438
2764
  selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
2439
2765
  selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
2440
2766
  waitFor(ms?: number): Promise<void>;
2441
2767
  $(selector: string): Promise<HeadlessTestingNodeHandle | null>;
2442
2768
  $$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
2769
+ renderedNodes(selector: string, options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedNodeSnapshot[]>;
2770
+ renderedSelectorNodes(selectors: string[], options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedSelectorNodesSnapshot>;
2771
+ waitForRendered(options?: HeadlessTestingRenderedOptions): Promise<string>;
2443
2772
  waitForSelector(selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<HeadlessTestingNodeHandle | null>;
2444
2773
  waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
2445
2774
  waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
2446
2775
  waitForText(text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
2447
2776
  waitForTextGone(text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
2448
- waitForData(path: string, matcher?: HeadlessTestingDataMatcher, options?: HeadlessTestingWaitOptions): Promise<any>;
2777
+ waitForData(path: string, matcher?: HeadlessTestingDataMatcher, options?: HeadlessTestingWaitOptions): Promise<{}>;
2449
2778
  wxml(): Promise<string>;
2779
+ snapshot(): Promise<HeadlessTestingPageSnapshot>;
2780
+ private renderedAccess;
2781
+ private waitAccess;
2450
2782
  }
2451
2783
  //#endregion
2452
- //#region src/testing/sessionHandle.d.ts
2784
+ //#region src/testing/sessionHandle/scope.d.ts
2453
2785
  declare class HeadlessTestingScopeHandle {
2454
2786
  readonly scopeId: string;
2455
2787
  private readonly project;
@@ -2494,15 +2826,20 @@ declare class HeadlessTestingScopeHandle {
2494
2826
  timeout?: number;
2495
2827
  }): Promise<HeadlessTestingScopeHandle[]>;
2496
2828
  }
2829
+ //#endregion
2830
+ //#region src/testing/sessionHandle/index.d.ts
2831
+ interface HeadlessTestingProtocolOptions {
2832
+ timeout?: number;
2833
+ }
2497
2834
  declare class HeadlessTestingSessionHandle {
2498
2835
  private readonly project;
2499
2836
  private readonly session;
2500
2837
  constructor(project: HeadlessProjectDescriptor, session: HeadlessSession);
2501
- private waitFor;
2502
- private pollUntil;
2503
2838
  close(): Promise<void>;
2504
2839
  currentPage(): Promise<HeadlessTestingPageHandle | null>;
2505
2840
  getCurrentPages(): Promise<HeadlessTestingPageHandle[]>;
2841
+ callWxMethod<T = unknown>(methodName: string, ...args: any[]): Promise<T>;
2842
+ callWxMethodWithOptions<T = unknown>(methodName: string, options?: HeadlessTestingProtocolOptions, ...args: any[]): Promise<T>;
2506
2843
  scopeSnapshot(scopeId: string): Promise<{
2507
2844
  data: Record<string, any>;
2508
2845
  methods: string[];
@@ -2527,12 +2864,17 @@ declare class HeadlessTestingSessionHandle {
2527
2864
  waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
2528
2865
  waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
2529
2866
  reLaunch(route: string): Promise<HeadlessTestingPageHandle>;
2867
+ navigateTo(route: string): Promise<HeadlessTestingPageHandle>;
2868
+ redirectTo(route: string): Promise<HeadlessTestingPageHandle>;
2869
+ navigateBack(delta?: number): Promise<HeadlessTestingPageHandle | null>;
2870
+ switchTab(route: string): Promise<HeadlessTestingPageHandle>;
2530
2871
  waitForCurrentPage(route?: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingPageHandle>;
2531
2872
  pageScrollTo(scrollTop: number): Promise<void>;
2532
2873
  triggerPullDownRefresh(): Promise<void>;
2533
2874
  triggerReachBottom(): Promise<void>;
2534
2875
  triggerResize(options: Record<string, any>): Promise<void>;
2535
2876
  triggerRouteDone(options?: Record<string, any>): Promise<void>;
2877
+ private requireCurrentPage;
2536
2878
  }
2537
2879
  //#endregion
2538
2880
  //#region src/testing/launch.d.ts
@@ -2541,4 +2883,4 @@ interface HeadlessTestingLaunchOptions {
2541
2883
  }
2542
2884
  declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
2543
2885
  //#endregion
2544
- 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, HeadlessWxAnimation, HeadlessWxAnimationAction, HeadlessWxAnimationExportResult, HeadlessWxAnimationStepOption, HeadlessWxAppBaseInfoResult, HeadlessWxAppendFileOption, HeadlessWxCallbackOption, HeadlessWxCanvasContext, HeadlessWxCanvasDrawCall, HeadlessWxCanvasSnapshot, HeadlessWxCanvasToTempFilePathOption, HeadlessWxCanvasToTempFilePathSuccessResult, HeadlessWxChooseImageOption, HeadlessWxChooseImageResult, HeadlessWxChooseImageTempFile, HeadlessWxChooseMediaOption, HeadlessWxChooseMediaResult, HeadlessWxChooseMediaTempFile, HeadlessWxChooseMessageFileOption, HeadlessWxChooseMessageFileResult, HeadlessWxChooseMessageFileTempFile, HeadlessWxChooseVideoOption, HeadlessWxChooseVideoResult, HeadlessWxClearStorageOption, HeadlessWxClipboardSnapshot, HeadlessWxCompressImageOption, HeadlessWxCompressImageResult, HeadlessWxCopyFileOption, HeadlessWxCreateIntersectionObserverOption, HeadlessWxDownloadFileLogEntry, HeadlessWxDownloadFileMockDefinition, HeadlessWxDownloadFileOption, HeadlessWxDownloadFileSuccessResult, HeadlessWxDriver, HeadlessWxFileSystemManager, HeadlessWxFileSystemResult, HeadlessWxGetAppBaseInfoOption, HeadlessWxGetClipboardDataOption, HeadlessWxGetClipboardDataResult, HeadlessWxGetFileInfoOption, HeadlessWxGetFileInfoResult, HeadlessWxGetImageInfoOption, HeadlessWxGetImageInfoResult, HeadlessWxGetNetworkTypeOption, HeadlessWxGetNetworkTypeResult, HeadlessWxGetSavedFileInfoOption, HeadlessWxGetSavedFileInfoSuccessResult, HeadlessWxGetSavedFileListOption, HeadlessWxGetSavedFileListSuccessResult, HeadlessWxGetStorageInfoOption, HeadlessWxGetStorageOption, HeadlessWxGetStorageResult, HeadlessWxGetSystemInfoOption, HeadlessWxGetVideoInfoOption, HeadlessWxGetVideoInfoResult, HeadlessWxGetWindowInfoOption, HeadlessWxHideLoadingOption, HeadlessWxHideNavigationBarLoadingOption, HeadlessWxIntersectionObserver, HeadlessWxIntersectionObserverMargins, HeadlessWxIntersectionObserverObserveAllResult, HeadlessWxLaunchOptions, HeadlessWxLoadingSnapshot, HeadlessWxMediaQueryObserver, HeadlessWxMediaQueryObserverObserveCallbackResult, HeadlessWxMenuButtonBoundingClientRectResult, HeadlessWxMkdirOption, HeadlessWxModalLogEntry, HeadlessWxModalMockDefinition, HeadlessWxNavigateBackOption, HeadlessWxNavigateOption, HeadlessWxNetworkSnapshot, HeadlessWxNetworkStatusChangeCallback, HeadlessWxNetworkStatusChangeResult, HeadlessWxNetworkType, HeadlessWxObserveDescriptor, HeadlessWxOpenDocumentOption, HeadlessWxOpenDocumentResult, HeadlessWxOpenDocumentSnapshot, HeadlessWxPageScrollToOption, HeadlessWxPreviewImageOption, HeadlessWxPreviewImageResult, HeadlessWxPreviewImageSnapshot, HeadlessWxReadDirOption, HeadlessWxReadDirSuccessResult, HeadlessWxReadFileOption, HeadlessWxReadFileSuccessResult, HeadlessWxRemoveSavedFileOption, HeadlessWxRemoveStorageOption, HeadlessWxRenameOption, HeadlessWxRequestLogEntry, HeadlessWxRequestMockDefinition, HeadlessWxRequestOption, HeadlessWxRequestSuccessResult, HeadlessWxRequestTask, HeadlessWxRmdirOption, HeadlessWxSaveFileOption, HeadlessWxSaveFileSuccessResult, HeadlessWxSaveImageToPhotosAlbumOption, HeadlessWxSaveImageToPhotosAlbumResult, HeadlessWxSaveVideoToPhotosAlbumOption, HeadlessWxSaveVideoToPhotosAlbumResult, HeadlessWxSavedFileInfo, HeadlessWxSelectorQuery, HeadlessWxSelectorQueryBoundingClientRectResult, HeadlessWxSelectorQueryFieldsOption, HeadlessWxSelectorQueryNode, HeadlessWxSelectorQueryRequest, HeadlessWxSelectorQueryScrollOffsetResult, HeadlessWxSetBackgroundColorOption, HeadlessWxSetBackgroundTextStyleOption, HeadlessWxSetClipboardDataOption, HeadlessWxSetClipboardDataResult, HeadlessWxSetNavigationBarColorOption, HeadlessWxSetNavigationBarTitleOption, HeadlessWxSetStorageOption, HeadlessWxSetTabBarBadgeOption, HeadlessWxShareMenuOption, HeadlessWxShareMenuSnapshot, HeadlessWxShowActionSheetOption, HeadlessWxShowActionSheetResult, HeadlessWxShowLoadingOption, HeadlessWxShowModalOption, HeadlessWxShowModalResult, HeadlessWxShowNavigationBarLoadingOption, HeadlessWxShowToastOption, HeadlessWxStartPullDownRefreshOption, HeadlessWxStatOption, HeadlessWxStatSuccessResult, HeadlessWxStats, HeadlessWxStorageInfoResult, HeadlessWxStorageResult, HeadlessWxSystemInfoResult, HeadlessWxTabBarItemOption, HeadlessWxTabBarOption, HeadlessWxToastSnapshot, HeadlessWxUnlinkOption, HeadlessWxUploadFileLogEntry, HeadlessWxUploadFileMockDefinition, HeadlessWxUploadFileOption, HeadlessWxUploadFileSuccessResult, HeadlessWxVideoContext, 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, resolveSelectorScrollTop, runComponentLifecycle, runComponentObservers, runComponentPageLifetime };
2886
+ export { ArtifactSource, BrowserDirectoryFileLike, BrowserHeadlessSession, BrowserHeadlessSessionOptions, BrowserModuleLoader, type BrowserRenderedPageTree, type BrowserRendererContext, BrowserVirtualFiles, CreateArtifactProjectOptions, CreateBrowserProjectOptions, type CreateComponentInstanceOptions, CreateProjectDescriptorOptions, HeadlessAppDefinition, HeadlessAppInstance, HeadlessBehaviorDefinition, HeadlessComponentDefinition, type HeadlessComponentInstance, HeadlessHostLoadContext, HeadlessHostRegistries, HeadlessPageDefinition, HeadlessPageInstance, HeadlessProjectConfigFile, HeadlessProjectDescriptor, HeadlessRouteRecord, HeadlessSelectorQueryResolverOptions, HeadlessSession, HeadlessSessionOptions, HeadlessTestingDataMatcher, HeadlessTestingLaunchOptions, HeadlessTestingLogicalNode, HeadlessTestingNodeHandle, HeadlessTestingPageCallMethodOptions, HeadlessTestingPageHandle, HeadlessTestingPageQueryOptions, HeadlessTestingPageSnapshot, HeadlessTestingPageWaitAccess, HeadlessTestingRenderedNodeSnapshot, HeadlessTestingRenderedOptions, HeadlessTestingRenderedPageAccess, HeadlessTestingRenderedSelectorNodesSnapshot, HeadlessTestingScopeHandle, HeadlessTestingSessionHandle, HeadlessTestingWaitForSelectorOptions, HeadlessTestingWaitOptions, HeadlessUniEventBus, HeadlessUniEventHandler, HeadlessWx, HeadlessWxAccessFileOption, HeadlessWxActionSheetLogEntry, HeadlessWxActionSheetMockDefinition, HeadlessWxAnimation, HeadlessWxAnimationAction, HeadlessWxAnimationExportResult, HeadlessWxAnimationStepOption, HeadlessWxAppBaseInfoResult, HeadlessWxAppendFileOption, HeadlessWxCallbackOption, HeadlessWxCanvasContext, HeadlessWxCanvasDrawCall, HeadlessWxCanvasSnapshot, HeadlessWxCanvasToTempFilePathOption, HeadlessWxCanvasToTempFilePathSuccessResult, HeadlessWxChooseImageOption, HeadlessWxChooseImageResult, HeadlessWxChooseImageTempFile, HeadlessWxChooseMediaOption, HeadlessWxChooseMediaResult, HeadlessWxChooseMediaTempFile, HeadlessWxChooseMessageFileOption, HeadlessWxChooseMessageFileResult, HeadlessWxChooseMessageFileTempFile, HeadlessWxChooseVideoOption, HeadlessWxChooseVideoResult, HeadlessWxClearStorageOption, HeadlessWxClipboardSnapshot, HeadlessWxCompressImageOption, HeadlessWxCompressImageResult, HeadlessWxCopyFileOption, HeadlessWxCreateIntersectionObserverOption, HeadlessWxDeviceInfoResult, HeadlessWxDownloadFileLogEntry, HeadlessWxDownloadFileMockDefinition, HeadlessWxDownloadFileOption, HeadlessWxDownloadFileSuccessResult, HeadlessWxDriver, HeadlessWxDriverCapabilities, HeadlessWxFileSystemManager, HeadlessWxFileSystemResult, HeadlessWxGetAppBaseInfoOption, HeadlessWxGetClipboardDataOption, HeadlessWxGetClipboardDataResult, HeadlessWxGetFileInfoOption, HeadlessWxGetFileInfoResult, HeadlessWxGetImageInfoOption, HeadlessWxGetImageInfoResult, HeadlessWxGetLocationOption, HeadlessWxGetLocationResult, HeadlessWxGetNetworkTypeOption, HeadlessWxGetNetworkTypeResult, HeadlessWxGetSavedFileInfoOption, HeadlessWxGetSavedFileInfoSuccessResult, HeadlessWxGetSavedFileListOption, HeadlessWxGetSavedFileListSuccessResult, HeadlessWxGetStorageInfoOption, HeadlessWxGetStorageOption, HeadlessWxGetStorageResult, HeadlessWxGetSystemInfoOption, HeadlessWxGetVideoInfoOption, HeadlessWxGetVideoInfoResult, HeadlessWxGetWindowInfoOption, HeadlessWxHideLoadingOption, HeadlessWxHideNavigationBarLoadingOption, HeadlessWxIntersectionObserver, HeadlessWxIntersectionObserverMargins, HeadlessWxIntersectionObserverObserveAllResult, HeadlessWxLaunchOptions, HeadlessWxLoadFontFaceOption, HeadlessWxLoadFontFaceResult, HeadlessWxLoadingSnapshot, HeadlessWxMediaQueryObserver, HeadlessWxMediaQueryObserverObserveCallbackResult, HeadlessWxMenuButtonBoundingClientRectResult, HeadlessWxMkdirOption, HeadlessWxModalLogEntry, HeadlessWxModalMockDefinition, HeadlessWxNavigateBackOption, HeadlessWxNavigateOption, HeadlessWxNetworkSnapshot, HeadlessWxNetworkStatusChangeCallback, HeadlessWxNetworkStatusChangeResult, HeadlessWxNetworkType, HeadlessWxObserveDescriptor, HeadlessWxOpenDocumentOption, HeadlessWxOpenDocumentResult, HeadlessWxOpenDocumentSnapshot, HeadlessWxPageScrollToOption, HeadlessWxPreviewImageOption, HeadlessWxPreviewImageResult, HeadlessWxPreviewImageSnapshot, HeadlessWxReadDirOption, HeadlessWxReadDirSuccessResult, HeadlessWxReadFileOption, HeadlessWxReadFileSuccessResult, HeadlessWxRemoveSavedFileOption, HeadlessWxRemoveStorageOption, HeadlessWxRenameOption, HeadlessWxRequestLogEntry, HeadlessWxRequestMockDefinition, HeadlessWxRequestOption, HeadlessWxRequestSuccessResult, HeadlessWxRequestTask, HeadlessWxRmdirOption, HeadlessWxSafeArea, HeadlessWxSafeAreaInsets, HeadlessWxSaveFileOption, HeadlessWxSaveFileSuccessResult, HeadlessWxSaveImageToPhotosAlbumOption, HeadlessWxSaveImageToPhotosAlbumResult, HeadlessWxSaveVideoToPhotosAlbumOption, HeadlessWxSaveVideoToPhotosAlbumResult, HeadlessWxSavedFileInfo, HeadlessWxSelectorQuery, HeadlessWxSelectorQueryBoundingClientRectResult, HeadlessWxSelectorQueryFieldsOption, HeadlessWxSelectorQueryNode, HeadlessWxSelectorQueryRequest, HeadlessWxSelectorQueryScrollOffsetResult, HeadlessWxSetBackgroundColorOption, HeadlessWxSetBackgroundTextStyleOption, HeadlessWxSetClipboardDataOption, HeadlessWxSetClipboardDataResult, HeadlessWxSetNavigationBarColorOption, HeadlessWxSetNavigationBarTitleOption, HeadlessWxSetStorageOption, HeadlessWxSetTabBarBadgeOption, HeadlessWxShareMenuOption, HeadlessWxShareMenuSnapshot, HeadlessWxShowActionSheetOption, HeadlessWxShowActionSheetResult, HeadlessWxShowLoadingOption, HeadlessWxShowModalOption, HeadlessWxShowModalResult, HeadlessWxShowNavigationBarLoadingOption, HeadlessWxShowToastOption, HeadlessWxStartPullDownRefreshOption, HeadlessWxStatOption, HeadlessWxStatSuccessResult, HeadlessWxStateOptions, HeadlessWxStats, HeadlessWxStorageInfoResult, HeadlessWxStorageResult, HeadlessWxSystemInfoResult, HeadlessWxTabBarItemOption, HeadlessWxTabBarOption, HeadlessWxToastSnapshot, HeadlessWxUnlinkOption, HeadlessWxUploadFileLogEntry, HeadlessWxUploadFileMockDefinition, HeadlessWxUploadFileOption, HeadlessWxUploadFileSuccessResult, HeadlessWxVideoContext, HeadlessWxWindowInfoResult, HeadlessWxWriteFileOption, MiniProgramEventBinding, PlatformAdapter, RenderedPageTree, RuntimeDiagnosticEntry, RuntimeDiagnosticLevel, RuntimeDiagnostics, RuntimeKernel, type RuntimeRenderedPageTree, type RuntimeRendererContext, RuntimeScheduler, cloneValue, coerceComponentPropertyValue, collectMiniProgramEventBindings, createAppInstance, createArtifactProject, createBrowserHeadlessSession, createBrowserModuleLoader, createBrowserProject, createBrowserVirtualFiles, createBrowserVirtualFilesFromDirectory, createComponentInstance, createFileSystemArtifactSource, createHeadlessSession, createHeadlessUniEventBus, createHeadlessWx, createHeadlessWxState, createHostRegistries, createLogicalNode, createMemoryArtifactSource, createOverlayArtifactSource, createPageInstance, createProjectDescriptor, executeSelectorQueryRequests, hasBrowserVirtualFile, hasComponentPropertyValueChanged, launch, loadProject, normalizeBrowserFilePath, normalizeComponentPropertyValue, querySelectorAll, readBrowserVirtualFile, readRenderedNodes, readRenderedSelectorNodes, registerAppDefinition, registerComponentDefinition, registerExportedComponentDefinition, registerPageDefinition, renderBrowserPageTree, renderPageTree, renderRuntimePageTree, resolveMiniProgramEventBinding, resolveRoutesFromAppConfig, resolveSelectorQueryScopeRoot, resolveSelectorScrollTop, runComponentLifecycle, runComponentObservers, runComponentPageLifetime, waitForPageComponent, waitForPageComponents, waitForPageData, waitForPageSelector, waitForPageText, waitForPageTextGone, waitForRenderedPage, wechat };