@mpcore/simulator 0.0.1 → 0.0.3

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,209 @@ interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
37
37
  scrollTop?: number;
38
38
  selector?: string;
39
39
  }
40
+ interface HeadlessWxSelectorQueryBoundingClientRectResult {
41
+ bottom: number;
42
+ height: number;
43
+ left: number;
44
+ right: number;
45
+ top: number;
46
+ width: number;
47
+ }
48
+ interface HeadlessWxSelectorQueryScrollOffsetResult {
49
+ scrollLeft: number;
50
+ scrollTop: number;
51
+ }
52
+ interface HeadlessWxSelectorQueryFieldsOption {
53
+ computedStyle?: string[];
54
+ context?: boolean;
55
+ dataset?: boolean;
56
+ id?: boolean;
57
+ mark?: boolean;
58
+ node?: boolean;
59
+ properties?: string[];
60
+ rect?: boolean;
61
+ scrollOffset?: boolean;
62
+ size?: boolean;
63
+ }
64
+ interface HeadlessWxSelectorQueryRequest {
65
+ fields: HeadlessWxSelectorQueryFieldsOption;
66
+ selector?: string;
67
+ single: boolean;
68
+ target: 'selector' | 'viewport';
69
+ }
70
+ interface HeadlessWxSelectorQueryNode {
71
+ boundingClientRect: (callback?: (result: HeadlessWxSelectorQueryBoundingClientRectResult | HeadlessWxSelectorQueryBoundingClientRectResult[] | null) => void) => HeadlessWxSelectorQuery;
72
+ fields: (fields: HeadlessWxSelectorQueryFieldsOption, callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
73
+ scrollOffset: (callback?: (result: HeadlessWxSelectorQueryScrollOffsetResult | HeadlessWxSelectorQueryScrollOffsetResult[] | null) => void) => HeadlessWxSelectorQuery;
74
+ }
75
+ interface HeadlessWxSelectorQuery {
76
+ exec: (callback?: (result: unknown[]) => void) => unknown[];
77
+ in: (component: Record<string, any>) => HeadlessWxSelectorQuery;
78
+ select: (selector: string) => HeadlessWxSelectorQueryNode;
79
+ selectAll: (selector: string) => HeadlessWxSelectorQueryNode;
80
+ selectViewport: () => HeadlessWxSelectorQueryNode;
81
+ }
82
+ interface HeadlessWxStorageResult {
83
+ errMsg: string;
84
+ }
85
+ interface HeadlessWxGetStorageResult extends HeadlessWxStorageResult {
86
+ data: unknown;
87
+ }
88
+ interface HeadlessWxStorageInfoResult extends HeadlessWxStorageResult {
89
+ currentSize: number;
90
+ keys: string[];
91
+ limitSize: number;
92
+ }
93
+ type HeadlessWxNetworkType = '2g' | '3g' | '4g' | '5g' | 'none' | 'unknown' | 'wifi';
94
+ interface HeadlessWxGetNetworkTypeResult {
95
+ errMsg: string;
96
+ networkType: HeadlessWxNetworkType;
97
+ }
98
+ interface HeadlessWxNetworkStatusChangeResult {
99
+ isConnected: boolean;
100
+ networkType: HeadlessWxNetworkType;
101
+ }
102
+ type HeadlessWxNetworkStatusChangeCallback = (result: HeadlessWxNetworkStatusChangeResult) => void;
103
+ interface HeadlessWxSystemInfoResult {
104
+ SDKVersion: string;
105
+ brand: string;
106
+ language: string;
107
+ model: string;
108
+ pixelRatio: number;
109
+ platform: string;
110
+ screenHeight: number;
111
+ screenWidth: number;
112
+ system: string;
113
+ version: string;
114
+ windowHeight: number;
115
+ windowWidth: number;
116
+ }
117
+ interface HeadlessWxAppBaseInfoResult {
118
+ SDKVersion: string;
119
+ enableDebug: boolean;
120
+ host: {
121
+ env: string;
122
+ };
123
+ language: string;
124
+ platform: string;
125
+ version: string;
126
+ }
127
+ interface HeadlessWxWindowInfoResult {
128
+ pixelRatio: number;
129
+ screenHeight: number;
130
+ screenWidth: number;
131
+ statusBarHeight: number;
132
+ windowHeight: number;
133
+ windowWidth: number;
134
+ }
135
+ interface HeadlessWxLaunchOptions {
136
+ path: string;
137
+ query: Record<string, string>;
138
+ referrerInfo: {
139
+ appId: string;
140
+ extraData: Record<string, never>;
141
+ };
142
+ scene: number;
143
+ }
144
+ interface HeadlessWxMenuButtonBoundingClientRectResult {
145
+ bottom: number;
146
+ height: number;
147
+ left: number;
148
+ right: number;
149
+ top: number;
150
+ width: number;
151
+ }
152
+ interface HeadlessWxSetStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
153
+ data: unknown;
154
+ key: string;
155
+ }
156
+ interface HeadlessWxGetStorageOption extends HeadlessWxCallbackOption<HeadlessWxGetStorageResult> {
157
+ key: string;
158
+ }
159
+ interface HeadlessWxGetStorageInfoOption extends HeadlessWxCallbackOption<HeadlessWxStorageInfoResult> {}
160
+ interface HeadlessWxGetNetworkTypeOption extends HeadlessWxCallbackOption<HeadlessWxGetNetworkTypeResult> {}
161
+ interface HeadlessWxGetSystemInfoOption extends HeadlessWxCallbackOption<HeadlessWxSystemInfoResult> {}
162
+ interface HeadlessWxGetWindowInfoOption extends HeadlessWxCallbackOption<HeadlessWxWindowInfoResult> {}
163
+ interface HeadlessWxGetAppBaseInfoOption extends HeadlessWxCallbackOption<HeadlessWxAppBaseInfoResult> {}
164
+ interface HeadlessWxRemoveStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
165
+ key: string;
166
+ }
167
+ interface HeadlessWxClearStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {}
168
+ interface HeadlessWxHideLoadingOption extends HeadlessWxCallbackOption<{
169
+ errMsg: string;
170
+ }> {}
171
+ interface HeadlessWxSetBackgroundTextStyleOption extends HeadlessWxCallbackOption<{
172
+ errMsg: string;
173
+ }> {
174
+ textStyle: string;
175
+ }
176
+ interface HeadlessWxSetBackgroundColorOption extends HeadlessWxCallbackOption<{
177
+ errMsg: string;
178
+ }> {
179
+ backgroundColor?: string;
180
+ backgroundColorBottom?: string;
181
+ backgroundColorTop?: string;
182
+ }
183
+ interface HeadlessWxSetNavigationBarTitleOption extends HeadlessWxCallbackOption<{
184
+ errMsg: string;
185
+ }> {
186
+ title: string;
187
+ }
188
+ interface HeadlessWxSetNavigationBarColorOption extends HeadlessWxCallbackOption<{
189
+ errMsg: string;
190
+ }> {
191
+ animation?: {
192
+ duration?: number;
193
+ timingFunction?: string;
194
+ };
195
+ backgroundColor?: string;
196
+ frontColor?: string;
197
+ }
198
+ interface HeadlessWxShowNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
199
+ errMsg: string;
200
+ }> {}
201
+ interface HeadlessWxHideNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
202
+ errMsg: string;
203
+ }> {}
204
+ interface HeadlessWxShareMenuOption extends HeadlessWxCallbackOption<{
205
+ errMsg: string;
206
+ }> {
207
+ isUpdatableMessage?: boolean;
208
+ menus?: string[];
209
+ withShareTicket?: boolean;
210
+ }
211
+ interface HeadlessWxTabBarOption extends HeadlessWxCallbackOption<{
212
+ errMsg: string;
213
+ }> {}
214
+ interface HeadlessWxTabBarItemOption extends HeadlessWxCallbackOption<{
215
+ errMsg: string;
216
+ }> {
217
+ index: number;
218
+ }
219
+ interface HeadlessWxSetTabBarBadgeOption extends HeadlessWxTabBarItemOption {
220
+ text: string;
221
+ }
222
+ interface HeadlessWxShowActionSheetResult {
223
+ errMsg: string;
224
+ tapIndex: number;
225
+ }
226
+ interface HeadlessWxShowActionSheetOption extends HeadlessWxCallbackOption<HeadlessWxShowActionSheetResult> {
227
+ itemList: string[];
228
+ }
229
+ interface HeadlessWxShowModalResult {
230
+ cancel: boolean;
231
+ confirm: boolean;
232
+ errMsg: string;
233
+ }
234
+ interface HeadlessWxShowModalOption extends HeadlessWxCallbackOption<HeadlessWxShowModalResult> {
235
+ cancelColor?: string;
236
+ cancelText?: string;
237
+ confirmColor?: string;
238
+ confirmText?: string;
239
+ content: string;
240
+ showCancel?: boolean;
241
+ title?: string;
242
+ }
40
243
  interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
