@mpcore/simulator 0.0.0 → 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
@@ -1,3 +1,435 @@
1
+ //#region src/host/globals.d.ts
2
+ interface HeadlessAppDefinition extends Record<string, any> {}
3
+ interface HeadlessPageDefinition extends Record<string, any> {}
4
+ interface HeadlessComponentDefinition extends Record<string, any> {}
5
+ interface HeadlessBehaviorDefinition extends Record<string, any> {
6
+ __isHeadlessBehavior__?: boolean;
7
+ }
8
+ interface HeadlessHostLoadContext {
9
+ kind: 'app' | 'page' | 'component';
10
+ route?: string;
11
+ }
12
+ interface HeadlessHostRegistries {
13
+ appDefinition: HeadlessAppDefinition | null;
14
+ components: Map<string, HeadlessComponentDefinition>;
15
+ currentLoadContext: HeadlessHostLoadContext | null;
16
+ pages: Map<string, HeadlessPageDefinition>;
17
+ }
18
+ declare function createHostRegistries(): HeadlessHostRegistries;
19
+ declare function registerAppDefinition(registries: HeadlessHostRegistries, definition: HeadlessAppDefinition): HeadlessAppDefinition;
20
+ declare function registerPageDefinition(registries: HeadlessHostRegistries, definition: HeadlessPageDefinition): HeadlessPageDefinition;
21
+ declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition): HeadlessComponentDefinition;
22
+ //#endregion
23
+ //#region src/host/wx.d.ts
24
+ interface HeadlessWxCallbackOption<TResult = void> {
25
+ complete?: (result?: TResult) => void;
26
+ fail?: (error: Error) => void;
27
+ success?: (result: TResult) => void;
28
+ }
29
+ interface HeadlessWxNavigateOption extends HeadlessWxCallbackOption {
30
+ url: string;
31
+ }
32
+ interface HeadlessWxNavigateBackOption extends HeadlessWxCallbackOption {
33
+ delta?: number;
34
+ }
35
+ interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
36
+ duration?: number;
37
+ scrollTop?: number;
38
+ selector?: string;
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
+ }
201
+ interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
202
+ errMsg: string;
203
+ }> {
204
+ duration?: number;
205
+ icon?: string;
206
+ mask?: boolean;
207
+ title: string;
208
+ }
209
+ interface HeadlessWxShowLoadingOption extends HeadlessWxCallbackOption<{
210
+ errMsg: string;
211
+ }> {
212
+ mask?: boolean;
213
+ title: string;
214
+ }
215
+ interface HeadlessWxRequestSuccessResult {
216
+ cookies: string[];
217
+ data: unknown;
218
+ errMsg: string;
219
+ header: Record<string, string>;
220
+ statusCode: number;
221
+ }
222
+ interface HeadlessWxRequestOption extends HeadlessWxCallbackOption<HeadlessWxRequestSuccessResult> {
223
+ data?: unknown;
224
+ header?: Record<string, string>;
225
+ method?: string;
226
+ url: string;
227
+ }
228
+ interface HeadlessWxRequestTask {
229
+ abort: () => void;
230
+ }
231
+ interface HeadlessWxDriver {
232
+ getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
233
+ clearStorageSync: () => void;
234
+ getEnterOptionsSync: () => HeadlessWxLaunchOptions;
235
+ getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
236
+ getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
237
+ getNetworkType: () => HeadlessWxGetNetworkTypeResult;
238
+ getStorageInfoSync: () => HeadlessWxStorageInfoResult;
239
+ getStorageSync: (key: string) => unknown;
240
+ getSystemInfoSync: () => HeadlessWxSystemInfoResult;
241
+ getWindowInfoSync: () => HeadlessWxWindowInfoResult;
242
+ hideLoading: () => {
243
+ errMsg: string;
244
+ };
245
+ hideToast: () => {
246
+ errMsg: string;
247
+ };
248
+ navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
249
+ navigateTo: (option: HeadlessWxNavigateOption) => unknown;
250
+ nextTick: (callback?: () => void) => void;
251
+ offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
252
+ onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
253
+ pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
254
+ reLaunch: (option: HeadlessWxNavigateOption) => unknown;
255
+ redirectTo: (option: HeadlessWxNavigateOption) => unknown;
256
+ removeStorageSync: (key: string) => void;
257
+ request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
258
+ setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
259
+ errMsg: string;
260
+ };
261
+ setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
262
+ errMsg: string;
263
+ };
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;
300
+ showToast: (option: HeadlessWxShowToastOption) => {
301
+ errMsg: string;
302
+ };
303
+ stopPullDownRefresh: () => void;
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
+ };
314
+ }
315
+ interface HeadlessWx {
316
+ canIUse: (schema: string) => boolean;
317
+ clearStorage: (option?: HeadlessWxClearStorageOption) => HeadlessWxStorageResult | undefined;
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;
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;
336
+ hideToast: () => {
337
+ errMsg: string;
338
+ };
339
+ navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
340
+ navigateTo: (option: HeadlessWxNavigateOption) => unknown;
341
+ nextTick: (callback?: () => void) => void;
342
+ offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
343
+ onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
344
+ pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
345
+ reLaunch: (option: HeadlessWxNavigateOption) => unknown;
346
+ redirectTo: (option: HeadlessWxNavigateOption) => unknown;
347
+ removeStorage: (option: HeadlessWxRemoveStorageOption) => HeadlessWxStorageResult | undefined;
348
+ removeStorageSync: (key: string) => void;
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;
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;
395
+ showToast: (option: HeadlessWxShowToastOption) => {
396
+ errMsg: string;
397
+ } | undefined;
398
+ stopPullDownRefresh: () => void;
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;
409
+ }
410
+ declare function createHeadlessWx(driver: HeadlessWxDriver): HeadlessWx;
411
+ //#endregion
412
+ //#region src/browser/virtualFiles.d.ts
413
+ interface BrowserDirectoryFileLike {
414
+ name: string;
415
+ text: () => Promise<string>;
416
+ webkitRelativePath?: string;
417
+ }
418
+ type BrowserVirtualFiles = Map<string, string>;
419
+ declare function normalizeBrowserFilePath(filePath: string): string;
420
+ declare function createBrowserVirtualFiles(entries: Iterable<[string, string]>): BrowserVirtualFiles;
421
+ declare function createBrowserVirtualFilesFromDirectory(files: BrowserDirectoryFileLike[]): Promise<BrowserVirtualFiles>;
422
+ declare function readBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): string | undefined;
423
+ declare function hasBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): boolean;
424
+ //#endregion
425
+ //#region src/browser/moduleLoader.d.ts
426
+ interface BrowserModuleLoader {
427
+ executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
428
+ executeAppModule: (filePath: string) => HeadlessAppDefinition;
429
+ executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
430
+ }
431
+ declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0]): BrowserModuleLoader;
432
+ //#endregion
1
433
  //#region src/project/resolveRoutes.d.ts
