@mpcore/simulator 0.0.1 → 0.0.2

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