41
244
  errMsg: string;
42
245
  }> {
@@ -45,6 +248,12 @@ interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
45
248
  mask?: boolean;
46
249
  title: string;
47
250
  }
251
+ interface HeadlessWxShowLoadingOption extends HeadlessWxCallbackOption<{
252
+ errMsg: string;
253
+ }> {
254
+ mask?: boolean;
255
+ title: string;
256
+ }
48
257
  interface HeadlessWxRequestSuccessResult {
49
258
  cookies: string[];
50
259
  data: unknown;
@@ -62,44 +271,185 @@ interface HeadlessWxRequestTask {
62
271
  abort: () => void;
63
272
  }
64
273
  interface HeadlessWxDriver {
274
+ executeSelectorQuery: (requests: HeadlessWxSelectorQueryRequest[], scope?: Record<string, any>) => unknown[];
275
+ getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
65
276
  clearStorageSync: () => void;
277
+ getEnterOptionsSync: () => HeadlessWxLaunchOptions;
278
+ getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
279
+ getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
280
+ getNetworkType: () => HeadlessWxGetNetworkTypeResult;
281
+ getStorageInfoSync: () => HeadlessWxStorageInfoResult;
66
282
  getStorageSync: (key: string) => unknown;
283
+ getSystemInfoSync: () => HeadlessWxSystemInfoResult;
284
+ getWindowInfoSync: () => HeadlessWxWindowInfoResult;
285
+ hideLoading: () => {
286
+ errMsg: string;
287
+ };
67
288
  hideToast: () => {
68
289
  errMsg: string;
69
290
  };
70
291
  navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
71
292
  navigateTo: (option: HeadlessWxNavigateOption) => unknown;
293
+ nextTick: (callback?: () => void) => void;
294
+ offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
295
+ onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
72
296
  pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
73
297
  reLaunch: (option: HeadlessWxNavigateOption) => unknown;
74
298
  redirectTo: (option: HeadlessWxNavigateOption) => unknown;
75
299
  removeStorageSync: (key: string) => void;
76
- request: (option: HeadlessWxRequestOption) => HeadlessWxRequestSuccessResult;
300
+ request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
301
+ setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
302
+ errMsg: string;
303
+ };
304
+ setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
305
+ errMsg: string;
306
+ };
77
307
  setStorageSync: (key: string, value: unknown) => void;
308
+ setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
309
+ errMsg: string;
310
+ };
311
+ setNavigationBarTitle: (option: HeadlessWxSetNavigationBarTitleOption) => {
312
+ errMsg: string;
313
+ };
314
+ hideShareMenu: () => {
315
+ errMsg: string;
316
+ };
317
+ hideNavigationBarLoading: () => {
318
+ errMsg: string;
319
+ };
320
+ hideTabBar: () => {
321
+ errMsg: string;
322
+ };
323
+ hideTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
324
+ errMsg: string;
325
+ };
326
+ showShareMenu: (option: HeadlessWxShareMenuOption) => {
327
+ errMsg: string;
328
+ };
329
+ showNavigationBarLoading: () => {
330
+ errMsg: string;
331
+ };
332
+ showTabBar: () => {
333
+ errMsg: string;
334
+ };
335
+ showTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
336
+ errMsg: string;
337
+ };
338
+ showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult;
339
+ showLoading: (option: HeadlessWxShowLoadingOption) => {
340
+ errMsg: string;
341
+ };
342
+ showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult;
78
343
  showToast: (option: HeadlessWxShowToastOption) => {
79
344
  errMsg: string;
80
345
  };
81
346
  stopPullDownRefresh: () => void;
82
347
  switchTab: (option: HeadlessWxNavigateOption) => unknown;
348
+ removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
349
+ errMsg: string;
350
+ };
351
+ setTabBarBadge: (option: HeadlessWxSetTabBarBadgeOption) => {
352
+ errMsg: string;
353
+ };
354
+ updateShareMenu: (option: HeadlessWxShareMenuOption) => {
355
+ errMsg: string;
356
+ };
83
357
  }
84
358
  interface HeadlessWx {
359
+ canIUse: (schema: string) => boolean;
360
+ clearStorage: (option?: HeadlessWxClearStorageOption) => HeadlessWxStorageResult | undefined;
85
361
  clearStorageSync: () => void;
362
+ createSelectorQuery: () => HeadlessWxSelectorQuery;
363
+ getEnterOptionsSync: () => HeadlessWxLaunchOptions;
364
+ getAppBaseInfo: (option?: HeadlessWxGetAppBaseInfoOption) => HeadlessWxAppBaseInfoResult | undefined;
365
+ getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
366
+ getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
367
+ getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
368
+ getNetworkType: (option?: HeadlessWxGetNetworkTypeOption) => HeadlessWxGetNetworkTypeResult | undefined;
369
+ getStorageInfo: (option?: HeadlessWxGetStorageInfoOption) => HeadlessWxStorageInfoResult | undefined;
370
+ getStorageInfoSync: () => HeadlessWxStorageInfoResult;
371
+ getStorage: (option: HeadlessWxGetStorageOption) => HeadlessWxGetStorageResult | undefined;
86
372
  getStorageSync: (key: string) => unknown;
373
+ getSystemInfo: (option?: HeadlessWxGetSystemInfoOption) => HeadlessWxSystemInfoResult | undefined;
374
+ getSystemInfoSync: () => HeadlessWxSystemInfoResult;
375
+ getWindowInfo: (option?: HeadlessWxGetWindowInfoOption) => HeadlessWxWindowInfoResult | undefined;
376
+ getWindowInfoSync: () => HeadlessWxWindowInfoResult;
377
+ hideLoading: (option?: HeadlessWxHideLoadingOption) => {
378
+ errMsg: string;
379
+ } | undefined;
87
380
  hideToast: () => {
88
381
  errMsg: string;
89
382
  };
90
383
  navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
91
384
  navigateTo: (option: HeadlessWxNavigateOption) => unknown;
385
+ nextTick: (callback?: () => void) => void;
386
+ offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
387
+ onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
92
388
  pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
93
389
  reLaunch: (option: HeadlessWxNavigateOption) => unknown;
94
390
  redirectTo: (option: HeadlessWxNavigateOption) => unknown;
391
+ removeStorage: (option: HeadlessWxRemoveStorageOption) => HeadlessWxStorageResult | undefined;
95
392
  removeStorageSync: (key: string) => void;
96
393
  request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
394
+ setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
395
+ errMsg: string;
396
+ } | undefined;
397
+ setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
398
+ errMsg: string;
399
+ } | undefined;
400
+ setStorage: (option: HeadlessWxSetStorageOption) => HeadlessWxStorageResult | undefined;
97
401
  setStorageSync: (key: string, value: unknown) => void;