2
434
  interface HeadlessRouteRecord {
3
435
  kind: 'page';
@@ -7,7 +439,7 @@ interface HeadlessRouteRecord {
7
439
  }
8
440
  declare function resolveRoutesFromAppConfig(config: Record<string, any>): HeadlessRouteRecord[];
9
441
  //#endregion
10
- //#region src/project/loadProject.d.ts
442
+ //#region src/project/createProjectDescriptor.d.ts
11
443
  interface HeadlessProjectConfigFile {
12
444
  filePath: string;
13
445
  value: Record<string, any>;
@@ -21,37 +453,135 @@ interface HeadlessProjectDescriptor {
21
453
  projectConfigFiles: HeadlessProjectConfigFile[];
22
454
  routes: HeadlessRouteRecord[];
23
455
  }
24
- declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
456
+ interface CreateProjectDescriptorOptions {
457
+ appConfig: Record<string, any>;
458
+ appConfigPath: string;
459
+ miniprogramRoot: string;
460
+ miniprogramRootPath: string;
461
+ projectPath: string;
462
+ projectConfigFiles?: HeadlessProjectConfigFile[];
463
+ }
464
+ declare function createProjectDescriptor(options: CreateProjectDescriptorOptions): HeadlessProjectDescriptor;
25
465
  //#endregion
26
- //#region src/host/globals.d.ts
27
- interface HeadlessAppDefinition extends Record<string, any> {}
28
- interface HeadlessPageDefinition extends Record<string, any> {}
29
- interface HeadlessComponentDefinition extends Record<string, any> {}
30
- interface HeadlessHostLoadContext {
31
- kind: 'app' | 'page' | 'component';
32
- route?: string;
466
+ //#region src/browser/project.d.ts
467
+ interface CreateBrowserProjectOptions {
468
+ appConfigPath?: string;
469
+ miniprogramRoot?: string;
470
+ miniprogramRootPath?: string;
471
+ projectPath?: string;
33
472
  }
34
- interface HeadlessHostRegistries {
35
- appDefinition: HeadlessAppDefinition | null;
36
- components: Map<string, HeadlessComponentDefinition>;
37
- currentLoadContext: HeadlessHostLoadContext | null;
38
- pages: Map<string, HeadlessPageDefinition>;
473
+ declare function createBrowserProject(files: BrowserVirtualFiles, options?: CreateBrowserProjectOptions): HeadlessProjectDescriptor;
474
+ //#endregion
475
+ //#region src/runtime/componentInstance.d.ts
476
+ interface HeadlessComponentInstance extends Record<string, any> {
477
+ __definition__?: HeadlessComponentDefinition;
478
+ __lastInteractionEvent__?: Record<string, any>;
479
+ __propertySnapshots__?: Record<string, any>;
480
+ __ready__?: boolean;
481
+ data: Record<string, any>;
482
+ properties: Record<string, any>;
483
+ selectAllComponents?: (selector: string) => any[];
484
+ selectComponent?: (selector: string) => any;
485
+ selectOwnerComponent?: () => any;
486
+ setData: (patch: Record<string, any>, callback?: () => void) => void;
487
+ triggerEvent: (eventName: string, detail?: unknown, options?: Record<string, any>) => void;
39
488
  }
40
- declare function createHostRegistries(): HeadlessHostRegistries;
41
- declare function registerAppDefinition(registries: HeadlessHostRegistries, definition: HeadlessAppDefinition): HeadlessAppDefinition;
42
- declare function registerPageDefinition(registries: HeadlessHostRegistries, definition: HeadlessPageDefinition): HeadlessPageDefinition;
43
- declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition): HeadlessComponentDefinition;
489
+ declare function cloneValue<T>(value: T): T;
490
+ declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
491
+ interface CreateComponentInstanceOptions {
492
+ definition: HeadlessComponentDefinition;
493
+ properties?: Record<string, any>;
494
+ triggerEvent?: (instance: HeadlessComponentInstance, eventName: string, detail?: unknown, options?: Record<string, any>) => void;
495
+ }
496
+ declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
497
+ declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): unknown;
498
+ declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
499
+ declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
500
+ declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
44
501
  //#endregion
45
- //#region src/host/wx.d.ts
46
- interface HeadlessWx {
47
- navigateBack: () => never;
48
- navigateTo: () => never;
49
- pageScrollTo: () => never;
50
- reLaunch: () => never;
51
- redirectTo: () => never;
52
- switchTab: () => never;
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
521
+ //#region src/runtime/pageInstance.d.ts
522
+ interface HeadlessPageInstance extends Record<string, any> {
523
+ __background__?: HeadlessBackgroundSnapshot;
524
+ __backgroundTextStyle__?: HeadlessBackgroundTextStyle;
525
+ __lastChangedKeys__?: string[];
526
+ __navigationBar__?: HeadlessNavigationBarSnapshot;
527
+ __navigationBarTitle__?: string;
528
+ __route__: string;
529
+ data: Record<string, any>;
530
+ options: Record<string, string>;
531
+ route: string;
532
+ selectAllComponents?: (selector: string) => any[];
533
+ selectComponent?: (selector: string) => any;
534
+ setData: (patch: Record<string, any>, callback?: () => void) => void;
535
+ }
536
+ declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>, pageState?: {
537
+ background?: HeadlessBackgroundSnapshot;
538
+ backgroundTextStyle?: HeadlessBackgroundTextStyle;
539
+ navigationBar?: HeadlessNavigationBarSnapshot;
540
+ }): HeadlessPageInstance;
541
+ //#endregion
542
+ //#region src/browser/render.d.ts
543
+ interface DomNodeLike$3 {
544
+ attribs?: Record<string, string>;
545
+ children?: DomNodeLike$3[];
546
+ data?: string;
547
+ name?: string;
548
+ parent?: DomNodeLike$3 | null;
549
+ type?: string;
550
+ }
551
+ interface BrowserRenderScope {
552
+ alias?: string;
553
+ classList?: string[];
554
+ data: Record<string, any>;
555
+ dataset?: Record<string, string>;
556
+ eventBindings?: Map<string, {
557
+ method: string;
558
+ stopAfter: boolean;
559
+ }>;
560
+ getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
561
+ getScopeId: () => string;
562
+ hostId?: string;
563
+ listenerScopeId?: string;
564
+ id?: string;
565
+ ownerScopeId?: string;
53
566
  }
54
- declare function createHeadlessWx(): HeadlessWx;
567
+ interface BrowserRenderedPageTree {
568
+ root: DomNodeLike$3;
569
+ wxml: string;
570
+ }
571
+ interface BrowserRendererContext {
572
+ changedPageKeys: string[];
573
+ componentCache: Map<string, HeadlessComponentInstance>;
574
+ componentScopes: Map<string, BrowserRenderScope>;
575
+ files: BrowserVirtualFiles;
576
+ moduleLoader: BrowserModuleLoader;
577
+ project: HeadlessProjectDescriptor;
578
+ session: {
579
+ selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
580
+ selectComponentWithin: (scopeId: string, selector: string) => any;
581
+ selectOwnerComponent: (scopeId: string) => any;
582
+ };
583
+ }
584
+ declare function renderBrowserPageTree(context: BrowserRendererContext, page: HeadlessPageInstance): BrowserRenderedPageTree;
55
585
  //#endregion
56
586
  //#region src/runtime/appInstance.d.ts
57
587
  interface HeadlessAppInstance extends Record<string, any> {
@@ -59,13 +589,456 @@ interface HeadlessAppInstance extends Record<string, any> {
59
589
  }
60
590
  declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
61
591
  //#endregion
62
- //#region src/runtime/pageInstance.d.ts
63
- interface HeadlessPageInstance extends Record<string, any> {
64
- data: Record<string, any>;
65
- route: string;
66
- setData: (patch: Record<string, any>) => void;
592
+ //#region src/runtime/wxState.d.ts
593
+ interface HeadlessWxLoadingSnapshot {
594
+ mask: boolean;
595
+ title: string;
596
+ }
597
+ interface HeadlessWxToastSnapshot {
598
+ duration: number;
599
+ icon: string;
600
+ mask: boolean;
601
+ title: string;
602
+ }
603
+ interface HeadlessWxNetworkSnapshot extends HeadlessWxNetworkStatusChangeResult {}
604
+ interface HeadlessWxShareMenuSnapshot {
605
+ isUpdatableMessage: boolean;
606
+ menus: string[];
607
+ visible: boolean;
608
+ withShareTicket: boolean;
67
609
  }
68
- declare function createPageInstance(route: string, definition: HeadlessPageDefinition): HeadlessPageInstance;
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
+ }
632
+ interface HeadlessWxRequestMockDefinition {
633
+ delay?: number;
634
+ header?: Record<string, string>;
635
+ method?: string;
636
+ response: unknown | ((option: HeadlessWxRequestOption) => unknown);
637
+ statusCode?: number;
638
+ url: RegExp | string;
639
+ }
640
+ interface HeadlessWxRequestLogEntry {
641
+ data: unknown;
642
+ header: Record<string, string>;
643
+ matched: boolean;
644
+ method: string;
645
+ response?: HeadlessWxRequestSuccessResult;
646
+ url: string;
647
+ }
648
+ declare function createHeadlessWxState(): {
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
+ }[];
672
+ getRequestLogs(): {
673
+ data: unknown;
674
+ header: {
675
+ [x: string]: string;
676
+ };
677
+ response: {
678
+ cookies: string[];
679
+ data: unknown;
680
+ header: {
681
+ [x: string]: string;
682
+ };
683
+ errMsg: string;
684
+ statusCode: number;
685
+ } | undefined;
686
+ matched: boolean;
687
+ method: string;
688
+ url: string;
689
+ }[];
690
+ getStorageInfoSync(): {
691
+ currentSize: number;
692
+ errMsg: string;
693
+ keys: string[];
694
+ limitSize: number;
695
+ };
696
+ getStorageSnapshot(): {
697
+ [k: string]: unknown;
698
+ };
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
+ };
713
+ getToast(): {
714
+ duration: number;
715
+ icon: string;
716
+ mask: boolean;
717
+ title: string;
718
+ } | null;
719
+ hideLoading(): {
720
+ errMsg: string;
721
+ };
722
+ hideToast(): {
723
+ errMsg: string;
724
+ };
725
+ offNetworkStatusChange(callback?: HeadlessWxNetworkStatusChangeCallback): void;
726
+ mockRequest(definition: HeadlessWxRequestMockDefinition): void;
727
+ mockModal(definition?: HeadlessWxModalMockDefinition): void;
728
+ mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
729
+ onNetworkStatusChange(callback: HeadlessWxNetworkStatusChangeCallback): void;
730
+ removeStorageSync(key: string): void;
731
+ request(option: HeadlessWxRequestOption): HeadlessWxRequestTask;
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;
745
+ showToast(option: HeadlessWxShowToastOption): {
746
+ errMsg: string;
747
+ };
748
+ updateShareMenu(option?: HeadlessWxShareMenuOption): {
749
+ errMsg: string;
750
+ };
751
+ };
752
+ //#endregion
753
+ //#region src/browser/session.d.ts
754
+ interface BrowserHeadlessSessionOptions {
755
+ files: BrowserVirtualFiles;
756
+ project?: HeadlessProjectDescriptor;
757
+ }
758
+ declare class BrowserHeadlessSession {
759
+ readonly files: BrowserVirtualFiles;
760
+ readonly project: HeadlessProjectDescriptor;
761
+ private appDefinition;
762
+ private appInstance;
763
+ private readonly moduleLoader;
764
+ private readonly registries;
765
+ private currentPageInstance;
766
+ private readonly pages;
767
+ private readonly componentCache;
768
+ private readonly componentScopes;
769
+ private readonly tabBarRoutes;
770
+ private readonly tabPages;
771
+ private readonly tabBarItems;
772
+ private readonly tabBarState;
773
+ private tabBarVisible;
774
+ private readonly systemInfo;
775
+ private enterOptions;
776
+ private launchOptions;
777
+ private readonly wxState;
778
+ constructor(options: BrowserHeadlessSessionOptions);
779
+ getApp(): HeadlessAppInstance | null;
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
+ }[];
805
+ getRequestLogs(): {
806
+ data: unknown;
807
+ header: {
808
+ [x: string]: string;
809
+ };
810
+ response: {
811
+ cookies: string[];
812
+ data: unknown;
813
+ header: {
814
+ [x: string]: string;
815
+ };
816
+ errMsg: string;
817
+ statusCode: number;
818
+ } | undefined;
819
+ matched: boolean;
820
+ method: string;
821
+ url: string;
822
+ }[];
823
+ getStorageSnapshot(): {
824
+ [k: string]: unknown;
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
+ }[];
913
+ getToast(): {
914
+ duration: number;
915
+ icon: string;
916
+ mask: boolean;
917
+ title: string;
918
+ } | null;
919
+ mockModal(definition?: HeadlessWxModalMockDefinition): void;
920
+ mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
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
+ };
973
+ getScopeSnapshot(scopeId: string): {
974
+ data: any;
975
+ methods: string[];
976
+ properties: any;
977
+ scopeId: string;
978
+ type: "component";
979
+ } | {
980
+ data: Record<string, any>;
981
+ methods: string[];
982
+ properties: Record<string, string>;
983
+ scopeId: string;
984
+ type: "page";
985
+ } | {
986
+ data: any;
987
+ methods: string[];
988
+ properties: {};
989
+ scopeId: string;
990
+ type: "scope";
991
+ } | null;
992
+ selectComponent(selector: string): any;
993
+ selectAllComponents(selector: string): any[];
994
+ selectComponentWithin(scopeId: string, selector: string): any;
995
+ selectAllComponentsWithin(scopeId: string, selector: string): any[];
996
+ selectOwnerComponent(scopeId: string): any;
997
+ private selectComponentsWithin;
998
+ renderCurrentPage(): BrowserRenderedPageTree;
999
+ callTapBinding(scopeId: string, methodName: string): any;
1000
+ callTapBindingWithEvent(scopeId: string, methodName: string, event?: {
1001
+ currentTarget?: {
1002
+ dataset?: Record<string, string>;
1003
+ id?: string;
1004
+ };
1005
+ dataset?: Record<string, string>;
1006
+ id?: string;
1007
+ target?: {
1008
+ dataset?: Record<string, string>;
1009
+ id?: string;
1010
+ };
1011
+ }): any;
1012
+ bootstrap(launchOptions?: HeadlessWxLaunchOptions): HeadlessAppInstance;
1013
+ reLaunch(url: string): HeadlessPageInstance;
1014
+ navigateTo(url: string): HeadlessPageInstance;
1015
+ redirectTo(url: string): HeadlessPageInstance;
1016
+ navigateBack(delta?: number): HeadlessPageInstance | null;
1017
+ switchTab(url: string): HeadlessPageInstance;
1018
+ pageScrollTo(option: {
1019
+ scrollTop?: number;
1020
+ }): void;
1021
+ triggerPullDownRefresh(): HeadlessPageInstance;
1022
+ triggerReachBottom(): HeadlessPageInstance;
1023
+ triggerResize(options: Record<string, any>): HeadlessPageInstance;
1024
+ triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
1025
+ stopPullDownRefresh(): void;
1026
+ private createFreshPage;
1027
+ private isTabBarRoute;
1028
+ private removePageInstance;
1029
+ private resolveNavigationTarget;
1030
+ private resolveTabBarItem;
1031
+ private requireTabBarItem;
1032
+ private unloadAllPages;
1033
+ private unloadPage;
1034
+ private requireCurrentPage;
1035
+ private detachPageComponents;
1036
+ private runPageComponentLifetime;
1037
+ }
1038
+ declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
1039
+ //#endregion
1040
+ //#region src/project/loadProject.d.ts
1041
+ declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
69
1042
  //#endregion
70
1043
  //#region src/runtime/session.d.ts
71
1044
  interface HeadlessSessionOptions {
@@ -79,11 +1052,238 @@ declare class HeadlessSession {
79
1052
  private readonly registries;
80
1053
  private currentPageInstance;
81
1054
  private readonly pages;
1055
+ private readonly tabBarRoutes;
1056
+ private readonly tabPages;
1057
+ private readonly tabBarItems;
1058
+ private readonly tabBarState;
1059
+ private tabBarVisible;
1060
+ private readonly systemInfo;
1061
+ private enterOptions;
1062
+ private launchOptions;
1063
+ private readonly wxState;
82
1064
  constructor(options: HeadlessSessionOptions);
83
1065
  getApp(): HeadlessAppInstance | null;
84
1066
  getCurrentPages(): HeadlessPageInstance[];
85
- bootstrap(): HeadlessAppInstance;
86
- reLaunch(route: string): 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
+ }[];
1091
+ getRequestLogs(): {
1092
+ data: unknown;
1093
+ header: {
1094
+ [x: string]: string;
1095
+ };
1096
+ response: {
1097
+ cookies: string[];
1098
+ data: unknown;
1099
+ header: {
1100
+ [x: string]: string;
1101
+ };
1102
+ errMsg: string;
1103
+ statusCode: number;
1104
+ } | undefined;
1105
+ matched: boolean;
1106
+ method: string;
1107
+ url: string;
1108
+ }[];
1109
+ getStorageSnapshot(): {
1110
+ [k: string]: unknown;
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
+ }[];
1199
+ getToast(): {
1200
+ duration: number;
1201
+ icon: string;
1202
+ mask: boolean;
1203
+ title: string;
1204
+ } | null;
1205
+ mockModal(definition?: HeadlessWxModalMockDefinition): void;
1206
+ mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
1207
+ mockRequest(definition: HeadlessWxRequestMockDefinition): void;
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;
1260
+ reLaunch(url: string): HeadlessPageInstance;
1261
+ navigateTo(url: string): HeadlessPageInstance;
1262
+ redirectTo(url: string): HeadlessPageInstance;
1263
+ navigateBack(delta?: number): HeadlessPageInstance | null;
1264
+ switchTab(url: string): HeadlessPageInstance;
1265
+ pageScrollTo(option: {
1266
+ scrollTop?: number;
1267
+ duration?: number;
1268
+ selector?: string;
1269
+ success?: () => void;
1270
+ fail?: (error: Error) => void;
1271
+ complete?: () => void;
1272
+ }): void;
1273
+ triggerPullDownRefresh(): HeadlessPageInstance;
1274
+ triggerReachBottom(): HeadlessPageInstance;
1275
+ triggerResize(options: Record<string, any>): HeadlessPageInstance;
1276
+ triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
1277
+ stopPullDownRefresh(): void;
1278
+ private createFreshPage;
1279
+ private isTabBarRoute;
1280
+ private resolveTabBarItem;
1281
+ private requireTabBarItem;
1282
+ private removePageInstance;
1283
+ private resolveNavigationTarget;
1284
+ private unloadAllPages;
1285
+ private unloadPage;
1286
+ private requireCurrentPage;
87
1287
  }