402
+ setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
403
+ errMsg: string;
404
+ } | undefined;
405
+ setNavigationBarTitle: (option: HeadlessWxSetNavigationBarTitleOption) => {
406
+ errMsg: string;
407
+ } | undefined;
408
+ hideShareMenu: (option?: HeadlessWxCallbackOption<{
409
+ errMsg: string;
410
+ }>) => {
411
+ errMsg: string;
412
+ } | undefined;
413
+ hideNavigationBarLoading: (option?: HeadlessWxHideNavigationBarLoadingOption) => {
414
+ errMsg: string;
415
+ } | undefined;
416
+ hideTabBar: (option?: HeadlessWxTabBarOption) => {
417
+ errMsg: string;
418
+ } | undefined;
419
+ hideTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
420
+ errMsg: string;
421
+ } | undefined;
422
+ showShareMenu: (option?: HeadlessWxShareMenuOption) => {
423
+ errMsg: string;
424
+ } | undefined;
425
+ showNavigationBarLoading: (option?: HeadlessWxShowNavigationBarLoadingOption) => {
426
+ errMsg: string;
427
+ } | undefined;
428
+ showTabBar: (option?: HeadlessWxTabBarOption) => {
429
+ errMsg: string;
430
+ } | undefined;
431
+ showTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
432
+ errMsg: string;
433
+ } | undefined;
434
+ showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult | undefined;
435
+ showLoading: (option: HeadlessWxShowLoadingOption) => {
436
+ errMsg: string;
437
+ } | undefined;
438
+ showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult | undefined;
98
439
  showToast: (option: HeadlessWxShowToastOption) => {
99
440
  errMsg: string;
100
441
  } | undefined;
101
442
  stopPullDownRefresh: () => void;
102
443
  switchTab: (option: HeadlessWxNavigateOption) => unknown;
444
+ removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
445
+ errMsg: string;
446
+ } | undefined;
447
+ setTabBarBadge: (option: HeadlessWxSetTabBarBadgeOption) => {
448
+ errMsg: string;
449
+ } | undefined;
450
+ updateShareMenu: (option?: HeadlessWxShareMenuOption) => {
451
+ errMsg: string;
452
+ } | undefined;
103
453
  }
104
454
  declare function createHeadlessWx(driver: HeadlessWxDriver): HeadlessWx;
105
455
  //#endregion
@@ -193,10 +543,34 @@ declare function createComponentInstance(options: CreateComponentInstanceOptions
193
543
  declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
194
544
  declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
195
545
  //#endregion
546
+ //#region src/project/pageConfig.d.ts
547
+ interface HeadlessNavigationBarSnapshot {
548
+ animation: {
549
+ duration?: number;
550
+ timingFunction?: string;
551
+ } | null;
552
+ backgroundColor: string;
553
+ frontColor: string;
554
+ loading: boolean;
555
+ title: string;
556
+ }
557
+ type HeadlessBackgroundTextStyle = 'dark' | 'light';
558
+ interface HeadlessBackgroundSnapshot {
559
+ backgroundColor: string;
560
+ backgroundColorBottom: string;
561
+ backgroundColorTop: string;
562
+ textStyle: HeadlessBackgroundTextStyle;
563
+ }
564
+ //#endregion
196
565
  //#region src/runtime/pageInstance.d.ts
197
566
  interface HeadlessPageInstance extends Record<string, any> {
567
+ __background__?: HeadlessBackgroundSnapshot;
568
+ __backgroundTextStyle__?: HeadlessBackgroundTextStyle;
198
569
  __lastChangedKeys__?: string[];
570
+ __navigationBar__?: HeadlessNavigationBarSnapshot;
571
+ __navigationBarTitle__?: string;
199
572
  __route__: string;
573
+ __scrollTop__?: number;
200
574
  data: Record<string, any>;
201
575
  options: Record<string, string>;
202
576
  route: string;
@@ -204,15 +578,19 @@ interface HeadlessPageInstance extends Record<string, any> {
204
578
  selectComponent?: (selector: string) => any;
205
579
  setData: (patch: Record<string, any>, callback?: () => void) => void;
206
580
  }
207
- declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>): HeadlessPageInstance;
581
+ declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>, pageState?: {
582
+ background?: HeadlessBackgroundSnapshot;
583
+ backgroundTextStyle?: HeadlessBackgroundTextStyle;
584
+ navigationBar?: HeadlessNavigationBarSnapshot;
585
+ }): HeadlessPageInstance;
208
586
  //#endregion
209
587
  //#region src/browser/render.d.ts