88
1288
  declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
89
1289
  //#endregion
@@ -96,14 +1296,43 @@ interface DomNodeLike$2 {
96
1296
  parent?: DomNodeLike$2 | null;
97
1297
  type?: string;
98
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
+ }
99
1322
  declare class HeadlessTestingNodeHandle {
100
1323
  private readonly node;
101
- constructor(node: DomNodeLike$2);
1324
+ private readonly interactions?;
1325
+ constructor(node: DomNodeLike$2, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
102
1326
  $(selector: string): Promise<HeadlessTestingNodeHandle | null>;
103
1327
  $$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
104
1328
  attr(name: string): Promise<string | undefined>;
105
- dataset(): Promise<Record<string, any>>;
1329
+ dataset(): Promise<Record<string, string>>;
106
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>;
107
1336
  wxml(): Promise<string>;
108
1337
  }
109
1338
  //#endregion
@@ -134,15 +1363,29 @@ interface DomNodeLike {
134
1363
  declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
135
1364
  //#endregion
136
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
+ }
137
1374
  declare class HeadlessTestingPageHandle {
138
1375
  private readonly project;
139
1376
  private readonly page;
140
1377
  constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance);
1378
+ private resolveDataByPath;
1379
+ private pollUntil;
141
1380
  callMethod(methodName: string, ...args: any[]): Promise<any>;
142
1381
  data(path?: string): Promise<any>;
143
1382
  waitFor(ms?: number): Promise<void>;
144
1383
  $(selector: string): Promise<HeadlessTestingNodeHandle | null>;
145
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>;
146
1389
  wxml(): Promise<string>;
147
1390
  }
148
1391
  //#endregion
@@ -151,10 +1394,18 @@ declare class HeadlessTestingSessionHandle {
151
1394
  private readonly project;
152
1395
  private readonly session;
153
1396
  constructor(project: HeadlessProjectDescriptor, session: HeadlessSession);
1397
+ private waitFor;
1398
+ private pollUntil;
154
1399
  close(): Promise<void>;
155
1400
  currentPage(): Promise<HeadlessTestingPageHandle | null>;
156
1401
  getCurrentPages(): Promise<HeadlessTestingPageHandle[]>;
157
1402
  reLaunch(route: string): Promise<HeadlessTestingPageHandle>;
1403
+ waitForCurrentPage(route?: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingPageHandle>;
1404
+ pageScrollTo(scrollTop: number): Promise<void>;
1405
+ triggerPullDownRefresh(): Promise<void>;
1406
+ triggerReachBottom(): Promise<void>;
1407
+ triggerResize(options: Record<string, any>): Promise<void>;
1408
+ triggerRouteDone(options?: Record<string, any>): Promise<void>;
158
1409
  }
159
1410
  //#endregion
160
1411
  //#region src/testing/launch.d.ts
@@ -163,4 +1414,4 @@ interface HeadlessTestingLaunchOptions {
163
1414
  }
164
1415
  declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
165
1416
  //#endregion
166
- export { HeadlessAppDefinition, HeadlessAppInstance, HeadlessComponentDefinition, HeadlessHostLoadContext, HeadlessHostRegistries, HeadlessPageDefinition, HeadlessPageInstance, HeadlessProjectConfigFile, HeadlessProjectDescriptor, HeadlessRouteRecord, HeadlessSession, HeadlessSessionOptions, HeadlessTestingLaunchOptions, HeadlessTestingNodeHandle, HeadlessTestingPageHandle, HeadlessTestingSessionHandle, HeadlessWx, RenderedPageTree, createAppInstance, createHeadlessSession, createHeadlessWx, createHostRegistries, createPageInstance, launch, loadProject, querySelectorAll, registerAppDefinition, registerComponentDefinition, registerPageDefinition, renderPageTree, resolveRoutesFromAppConfig };
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 };