210
- interface DomNodeLike$3 {
588
+ interface DomNodeLike$5 {
211
589
  attribs?: Record<string, string>;
212
- children?: DomNodeLike$3[];
590
+ children?: DomNodeLike$5[];
213
591
  data?: string;
214
592
  name?: string;
215
- parent?: DomNodeLike$3 | null;
593
+ parent?: DomNodeLike$5 | null;
216
594
  type?: string;
217
595
  }
218
596
  interface BrowserRenderScope {
@@ -232,7 +610,7 @@ interface BrowserRenderScope {
232
610
  ownerScopeId?: string;
233
611
  }
234
612
  interface BrowserRenderedPageTree {
235
- root: DomNodeLike$3;
613
+ root: DomNodeLike$5;
236
614
  wxml: string;
237
615
  }
238
616
  interface BrowserRendererContext {
@@ -256,14 +634,101 @@ interface HeadlessAppInstance extends Record<string, any> {
256
634
  }
257
635
  declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
258
636
  //#endregion
637
+ //#region src/project/loadProject.d.ts
638
+ declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
639
+ //#endregion
640
+ //#region src/runtime/moduleLoader.d.ts
641
+ interface HeadlessModuleLoader {
642
+ executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
643
+ executeAppModule: (filePath: string) => HeadlessAppDefinition;
644
+ executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
645
+ }
646
+ //#endregion
647
+ //#region src/runtime/render.d.ts
648
+ interface DomNodeLike$4 {
649
+ attribs?: Record<string, string>;
650
+ children?: DomNodeLike$4[];
651
+ data?: string;
652
+ name?: string;
653
+ parent?: DomNodeLike$4 | null;
654
+ type?: string;
655
+ }
656
+ interface RuntimeRenderScope {
657
+ alias?: string;
658
+ classList?: string[];
659
+ data: Record<string, any>;
660
+ dataset?: Record<string, string>;
661
+ eventBindings?: Map<string, {
662
+ method: string;
663
+ stopAfter: boolean;
664
+ }>;
665
+ getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
666
+ getScopeId: () => string;
667
+ hostId?: string;
668
+ listenerScopeId?: string;
669
+ id?: string;
670
+ ownerScopeId?: string;
671
+ }
672
+ interface RuntimeRenderedPageTree {
673
+ root: DomNodeLike$4;
674
+ wxml: string;
675
+ }
676
+ interface RuntimeRendererContext {
677
+ changedPageKeys: string[];
678
+ componentCache: Map<string, HeadlessComponentInstance>;
679
+ componentScopes: Map<string, RuntimeRenderScope>;
680
+ moduleLoader: HeadlessModuleLoader;
681
+ project: HeadlessProjectDescriptor;
682
+ session: {
683
+ selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
684
+ selectComponentWithin: (scopeId: string, selector: string) => any;
685
+ selectOwnerComponent: (scopeId: string) => any;
686
+ };
687
+ }
688
+ declare function renderRuntimePageTree(context: RuntimeRendererContext, page: HeadlessPageInstance): RuntimeRenderedPageTree;
689
+ //#endregion
259
690
  //#region src/runtime/wxState.d.ts
691
+ interface HeadlessWxLoadingSnapshot {
692
+ mask: boolean;
693
+ title: string;
694
+ }
260
695
  interface HeadlessWxToastSnapshot {
261
696
  duration: number;
262
697
  icon: string;
263
698
  mask: boolean;
264
699
  title: string;
265
700
  }
701
+ interface HeadlessWxNetworkSnapshot extends HeadlessWxNetworkStatusChangeResult {}
702
+ interface HeadlessWxShareMenuSnapshot {
703
+ isUpdatableMessage: boolean;
704
+ menus: string[];
705
+ visible: boolean;
706
+ withShareTicket: boolean;
707
+ }
708
+ interface HeadlessWxActionSheetMockDefinition {
709
+ cancel?: boolean;
710
+ tapIndex?: number;
711
+ }
712
+ interface HeadlessWxActionSheetLogEntry {
713
+ itemList: string[];
714
+ result?: HeadlessWxShowActionSheetResult;
715
+ }
716
+ interface HeadlessWxModalMockDefinition {
717
+ cancel?: boolean;
718
+ confirm?: boolean;
719
+ }
720
+ interface HeadlessWxModalLogEntry {
721
+ cancelColor: string;
722
+ cancelText: string;
723
+ confirmColor: string;
724
+ confirmText: string;
725
+ content: string;
726
+ result: HeadlessWxShowModalResult;
727
+ showCancel: boolean;
728
+ title: string;
729
+ }
266
730
  interface HeadlessWxRequestMockDefinition {
731
+ delay?: number;
267
732
  header?: Record<string, string>;
268
733
  method?: string;
269
734
  response: unknown | ((option: HeadlessWxRequestOption) => unknown);
@@ -280,6 +745,28 @@ interface HeadlessWxRequestLogEntry {
280
745
  }
281
746
  declare function createHeadlessWxState(): {
282
747
  clearStorageSync(): void;
748
+ getActionSheetLogs(): {
749
+ itemList: string[];
750
+ result: {
751
+ errMsg: string;
752
+ tapIndex: number;
753
+ } | undefined;
754
+ }[];
755
+ getNetworkType(): HeadlessWxGetNetworkTypeResult;
756
+ getModalLogs(): {
757
+ result: {
758
+ cancel: boolean;
759
+ confirm: boolean;
760
+ errMsg: string;
761
+ };
762
+ cancelColor: string;
763
+ cancelText: string;
764
+ confirmColor: string;
765
+ confirmText: string;
766
+ content: string;
767
+ showCancel: boolean;
768
+ title: string;
769
+ }[];
283
770
  getRequestLogs(): {
284
771
  data: unknown;
285
772
  header: {
@@ -298,44 +785,74 @@ declare function createHeadlessWxState(): {
298
785
  method: string;
299
786
  url: string;
300
787
  }[];
788
+ getStorageInfoSync(): {
789
+ currentSize: number;
790
+ errMsg: string;
791
+ keys: string[];
792
+ limitSize: number;
793
+ };
301
794
  getStorageSnapshot(): {
302
795
  [k: string]: unknown;
303
796
  };
304
797
  getStorageSync(key: string): unknown;
798
+ getShareMenu(): {
799
+ isUpdatableMessage: boolean;
800
+ menus: string[];
801
+ visible: boolean;
802
+ withShareTicket: boolean;
803
+ };
804
+ getLoading(): {
805
+ mask: boolean;
806
+ title: string;
807
+ } | null;
808
+ hideShareMenu(): {
809
+ errMsg: string;
810
+ };
305
811
  getToast(): {
306
812
  duration: number;
307
813
  icon: string;
308
814
  mask: boolean;
309
815
  title: string;
310
816
  } | null;
817
+ hideLoading(): {
818
+ errMsg: string;
819
+ };
311
820
  hideToast(): {
312
821
  errMsg: string;
313
822
  };
823
+ offNetworkStatusChange(callback?: HeadlessWxNetworkStatusChangeCallback): void;
314
824
  mockRequest(definition: HeadlessWxRequestMockDefinition): void;
825
+ mockModal(definition?: HeadlessWxModalMockDefinition): void;
826
+ mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
827
+ onNetworkStatusChange(callback: HeadlessWxNetworkStatusChangeCallback): void;
315
828
  removeStorageSync(key: string): void;
316
- request(option: HeadlessWxRequestOption): HeadlessWxRequestSuccessResult;
829
+ request(option: HeadlessWxRequestOption): HeadlessWxRequestTask;
317
830
  setStorageSync(key: string, value: unknown): void;
831
+ setNetworkType(nextNetworkType: HeadlessWxNetworkType): {
832
+ errMsg: string;
833
+ networkType: HeadlessWxNetworkType;
834
+ };
835
+ showActionSheet(option: HeadlessWxShowActionSheetOption): HeadlessWxShowActionSheetResult;
836
+ showShareMenu(option?: HeadlessWxShareMenuOption): {
837
+ errMsg: string;
838
+ };
839
+ showLoading(option: HeadlessWxShowLoadingOption): {
840
+ errMsg: string;
841
+ };
842
+ showModal(option: HeadlessWxShowModalOption): HeadlessWxShowModalResult;
318
843
  showToast(option: HeadlessWxShowToastOption): {
319
844
  errMsg: string;
320
845
  };
846
+ updateShareMenu(option?: HeadlessWxShareMenuOption): {
847
+ errMsg: string;
848
+ };
321
849
  };
322
850
  //#endregion
323
- //#region src/browser/session.d.ts
324
- interface BrowserHeadlessSessionOptions {
325
- files: BrowserVirtualFiles;
326
- project?: HeadlessProjectDescriptor;
327
- }
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;
851
+ //#region src/runtime/session.d.ts
852
+ interface HeadlessSessionOptions {
853
+ projectPath: string;
336
854
  }
337
- declare class BrowserHeadlessSession {
338
- readonly files: BrowserVirtualFiles;
855
+ declare class HeadlessSession {
339
856
  readonly project: HeadlessProjectDescriptor;
340
857
  private appDefinition;
341
858
  private appInstance;
@@ -348,10 +865,40 @@ declare class BrowserHeadlessSession {
348
865
  private readonly tabBarRoutes;
349
866
  private readonly tabPages;
350
867
  private readonly tabBarItems;
868
+ private readonly tabBarState;
869
+ private tabBarVisible;
870
+ private readonly systemInfo;
871
+ private enterOptions;
872
+ private launchOptions;
351
873
  private readonly wxState;
352
- constructor(options: BrowserHeadlessSessionOptions);
874
+ private pullDownRefreshState;
875
+ constructor(options: HeadlessSessionOptions);
353
876
  getApp(): HeadlessAppInstance | null;
354
877
  getCurrentPages(): HeadlessPageInstance[];
878
+ getCurrentPageNavigationBarTitle(): string | null;
879
+ getCurrentPageNavigationBar(): {
880
+ animation: {
881
+ duration?: number;
882
+ timingFunction?: string;
883
+ } | null;
884
+ backgroundColor: string;
885
+ frontColor: string;
886
+ loading: boolean;
887
+ title: string;
888
+ } | null;
889
+ getCurrentPageBackground(): {
890
+ backgroundColor: string;
891
+ backgroundColorBottom: string;
892
+ backgroundColorTop: string;
893
+ textStyle: HeadlessBackgroundTextStyle;
894
+ } | null;
895
+ getActionSheetLogs(): {
896
+ itemList: string[];
897
+ result: {
898
+ errMsg: string;
899
+ tapIndex: number;
900
+ } | undefined;
901
+ }[];
355
902
  getRequestLogs(): {
356
903
  data: unknown;
357
904
  header: {
@@ -370,20 +917,11 @@ declare class BrowserHeadlessSession {
370
917
  method: string;
371
918
  url: string;
372
919
  }[];
373
- getStorageSnapshot(): {
374
- [k: string]: unknown;
375
- };
376
- getToast(): {
377
- duration: number;
378
- icon: string;
379
- mask: boolean;
380
- title: string;
381
- } | null;
382
- mockRequest(definition: HeadlessWxRequestMockDefinition): void;
920
+ renderCurrentPage(): RuntimeRenderedPageTree;
383
921
  getScopeSnapshot(scopeId: string): {
384
- data: any;
922
+ data: Record<string, any>;
385
923
  methods: string[];
386
- properties: any;
924
+ properties: Record<string, any>;
387
925
  scopeId: string;
388
926
  type: "component";
389
927
  } | {
@@ -399,27 +937,169 @@ declare class BrowserHeadlessSession {
399
937
  scopeId: string;
400
938
  type: "scope";
401
939
  } | null;
402
- selectComponent(selector: string): any;
403
- selectAllComponents(selector: string): any[];
404
- selectComponentWithin(scopeId: string, selector: string): any;
405
- selectAllComponentsWithin(scopeId: string, selector: string): any[];
406
- selectOwnerComponent(scopeId: string): any;
407
- private selectComponentsWithin;
408
- renderCurrentPage(): BrowserRenderedPageTree;
409
- callTapBinding(scopeId: string, methodName: string): any;
410
- callTapBindingWithEvent(scopeId: string, methodName: string, event?: {
411
- currentTarget?: {
412
- dataset?: Record<string, string>;
413
- id?: string;
940
+ getScopeIdForComponent(component: HeadlessComponentInstance | null | undefined): string | null;
941
+ callScopeMethod(scopeId: string | null, methodName: string, event: Record<string, any>): any;
942
+ callScopeMethodDirect(scopeId: string, methodName: string, ...args: any[]): any;
943
+ getStorageSnapshot(): {
944
+ [k: string]: unknown;
945
+ };
946
+ getShareMenu(): {
947
+ isUpdatableMessage: boolean;
948
+ menus: string[];
949
+ visible: boolean;
950
+ withShareTicket: boolean;
951
+ };
952
+ selectComponent(selector: string): HeadlessComponentInstance | null;
953
+ selectAllComponents(selector: string): (HeadlessComponentInstance | undefined)[];
954
+ selectComponentWithin(scopeId: string, selector: string): HeadlessComponentInstance | null;
955
+ selectAllComponentsWithin(scopeId: string, selector: string): (HeadlessComponentInstance | undefined)[];
956
+ selectOwnerComponent(scopeId: string): HeadlessComponentInstance | null;
957
+ getTabBar(): {
958
+ visible: boolean;
959
+ };
960
+ getTabBarSnapshot(): {
961
+ items: {
962
+ badge: string | null;
963
+ index: number;
964
+ pagePath: string;
965
+ redDot: boolean;
966
+ text: string | undefined;
967
+ }[];
968
+ visible: boolean;
969
+ };
970
+ getStorageInfo(): {
971
+ currentSize: number;
972
+ errMsg: string;
973
+ keys: string[];
974
+ limitSize: number;
975
+ };
976
+ getPullDownRefreshState(): {
977
+ active: boolean;
978
+ stopCalls: number;
979
+ };
980
+ getSystemInfo(): {
981
+ SDKVersion: string;
982
+ brand: string;
983
+ language: string;
984
+ model: string;
985
+ pixelRatio: number;
986
+ platform: string;
987
+ screenHeight: number;
988
+ screenWidth: number;
989
+ system: string;
990
+ version: string;
991
+ windowHeight: number;
992
+ windowWidth: number;
993
+ };
994
+ getWindowInfo(): HeadlessWxWindowInfoResult;
995
+ getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
996
+ getLaunchOptions(): {
997
+ query: {
998
+ [x: string]: string;
414
999
  };
415
- dataset?: Record<string, string>;
416
- id?: string;
417
- target?: {
418
- dataset?: Record<string, string>;
419
- id?: string;
1000
+ referrerInfo: {
1001
+ extraData: {
1002
+ [x: string]: never;
1003
+ };
1004
+ appId: string;
420
1005
  };
421
- }): any;
422
- bootstrap(launchOptions?: HeadlessAppLaunchOptions$1): HeadlessAppInstance;
1006
+ path: string;
1007
+ scene: number;
1008
+ };
1009
+ getEnterOptions(): {
1010
+ query: {
1011
+ [x: string]: string;
1012
+ };
1013
+ referrerInfo: {
1014
+ extraData: {
1015
+ [x: string]: never;
1016
+ };
1017
+ appId: string;
1018
+ };
1019
+ path: string;
1020
+ scene: number;
1021
+ };
1022
+ getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
1023
+ getNetworkType(): HeadlessWxGetNetworkTypeResult;
1024
+ getLoading(): {
1025
+ mask: boolean;
1026
+ title: string;
1027
+ } | null;
1028
+ getModalLogs(): {
1029
+ result: {
1030
+ cancel: boolean;
1031
+ confirm: boolean;
1032
+ errMsg: string;
1033
+ };
1034
+ cancelColor: string;
1035
+ cancelText: string;
1036
+ confirmColor: string;
1037
+ confirmText: string;
1038
+ content: string;
1039
+ showCancel: boolean;
1040
+ title: string;
1041
+ }[];
1042
+ getToast(): {
1043
+ duration: number;
1044
+ icon: string;
1045
+ mask: boolean;
1046
+ title: string;
1047
+ } | null;
1048
+ mockModal(definition?: HeadlessWxModalMockDefinition): void;
1049
+ mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
1050
+ mockRequest(definition: HeadlessWxRequestMockDefinition): void;
1051
+ setNetworkType(networkType: HeadlessWxNetworkType): {
1052
+ errMsg: string;
1053
+ networkType: HeadlessWxNetworkType;
1054
+ };
1055
+ setBackgroundTextStyle(textStyle: string): {
1056
+ errMsg: string;
1057
+ };
1058
+ setBackgroundColor(option: {
1059
+ backgroundColor?: string;
1060
+ backgroundColorBottom?: string;
1061
+ backgroundColorTop?: string;
1062
+ }): {
1063
+ errMsg: string;
1064
+ };
1065
+ setNavigationBarTitle(title: string): {
1066
+ errMsg: string;
1067
+ };
1068
+ setNavigationBarColor(option: {
1069
+ animation?: {
1070
+ duration?: number;
1071
+ timingFunction?: string;
1072
+ };
1073
+ backgroundColor?: string;
1074
+ frontColor?: string;
1075
+ }): {
1076
+ errMsg: string;
1077
+ };
1078
+ showNavigationBarLoading(): {
1079
+ errMsg: string;
1080
+ };
1081
+ hideNavigationBarLoading(): {
1082
+ errMsg: string;
1083
+ };
1084
+ hideTabBar(): {
1085
+ errMsg: string;
1086
+ };
1087
+ hideTabBarRedDot(index: number): {
1088
+ errMsg: string;
1089
+ };
1090
+ showTabBar(): {
1091
+ errMsg: string;
1092
+ };
1093
+ showTabBarRedDot(index: number): {
1094
+ errMsg: string;
1095
+ };
1096
+ removeTabBarBadge(index: number): {
1097
+ errMsg: string;
1098
+ };
1099
+ setTabBarBadge(index: number, text: string): {
1100
+ errMsg: string;
1101
+ };
1102
+ bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
423
1103
  reLaunch(url: string): HeadlessPageInstance;
424
1104
  navigateTo(url: string): HeadlessPageInstance;
425
1105
  redirectTo(url: string): HeadlessPageInstance;
@@ -427,42 +1107,41 @@ declare class BrowserHeadlessSession {
427
1107
  switchTab(url: string): HeadlessPageInstance;
428
1108
  pageScrollTo(option: {
429
1109
  scrollTop?: number;
1110
+ duration?: number;
1111
+ selector?: string;
1112
+ success?: () => void;
1113
+ fail?: (error: Error) => void;
1114
+ complete?: () => void;
430
1115
  }): void;
431
1116
  triggerPullDownRefresh(): HeadlessPageInstance;
432
1117
  triggerReachBottom(): HeadlessPageInstance;
433
1118
  triggerResize(options: Record<string, any>): HeadlessPageInstance;
434
1119
  triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
435
1120
  stopPullDownRefresh(): void;
1121
+ private executeSelectorQuery;
436
1122
  private createFreshPage;
437
1123
  private isTabBarRoute;
1124
+ private resolveTabBarItem;
1125
+ private requireTabBarItem;
438
1126
  private removePageInstance;
439
1127
  private resolveNavigationTarget;
440
- private resolveTabBarItem;
441
1128
  private unloadAllPages;
442
1129
  private unloadPage;
443
1130
  private requireCurrentPage;
1131
+ private selectComponentsWithin;
444
1132
  private detachPageComponents;
445
1133
  private runPageComponentLifetime;
1134
+ private getComponentScopeId;
446
1135
  }
447
- declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
448
- //#endregion
449
- //#region src/project/loadProject.d.ts
450
- declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
1136
+ declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
451
1137
  //#endregion
452
- //#region src/runtime/session.d.ts
453
- interface HeadlessSessionOptions {
454
- projectPath: string;
455
- }
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;
1138
+ //#region src/browser/session.d.ts
1139
+ interface BrowserHeadlessSessionOptions {
1140
+ files: BrowserVirtualFiles;
1141
+ project?: HeadlessProjectDescriptor;
464
1142
  }
465
- declare class HeadlessSession {
1143
+ declare class BrowserHeadlessSession {
1144
+ readonly files: BrowserVirtualFiles;
466
1145
  readonly project: HeadlessProjectDescriptor;
467
1146
  private appDefinition;
468
1147
  private appInstance;
@@ -470,13 +1149,45 @@ declare class HeadlessSession {
470
1149
  private readonly registries;
471
1150
  private currentPageInstance;
472
1151
  private readonly pages;
1152
+ private readonly componentCache;
1153
+ private readonly componentScopes;
473
1154
  private readonly tabBarRoutes;
474
1155
  private readonly tabPages;
475
1156
  private readonly tabBarItems;
1157
+ private readonly tabBarState;
1158
+ private tabBarVisible;
1159
+ private readonly systemInfo;
1160
+ private enterOptions;
1161
+ private launchOptions;
476
1162
  private readonly wxState;
477
- constructor(options: HeadlessSessionOptions);
1163
+ private pullDownRefreshState;
1164
+ constructor(options: BrowserHeadlessSessionOptions);
478
1165
  getApp(): HeadlessAppInstance | null;
479
1166
  getCurrentPages(): HeadlessPageInstance[];
1167
+ getCurrentPageNavigationBarTitle(): string | null;
1168
+ getCurrentPageNavigationBar(): {
1169
+ animation: {
1170
+ duration?: number;
1171
+ timingFunction?: string;
1172
+ } | null;
1173
+ backgroundColor: string;
1174
+ frontColor: string;
1175
+ loading: boolean;
1176
+ title: string;
1177
+ } | null;
1178
+ getCurrentPageBackground(): {
1179
+ backgroundColor: string;
1180
+ backgroundColorBottom: string;
1181
+ backgroundColorTop: string;
1182
+ textStyle: HeadlessBackgroundTextStyle;
1183
+ } | null;
1184
+ getActionSheetLogs(): {
1185
+ itemList: string[];
1186
+ result: {
1187
+ errMsg: string;
1188
+ tapIndex: number;
1189
+ } | undefined;
1190
+ }[];
480
1191
  getRequestLogs(): {
481
1192
  data: unknown;
482
1193
  header: {
@@ -498,14 +1209,201 @@ declare class HeadlessSession {
498
1209
  getStorageSnapshot(): {
499
1210
  [k: string]: unknown;
500
1211
  };
1212
+ getShareMenu(): {
1213
+ isUpdatableMessage: boolean;
1214
+ menus: string[];
1215
+ visible: boolean;
1216
+ withShareTicket: boolean;
1217
+ };
1218
+ getTabBar(): {
1219
+ visible: boolean;
1220
+ };
1221
+ getTabBarSnapshot(): {
1222
+ items: {
1223
+ badge: string | null;
1224
+ index: number;
1225
+ pagePath: string;
1226
+ redDot: boolean;
1227
+ text: string | undefined;
1228
+ }[];
1229
+ visible: boolean;
1230
+ };
1231
+ getStorageInfo(): {
1232
+ currentSize: number;
1233
+ errMsg: string;
1234
+ keys: string[];
1235
+ limitSize: number;
1236
+ };
1237
+ getPullDownRefreshState(): {
1238
+ active: boolean;
1239
+ stopCalls: number;
1240
+ };
1241
+ getSystemInfo(): {
1242
+ SDKVersion: string;
1243
+ brand: string;
1244
+ language: string;
1245
+ model: string;
1246
+ pixelRatio: number;
1247
+ platform: string;
1248
+ screenHeight: number;
1249
+ screenWidth: number;
1250
+ system: string;
1251
+ version: string;
1252
+ windowHeight: number;
1253
+ windowWidth: number;
1254
+ };
1255
+ getWindowInfo(): HeadlessWxWindowInfoResult;
1256
+ getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
1257
+ getLaunchOptions(): {
1258
+ query: {
1259
+ [x: string]: string;
1260
+ };
1261
+ referrerInfo: {
1262
+ extraData: {
1263
+ [x: string]: never;
1264
+ };
1265
+ appId: string;
1266
+ };
1267
+ path: string;
1268
+ scene: number;
1269
+ };
1270
+ getEnterOptions(): {
1271
+ query: {
1272
+ [x: string]: string;
1273
+ };
1274
+ referrerInfo: {
1275
+ extraData: {
1276
+ [x: string]: never;
1277
+ };
1278
+ appId: string;
1279
+ };
1280
+ path: string;
1281
+ scene: number;
1282
+ };
1283
+ getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
1284
+ getNetworkType(): HeadlessWxGetNetworkTypeResult;
1285
+ getLoading(): {
1286
+ mask: boolean;
1287
+ title: string;
1288
+ } | null;
1289
+ getModalLogs(): {
1290
+ result: {
1291
+ cancel: boolean;
1292
+ confirm: boolean;
1293
+ errMsg: string;
1294
+ };
1295
+ cancelColor: string;
1296
+ cancelText: string;
1297
+ confirmColor: string;
1298
+ confirmText: string;
1299
+ content: string;
1300
+ showCancel: boolean;
1301
+ title: string;
1302
+ }[];
501
1303
  getToast(): {
502
1304
  duration: number;
503
1305
  icon: string;
504
1306
  mask: boolean;
505
1307
  title: string;
506
1308
  } | null;
1309
+ mockModal(definition?: HeadlessWxModalMockDefinition): void;
1310
+ mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
507
1311
  mockRequest(definition: HeadlessWxRequestMockDefinition): void;
508
- bootstrap(launchOptions?: HeadlessAppLaunchOptions): HeadlessAppInstance;
1312
+ setNetworkType(networkType: HeadlessWxNetworkType): {
1313
+ errMsg: string;
1314
+ networkType: HeadlessWxNetworkType;
1315
+ };
1316
+ setBackgroundTextStyle(textStyle: string): {
1317
+ errMsg: string;
1318
+ };
1319
+ setBackgroundColor(option: {
1320
+ backgroundColor?: string;
1321
+ backgroundColorBottom?: string;
1322
+ backgroundColorTop?: string;
1323
+ }): {
1324
+ errMsg: string;
1325
+ };
1326
+ setNavigationBarTitle(title: string): {
1327
+ errMsg: string;
1328
+ };
1329
+ setNavigationBarColor(option: {
1330
+ animation?: {
1331
+ duration?: number;
1332
+ timingFunction?: string;
1333
+ };
1334
+ backgroundColor?: string;
1335
+ frontColor?: string;
1336
+ }): {
1337
+ errMsg: string;
1338
+ };
1339
+ showNavigationBarLoading(): {
1340
+ errMsg: string;
1341
+ };
1342
+ hideNavigationBarLoading(): {
1343
+ errMsg: string;
1344
+ };
1345
+ hideTabBar(): {
1346
+ errMsg: string;
1347
+ };
1348
+ hideTabBarRedDot(index: number): {
1349
+ errMsg: string;
1350
+ };
1351
+ showTabBar(): {
1352
+ errMsg: string;
1353
+ };
1354
+ showTabBarRedDot(index: number): {
1355
+ errMsg: string;
1356
+ };
1357
+ removeTabBarBadge(index: number): {
1358
+ errMsg: string;
1359
+ };
1360
+ setTabBarBadge(index: number, text: string): {
1361
+ errMsg: string;
1362
+ };
1363
+ getScopeSnapshot(scopeId: string): {
1364
+ data: any;
1365
+ methods: string[];
1366
+ properties: any;
1367
+ scopeId: string;
1368
+ type: "component";
1369
+ } | {
1370
+ data: Record<string, any>;
1371
+ methods: string[];
1372
+ properties: Record<string, string>;
1373
+ scopeId: string;
1374
+ type: "page";
1375
+ } | {
1376
+ data: any;
1377
+ methods: string[];
1378
+ properties: {};
1379
+ scopeId: string;
1380
+ type: "scope";
1381
+ } | null;
1382
+ getScopeIdForComponent(component: HeadlessComponentInstance | null | undefined): string | null;
1383
+ selectComponent(selector: string): any;
1384
+ selectAllComponents(selector: string): any[];
1385
+ selectComponentWithin(scopeId: string, selector: string): any;
1386
+ selectAllComponentsWithin(scopeId: string, selector: string): any[];
1387
+ selectOwnerComponent(scopeId: string): any;
1388
+ private selectComponentsWithin;
1389
+ renderCurrentPage(): BrowserRenderedPageTree;
1390
+ callScopeMethod(scopeId: string | null, methodName: string, event: Record<string, any>): any;
1391
+ callScopeMethodDirect(scopeId: string, methodName: string, ...args: any[]): any;
1392
+ callTapBinding(scopeId: string, methodName: string): any;
1393
+ callTapBindingWithEvent(scopeId: string, methodName: string, event?: {
1394
+ currentTarget?: {
1395
+ dataset?: Record<string, string>;
1396
+ id?: string;
1397
+ };
1398
+ dataset?: Record<string, string>;
1399
+ id?: string;
1400
+ mark?: Record<string, unknown>;
1401
+ target?: {
1402
+ dataset?: Record<string, string>;
1403
+ id?: string;
1404
+ };
1405
+ }): any;
1406
+ bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
509
1407
  reLaunch(url: string): HeadlessPageInstance;
510
1408
  navigateTo(url: string): HeadlessPageInstance;
511
1409
  redirectTo(url: string): HeadlessPageInstance;
@@ -513,49 +1411,120 @@ declare class HeadlessSession {
513
1411
  switchTab(url: string): HeadlessPageInstance;
514
1412
  pageScrollTo(option: {
515
1413
  scrollTop?: number;
516
- duration?: number;
517
- selector?: string;
518
- success?: () => void;
519
- fail?: (error: Error) => void;
520
- complete?: () => void;
521
1414
  }): void;
522
1415
  triggerPullDownRefresh(): HeadlessPageInstance;
523
1416
  triggerReachBottom(): HeadlessPageInstance;
524
1417
  triggerResize(options: Record<string, any>): HeadlessPageInstance;
525
1418
  triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
526
1419
  stopPullDownRefresh(): void;
1420
+ private executeSelectorQuery;
527
1421
  private createFreshPage;
528
1422
  private isTabBarRoute;
529
- private resolveTabBarItem;
530
1423
  private removePageInstance;
531
1424
  private resolveNavigationTarget;
1425
+ private resolveTabBarItem;
1426
+ private requireTabBarItem;
532
1427
  private unloadAllPages;
533
1428
  private unloadPage;
534
1429
  private requireCurrentPage;
1430
+ private detachPageComponents;
1431
+ private runPageComponentLifetime;
1432
+ private getComponentScopeId;
535
1433
  }
536
- declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
1434
+ declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
537
1435
  //#endregion
538
1436
  //#region src/view/nodeHandle.d.ts
539
- interface DomNodeLike$2 {
1437
+ interface DomNodeLike$3 {
540
1438
  attribs?: Record<string, string>;
541
- children?: DomNodeLike$2[];
1439
+ children?: DomNodeLike$3[];
542
1440
  data?: string;
543
1441
  name?: string;
544
- parent?: DomNodeLike$2 | null;
1442
+ parent?: DomNodeLike$3 | null;
545
1443
  type?: string;
546
1444
  }
1445
+ interface HeadlessTestingNodeEventInit {
1446
+ currentTarget?: {
1447
+ dataset?: Record<string, string>;
1448
+ id?: string;
1449
+ };
1450
+ dataset?: Record<string, string>;
1451
+ detail?: unknown;
1452
+ id?: string;
1453
+ mark?: Record<string, unknown>;
1454
+ target?: {
1455
+ dataset?: Record<string, string>;
1456
+ id?: string;
1457
+ };
1458
+ }
1459
+ interface HeadlessTestingNodeValueEventInit extends HeadlessTestingNodeEventInit {
1460
+ detail?: {
1461
+ value?: string;
1462
+ [key: string]: unknown;
1463
+ };
1464
+ }
1465
+ interface HeadlessTestingNodeInteractionHandlers {
1466
+ callMethod: (scopeId: string | null, methodName: string, event: Record<string, any>) => unknown;
1467
+ createScopeHandle: (scopeId: string | null) => {
1468
+ scopeId: string;
1469
+ snapshot: () => Promise<unknown>;
1470
+ } | null;
1471
+ createPageHandle: () => {
1472
+ data: (path?: string) => Promise<unknown>;
1473
+ };
1474
+ ownerScopeId: (scopeId: string | null) => string | null;
1475
+ }
547
1476
  declare class HeadlessTestingNodeHandle {
548
1477
  private readonly node;
549
- constructor(node: DomNodeLike$2);
1478
+ private readonly interactions?;
1479
+ constructor(node: DomNodeLike$3, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
550
1480
  $(selector: string): Promise<HeadlessTestingNodeHandle | null>;
551
1481
  $$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
552
1482
  attr(name: string): Promise<string | undefined>;
553
- dataset(): Promise<Record<string, any>>;
1483
+ dataset(): Promise<Record<string, string>>;
1484
+ scope(): Promise<{
1485
+ scopeId: string;
1486
+ snapshot: () => Promise<unknown>;
1487
+ } | null>;
1488
+ componentScope(): Promise<{
1489
+ scopeId: string;
1490
+ snapshot: () => Promise<unknown>;
1491
+ } | null>;
1492
+ pageScope(): Promise<{
1493
+ scopeId: string;
1494
+ snapshot: () => Promise<unknown>;
1495
+ } | null>;
1496
+ page(): Promise<{
1497
+ data: (path?: string) => Promise<unknown>;
1498
+ }>;
1499
+ ownerComponentScope(): Promise<{
1500
+ scopeId: string;
1501
+ snapshot: () => Promise<unknown>;
1502
+ } | null>;
554
1503
  text(): Promise<string>;
1504
+ trigger(eventName: string, event?: HeadlessTestingNodeEventInit): Promise<unknown>;
1505
+ tap(event?: HeadlessTestingNodeEventInit): Promise<unknown>;
1506
+ input(value: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
1507
+ change(value: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
1508
+ blur(value?: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
555
1509
  wxml(): Promise<string>;
556
1510
  }
557
1511
  //#endregion
558
1512
  //#region src/view/render.d.ts
1513
+ interface DomNodeLike$2 {
1514
+ attribs?: Record<string, string>;
1515
+ children?: DomNodeLike$2[];
1516
+ data?: string;
1517
+ name?: string;
1518
+ parent?: DomNodeLike$2 | null;
1519
+ type?: string;
1520
+ }
1521
+ interface RenderedPageTree {
1522
+ root: DomNodeLike$2;
1523
+ wxml: string;
1524
+ }
1525
+ declare function renderPageTree(project: HeadlessProjectDescriptor, page: HeadlessPageInstance): RenderedPageTree;
1526
+ //#endregion
1527
+ //#region src/view/selectorQuery.d.ts
559
1528
  interface DomNodeLike$1 {
560
1529
  attribs?: Record<string, string>;
561
1530
  children?: DomNodeLike$1[];
@@ -564,11 +1533,13 @@ interface DomNodeLike$1 {
564
1533
  parent?: DomNodeLike$1 | null;
565
1534
  type?: string;
566
1535
  }
567
- interface RenderedPageTree {
1536
+ interface HeadlessSelectorQueryResolverOptions {
1537
+ page: HeadlessPageInstance;
568
1538
  root: DomNodeLike$1;
569
- wxml: string;
1539
+ windowInfo: HeadlessWxWindowInfoResult;
570
1540
  }
571
- declare function renderPageTree(project: HeadlessProjectDescriptor, page: HeadlessPageInstance): RenderedPageTree;
1541
+ declare function executeSelectorQueryRequests(requests: HeadlessWxSelectorQueryRequest[], options: HeadlessSelectorQueryResolverOptions): (Record<string, any> | Record<string, any>[] | null)[];
1542
+ declare function resolveSelectorQueryScopeRoot(root: DomNodeLike$1, scopeId?: string | null): DomNodeLike$1;
572
1543
  //#endregion
573
1544
  //#region src/view/selectors.d.ts
574
1545
  interface DomNodeLike {
@@ -582,27 +1553,117 @@ interface DomNodeLike {
582
1553
  declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
583
1554
  //#endregion
584
1555
  //#region src/testing/pageHandle.d.ts
1556
+ interface HeadlessTestingWaitOptions {
1557
+ interval?: number;
1558
+ timeout?: number;
1559
+ }
1560
+ type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
1561
+ interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
1562
+ state?: 'attached' | 'detached';
1563
+ }
585
1564
  declare class HeadlessTestingPageHandle {
586
1565
  private readonly project;
587
1566
  private readonly page;
588
- constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance);
1567
+ private readonly session?;
1568
+ constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance, session?: HeadlessSession | undefined);
1569
+ private resolveDataByPath;
1570
+ private pollUntil;
1571
+ private createScopeHandle;
589
1572
  callMethod(methodName: string, ...args: any[]): Promise<any>;
590
1573
  data(path?: string): Promise<any>;
1574
+ selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
1575
+ selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
591
1576
  waitFor(ms?: number): Promise<void>;
592
1577
  $(selector: string): Promise<HeadlessTestingNodeHandle | null>;
593
1578
  $$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
1579
+ waitForSelector(selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<HeadlessTestingNodeHandle | null>;
1580
+ waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
1581
+ waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
1582
+ waitForText(text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
1583
+ waitForTextGone(text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
1584
+ waitForData(path: string, matcher?: HeadlessTestingDataMatcher, options?: HeadlessTestingWaitOptions): Promise<any>;
594
1585
  wxml(): Promise<string>;
595
1586
  }
596
1587
  //#endregion
597
1588
  //#region src/testing/sessionHandle.d.ts
1589
+ declare class HeadlessTestingScopeHandle {
1590
+ readonly scopeId: string;
1591
+ private readonly project;
1592
+ private readonly session;
1593
+ constructor(scopeId: string, project: HeadlessProjectDescriptor, session: HeadlessSession);
1594
+ private createScopeHandle;
1595
+ callMethod(methodName: string, ...args: any[]): Promise<any>;
1596
+ snapshot(): Promise<{
1597
+ data: Record<string, any>;
1598
+ methods: string[];
1599
+ properties: Record<string, any>;
1600
+ scopeId: string;
1601
+ type: "component";
1602
+ } | {
1603
+ data: Record<string, any>;
1604
+ methods: string[];
1605
+ properties: Record<string, string>;
1606
+ scopeId: string;
1607
+ type: "page";
1608
+ } | {
1609
+ data: any;
1610
+ methods: string[];
1611
+ properties: {};
1612
+ scopeId: string;
1613
+ type: "scope";
1614
+ } | null>;
1615
+ page(): Promise<HeadlessTestingPageHandle | null>;
1616
+ pageScope(): Promise<HeadlessTestingScopeHandle>;
1617
+ ownerComponent(): Promise<HeadlessTestingScopeHandle | null>;
1618
+ waitForOwnerComponent(options?: {
1619
+ interval?: number;
1620
+ timeout?: number;
1621
+ }): Promise<HeadlessTestingScopeHandle>;
1622
+ selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
1623
+ selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
1624
+ waitForComponent(selector: string, options?: {
1625
+ interval?: number;
1626
+ timeout?: number;
1627
+ }): Promise<HeadlessTestingScopeHandle>;
1628
+ waitForComponents(selector: string, count?: number, options?: {
1629
+ interval?: number;
1630
+ timeout?: number;
1631
+ }): Promise<HeadlessTestingScopeHandle[]>;
1632
+ }
598
1633
  declare class HeadlessTestingSessionHandle {
599
1634
  private readonly project;
600
1635
  private readonly session;
601
1636
  constructor(project: HeadlessProjectDescriptor, session: HeadlessSession);
1637
+ private waitFor;
1638
+ private pollUntil;
602
1639
  close(): Promise<void>;
603
1640
  currentPage(): Promise<HeadlessTestingPageHandle | null>;
604
1641
  getCurrentPages(): Promise<HeadlessTestingPageHandle[]>;
1642
+ scopeSnapshot(scopeId: string): Promise<{
1643
+ data: Record<string, any>;
1644
+ methods: string[];
1645
+ properties: Record<string, any>;
1646
+ scopeId: string;
1647
+ type: "component";
1648
+ } | {
1649
+ data: Record<string, any>;
1650
+ methods: string[];
1651
+ properties: Record<string, string>;
1652
+ scopeId: string;
1653
+ type: "page";
1654
+ } | {
1655
+ data: any;
1656
+ methods: string[];
1657
+ properties: {};
1658
+ scopeId: string;
1659
+ type: "scope";
1660
+ } | null>;
1661
+ selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
1662
+ selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
1663
+ waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
1664
+ waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
605
1665
  reLaunch(route: string): Promise<HeadlessTestingPageHandle>;
1666
+ waitForCurrentPage(route?: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingPageHandle>;
606
1667
  pageScrollTo(scrollTop: number): Promise<void>;
607
1668
  triggerPullDownRefresh(): Promise<void>;
608
1669
  triggerReachBottom(): Promise<void>;
@@ -616,4 +1677,4 @@ interface HeadlessTestingLaunchOptions {
616
1677
  }
617
1678
  declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
618
1679
  //#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 };
1680
+ 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, 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, HeadlessWxSelectorQuery, HeadlessWxSelectorQueryBoundingClientRectResult, HeadlessWxSelectorQueryFieldsOption, HeadlessWxSelectorQueryNode, HeadlessWxSelectorQueryRequest, HeadlessWxSelectorQueryScrollOffsetResult, HeadlessWxSetBackgroundColorOption, HeadlessWxSetBackgroundTextStyleOption, HeadlessWxSetNavigationBarColorOption, HeadlessWxSetNavigationBarTitleOption, HeadlessWxSetStorageOption, HeadlessWxSetTabBarBadgeOption, HeadlessWxShareMenuOption, HeadlessWxShareMenuSnapshot, HeadlessWxShowActionSheetOption, HeadlessWxShowActionSheetResult, HeadlessWxShowLoadingOption, HeadlessWxShowModalOption, HeadlessWxShowModalResult, HeadlessWxShowNavigationBarLoadingOption, HeadlessWxShowToastOption, HeadlessWxStorageInfoResult, HeadlessWxStorageResult, HeadlessWxSystemInfoResult, HeadlessWxTabBarItemOption, HeadlessWxTabBarOption, HeadlessWxToastSnapshot, HeadlessWxWindowInfoResult, RenderedPageTree, RuntimeRenderedPageTree, RuntimeRendererContext, cloneValue, coerceComponentPropertyValue, createAppInstance, createBrowserHeadlessSession, createBrowserModuleLoader, createBrowserProject, createBrowserVirtualFiles, createBrowserVirtualFilesFromDirectory, createComponentInstance, createHeadlessSession, createHeadlessWx, createHeadlessWxState, createHostRegistries, createPageInstance, createProjectDescriptor, executeSelectorQueryRequests, hasBrowserVirtualFile, launch, loadProject, normalizeBrowserFilePath, normalizeComponentPropertyValue, querySelectorAll, readBrowserVirtualFile, registerAppDefinition, registerComponentDefinition, registerPageDefinition, renderBrowserPageTree, renderPageTree, renderRuntimePageTree, resolveRoutesFromAppConfig, resolveSelectorQueryScopeRoot, runComponentLifecycle, runComponentObservers, runComponentPageLifetime };