@mpcore/simulator 0.0.0 → 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/LICENSE +21 -0
  2. package/dist/index.d.mts +489 -36
  3. package/dist/index.mjs +1844 -169
  4. package/package.json +10 -10
package/LICENSE ADDED
@@ -0,0 +1,21 @@
1
+ MIT License
2
+
3
+ Copyright (c) 2024 ice breaker
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
package/dist/index.d.mts CHANGED
@@ -1,3 +1,129 @@
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 HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
41
+ errMsg: string;
42
+ }> {
43
+ duration?: number;
44
+ icon?: string;
45
+ mask?: boolean;
46
+ title: string;
47
+ }
48
+ interface HeadlessWxRequestSuccessResult {
49
+ cookies: string[];
50
+ data: unknown;
51
+ errMsg: string;
52
+ header: Record<string, string>;
53
+ statusCode: number;
54
+ }
55
+ interface HeadlessWxRequestOption extends HeadlessWxCallbackOption<HeadlessWxRequestSuccessResult> {
56
+ data?: unknown;
57
+ header?: Record<string, string>;
58
+ method?: string;
59
+ url: string;
60
+ }
61
+ interface HeadlessWxRequestTask {
62
+ abort: () => void;
63
+ }
64
+ interface HeadlessWxDriver {
65
+ clearStorageSync: () => void;
66
+ getStorageSync: (key: string) => unknown;
67
+ hideToast: () => {
68
+ errMsg: string;
69
+ };
70
+ navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
71
+ navigateTo: (option: HeadlessWxNavigateOption) => unknown;
72
+ pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
73
+ reLaunch: (option: HeadlessWxNavigateOption) => unknown;
74
+ redirectTo: (option: HeadlessWxNavigateOption) => unknown;
75
+ removeStorageSync: (key: string) => void;
76
+ request: (option: HeadlessWxRequestOption) => HeadlessWxRequestSuccessResult;
77
+ setStorageSync: (key: string, value: unknown) => void;
78
+ showToast: (option: HeadlessWxShowToastOption) => {
79
+ errMsg: string;
80
+ };
81
+ stopPullDownRefresh: () => void;
82
+ switchTab: (option: HeadlessWxNavigateOption) => unknown;
83
+ }
84
+ interface HeadlessWx {
85
+ clearStorageSync: () => void;
86
+ getStorageSync: (key: string) => unknown;
87
+ hideToast: () => {
88
+ errMsg: string;
89
+ };
90
+ navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
91
+ navigateTo: (option: HeadlessWxNavigateOption) => unknown;
92
+ pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
93
+ reLaunch: (option: HeadlessWxNavigateOption) => unknown;
94
+ redirectTo: (option: HeadlessWxNavigateOption) => unknown;
95
+ removeStorageSync: (key: string) => void;
96
+ request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
97
+ setStorageSync: (key: string, value: unknown) => void;
98
+ showToast: (option: HeadlessWxShowToastOption) => {
99
+ errMsg: string;
100
+ } | undefined;
101
+ stopPullDownRefresh: () => void;
102
+ switchTab: (option: HeadlessWxNavigateOption) => unknown;
103
+ }
104
+ declare function createHeadlessWx(driver: HeadlessWxDriver): HeadlessWx;
105
+ //#endregion
106
+ //#region src/browser/virtualFiles.d.ts
107
+ interface BrowserDirectoryFileLike {
108
+ name: string;
109
+ text: () => Promise<string>;
110
+ webkitRelativePath?: string;
111
+ }
112
+ type BrowserVirtualFiles = Map<string, string>;
113
+ declare function normalizeBrowserFilePath(filePath: string): string;
114
+ declare function createBrowserVirtualFiles(entries: Iterable<[string, string]>): BrowserVirtualFiles;
115
+ declare function createBrowserVirtualFilesFromDirectory(files: BrowserDirectoryFileLike[]): Promise<BrowserVirtualFiles>;
116
+ declare function readBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): string | undefined;
117
+ declare function hasBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): boolean;
118
+ //#endregion
119
+ //#region src/browser/moduleLoader.d.ts
120
+ interface BrowserModuleLoader {
121
+ executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
122
+ executeAppModule: (filePath: string) => HeadlessAppDefinition;
123
+ executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
124
+ }
125
+ declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0]): BrowserModuleLoader;
126
+ //#endregion
1
127
  //#region src/project/resolveRoutes.d.ts
2
128
  interface HeadlessRouteRecord {
3
129
  kind: 'page';
@@ -7,7 +133,7 @@ interface HeadlessRouteRecord {
7
133
  }
8
134
  declare function resolveRoutesFromAppConfig(config: Record<string, any>): HeadlessRouteRecord[];
9
135
  //#endregion
10
- //#region src/project/loadProject.d.ts
136
+ //#region src/project/createProjectDescriptor.d.ts
11
137
  interface HeadlessProjectConfigFile {
12
138
  filePath: string;
13
139
  value: Record<string, any>;
@@ -21,37 +147,108 @@ interface HeadlessProjectDescriptor {
21
147
  projectConfigFiles: HeadlessProjectConfigFile[];
22
148
  routes: HeadlessRouteRecord[];
23
149
  }
24
- declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
150
+ interface CreateProjectDescriptorOptions {
151
+ appConfig: Record<string, any>;
152
+ appConfigPath: string;
153
+ miniprogramRoot: string;
154
+ miniprogramRootPath: string;
155
+ projectPath: string;
156
+ projectConfigFiles?: HeadlessProjectConfigFile[];
157
+ }
158
+ declare function createProjectDescriptor(options: CreateProjectDescriptorOptions): HeadlessProjectDescriptor;
25
159
  //#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;
160
+ //#region src/browser/project.d.ts
161
+ interface CreateBrowserProjectOptions {
162
+ appConfigPath?: string;
163
+ miniprogramRoot?: string;
164
+ miniprogramRootPath?: string;
165
+ projectPath?: string;
33
166
  }
34
- interface HeadlessHostRegistries {
35
- appDefinition: HeadlessAppDefinition | null;
36
- components: Map<string, HeadlessComponentDefinition>;
37
- currentLoadContext: HeadlessHostLoadContext | null;
38
- pages: Map<string, HeadlessPageDefinition>;
167
+ declare function createBrowserProject(files: BrowserVirtualFiles, options?: CreateBrowserProjectOptions): HeadlessProjectDescriptor;
168
+ //#endregion
169
+ //#region src/runtime/componentInstance.d.ts
170
+ interface HeadlessComponentInstance extends Record<string, any> {
171
+ __definition__?: HeadlessComponentDefinition;
172
+ __lastInteractionEvent__?: Record<string, any>;
173
+ __propertySnapshots__?: Record<string, any>;
174
+ __ready__?: boolean;
175
+ data: Record<string, any>;
176
+ properties: Record<string, any>;
177
+ selectAllComponents?: (selector: string) => any[];
178
+ selectComponent?: (selector: string) => any;
179
+ selectOwnerComponent?: () => any;
180
+ setData: (patch: Record<string, any>, callback?: () => void) => void;
181
+ triggerEvent: (eventName: string, detail?: unknown, options?: Record<string, any>) => void;
39
182
  }
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;
183
+ declare function cloneValue<T>(value: T): T;
184
+ declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
185
+ interface CreateComponentInstanceOptions {
186
+ definition: HeadlessComponentDefinition;
187
+ properties?: Record<string, any>;
188
+ triggerEvent?: (instance: HeadlessComponentInstance, eventName: string, detail?: unknown, options?: Record<string, any>) => void;
189
+ }
190
+ declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
191
+ declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): unknown;
192
+ declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
193
+ declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
194
+ declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
44
195
  //#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;
196
+ //#region src/runtime/pageInstance.d.ts
197
+ interface HeadlessPageInstance extends Record<string, any> {
198
+ __lastChangedKeys__?: string[];
199
+ __route__: string;
200
+ data: Record<string, any>;
201
+ options: Record<string, string>;
202
+ route: string;
203
+ selectAllComponents?: (selector: string) => any[];
204
+ selectComponent?: (selector: string) => any;
205
+ setData: (patch: Record<string, any>, callback?: () => void) => void;
206
+ }
207
+ declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>): HeadlessPageInstance;
208
+ //#endregion
209
+ //#region src/browser/render.d.ts
210
+ interface DomNodeLike$3 {
211
+ attribs?: Record<string, string>;
212
+ children?: DomNodeLike$3[];
213
+ data?: string;
214
+ name?: string;
215
+ parent?: DomNodeLike$3 | null;
216
+ type?: string;
217
+ }
218
+ interface BrowserRenderScope {
219
+ alias?: string;
220
+ classList?: string[];
221
+ data: Record<string, any>;
222
+ dataset?: Record<string, string>;
223
+ eventBindings?: Map<string, {
224
+ method: string;
225
+ stopAfter: boolean;
226
+ }>;
227
+ getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
228
+ getScopeId: () => string;
229
+ hostId?: string;
230
+ listenerScopeId?: string;
231
+ id?: string;
232
+ ownerScopeId?: string;
53
233
  }
54
- declare function createHeadlessWx(): HeadlessWx;
234
+ interface BrowserRenderedPageTree {
235
+ root: DomNodeLike$3;
236
+ wxml: string;
237
+ }
238
+ interface BrowserRendererContext {
239
+ changedPageKeys: string[];
240
+ componentCache: Map<string, HeadlessComponentInstance>;
241
+ componentScopes: Map<string, BrowserRenderScope>;
242
+ files: BrowserVirtualFiles;
243
+ moduleLoader: BrowserModuleLoader;
244
+ project: HeadlessProjectDescriptor;
245
+ session: {
246
+ selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
247
+ selectComponentWithin: (scopeId: string, selector: string) => any;
248
+ selectOwnerComponent: (scopeId: string) => any;
249
+ };
250
+ }
251
+ declare function renderBrowserPageTree(context: BrowserRendererContext, page: HeadlessPageInstance): BrowserRenderedPageTree;
55
252
  //#endregion
56
253
  //#region src/runtime/appInstance.d.ts
57
254
  interface HeadlessAppInstance extends Record<string, any> {
@@ -59,18 +256,212 @@ interface HeadlessAppInstance extends Record<string, any> {
59
256
  }
60
257
  declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
61
258
  //#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;
259
+ //#region src/runtime/wxState.d.ts
260
+ interface HeadlessWxToastSnapshot {
261
+ duration: number;
262
+ icon: string;
263
+ mask: boolean;
264
+ title: string;
265
+ }
266
+ interface HeadlessWxRequestMockDefinition {
267
+ header?: Record<string, string>;
268
+ method?: string;
269
+ response: unknown | ((option: HeadlessWxRequestOption) => unknown);
270
+ statusCode?: number;
271
+ url: RegExp | string;
272
+ }
273
+ interface HeadlessWxRequestLogEntry {
274
+ data: unknown;
275
+ header: Record<string, string>;
276
+ matched: boolean;
277
+ method: string;
278
+ response?: HeadlessWxRequestSuccessResult;
279
+ url: string;
280
+ }
281
+ declare function createHeadlessWxState(): {
282
+ clearStorageSync(): void;
283
+ getRequestLogs(): {
284
+ data: unknown;
285
+ header: {
286
+ [x: string]: string;
287
+ };
288
+ response: {
289
+ cookies: string[];
290
+ data: unknown;
291
+ header: {
292
+ [x: string]: string;
293
+ };
294
+ errMsg: string;
295
+ statusCode: number;
296
+ } | undefined;
297
+ matched: boolean;
298
+ method: string;
299
+ url: string;
300
+ }[];
301
+ getStorageSnapshot(): {
302
+ [k: string]: unknown;
303
+ };
304
+ getStorageSync(key: string): unknown;
305
+ getToast(): {
306
+ duration: number;
307
+ icon: string;
308
+ mask: boolean;
309
+ title: string;
310
+ } | null;
311
+ hideToast(): {
312
+ errMsg: string;
313
+ };
314
+ mockRequest(definition: HeadlessWxRequestMockDefinition): void;
315
+ removeStorageSync(key: string): void;
316
+ request(option: HeadlessWxRequestOption): HeadlessWxRequestSuccessResult;
317
+ setStorageSync(key: string, value: unknown): void;
318
+ showToast(option: HeadlessWxShowToastOption): {
319
+ errMsg: string;
320
+ };
321
+ };
322
+ //#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;
336
+ }
337
+ declare class BrowserHeadlessSession {
338
+ readonly files: BrowserVirtualFiles;
339
+ readonly project: HeadlessProjectDescriptor;
340
+ private appDefinition;
341
+ private appInstance;
342
+ private readonly moduleLoader;
343
+ private readonly registries;
344
+ private currentPageInstance;
345
+ private readonly pages;
346
+ private readonly componentCache;
347
+ private readonly componentScopes;
348
+ private readonly tabBarRoutes;
349
+ private readonly tabPages;
350
+ private readonly tabBarItems;
351
+ private readonly wxState;
352
+ constructor(options: BrowserHeadlessSessionOptions);
353
+ getApp(): HeadlessAppInstance | null;
354
+ getCurrentPages(): HeadlessPageInstance[];
355
+ getRequestLogs(): {
356
+ data: unknown;
357
+ header: {
358
+ [x: string]: string;
359
+ };
360
+ response: {
361
+ cookies: string[];
362
+ data: unknown;
363
+ header: {
364
+ [x: string]: string;
365
+ };
366
+ errMsg: string;
367
+ statusCode: number;
368
+ } | undefined;
369
+ matched: boolean;
370
+ method: string;
371
+ url: string;
372
+ }[];
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;
383
+ getScopeSnapshot(scopeId: string): {
384
+ data: any;
385
+ methods: string[];
386
+ properties: any;
387
+ scopeId: string;
388
+ type: "component";
389
+ } | {
390
+ data: Record<string, any>;
391
+ methods: string[];
392
+ properties: Record<string, string>;
393
+ scopeId: string;
394
+ type: "page";
395
+ } | {
396
+ data: any;
397
+ methods: string[];
398
+ properties: {};
399
+ scopeId: string;
400
+ type: "scope";
401
+ } | 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;
414
+ };
415
+ dataset?: Record<string, string>;
416
+ id?: string;
417
+ target?: {
418
+ dataset?: Record<string, string>;
419
+ id?: string;
420
+ };
421
+ }): any;
422
+ bootstrap(launchOptions?: HeadlessAppLaunchOptions$1): HeadlessAppInstance;
423
+ reLaunch(url: string): HeadlessPageInstance;
424
+ navigateTo(url: string): HeadlessPageInstance;
425
+ redirectTo(url: string): HeadlessPageInstance;
426
+ navigateBack(delta?: number): HeadlessPageInstance | null;
427
+ switchTab(url: string): HeadlessPageInstance;
428
+ pageScrollTo(option: {
429
+ scrollTop?: number;
430
+ }): void;
431
+ triggerPullDownRefresh(): HeadlessPageInstance;
432
+ triggerReachBottom(): HeadlessPageInstance;
433
+ triggerResize(options: Record<string, any>): HeadlessPageInstance;
434
+ triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
435
+ stopPullDownRefresh(): void;
436
+ private createFreshPage;
437
+ private isTabBarRoute;
438
+ private removePageInstance;
439
+ private resolveNavigationTarget;
440
+ private resolveTabBarItem;
441
+ private unloadAllPages;
442
+ private unloadPage;
443
+ private requireCurrentPage;
444
+ private detachPageComponents;
445
+ private runPageComponentLifetime;
67
446
  }
68
- declare function createPageInstance(route: string, definition: HeadlessPageDefinition): HeadlessPageInstance;
447
+ declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
448
+ //#endregion
449
+ //#region src/project/loadProject.d.ts
450
+ declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
69
451
  //#endregion
70
452
  //#region src/runtime/session.d.ts
71
453
  interface HeadlessSessionOptions {
72
454
  projectPath: string;
73
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;
464
+ }
74
465
  declare class HeadlessSession {
75
466
  readonly project: HeadlessProjectDescriptor;
76
467
  private appDefinition;
@@ -79,11 +470,68 @@ declare class HeadlessSession {
79
470
  private readonly registries;
80
471
  private currentPageInstance;
81
472
  private readonly pages;
473
+ private readonly tabBarRoutes;
474
+ private readonly tabPages;
475
+ private readonly tabBarItems;
476
+ private readonly wxState;
82
477
  constructor(options: HeadlessSessionOptions);
83
478
  getApp(): HeadlessAppInstance | null;
84
479
  getCurrentPages(): HeadlessPageInstance[];
85
- bootstrap(): HeadlessAppInstance;
86
- reLaunch(route: string): HeadlessPageInstance;
480
+ getRequestLogs(): {
481
+ data: unknown;
482
+ header: {
483
+ [x: string]: string;
484
+ };
485
+ response: {
486
+ cookies: string[];
487
+ data: unknown;
488
+ header: {
489
+ [x: string]: string;
490
+ };
491
+ errMsg: string;
492
+ statusCode: number;
493
+ } | undefined;
494
+ matched: boolean;
495
+ method: string;
496
+ url: string;
497
+ }[];
498
+ getStorageSnapshot(): {
499
+ [k: string]: unknown;
500
+ };
501
+ getToast(): {
502
+ duration: number;
503
+ icon: string;
504
+ mask: boolean;
505
+ title: string;
506
+ } | null;
507
+ mockRequest(definition: HeadlessWxRequestMockDefinition): void;
508
+ bootstrap(launchOptions?: HeadlessAppLaunchOptions): HeadlessAppInstance;
509
+ reLaunch(url: string): HeadlessPageInstance;
510
+ navigateTo(url: string): HeadlessPageInstance;
511
+ redirectTo(url: string): HeadlessPageInstance;
512
+ navigateBack(delta?: number): HeadlessPageInstance | null;
513
+ switchTab(url: string): HeadlessPageInstance;
514
+ pageScrollTo(option: {
515
+ scrollTop?: number;
516
+ duration?: number;
517
+ selector?: string;
518
+ success?: () => void;
519
+ fail?: (error: Error) => void;
520
+ complete?: () => void;
521
+ }): void;
522
+ triggerPullDownRefresh(): HeadlessPageInstance;
523
+ triggerReachBottom(): HeadlessPageInstance;
524
+ triggerResize(options: Record<string, any>): HeadlessPageInstance;
525
+ triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
526
+ stopPullDownRefresh(): void;
527
+ private createFreshPage;
528
+ private isTabBarRoute;
529
+ private resolveTabBarItem;
530
+ private removePageInstance;
531
+ private resolveNavigationTarget;
532
+ private unloadAllPages;
533
+ private unloadPage;
534
+ private requireCurrentPage;
87
535
  }
88
536
  declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
89
537
  //#endregion
@@ -155,6 +603,11 @@ declare class HeadlessTestingSessionHandle {
155
603
  currentPage(): Promise<HeadlessTestingPageHandle | null>;
156
604
  getCurrentPages(): Promise<HeadlessTestingPageHandle[]>;
157
605
  reLaunch(route: string): Promise<HeadlessTestingPageHandle>;
606
+ pageScrollTo(scrollTop: number): Promise<void>;
607
+ triggerPullDownRefresh(): Promise<void>;
608
+ triggerReachBottom(): Promise<void>;
609
+ triggerResize(options: Record<string, any>): Promise<void>;
610
+ triggerRouteDone(options?: Record<string, any>): Promise<void>;
158
611
  }
159
612
  //#endregion
160
613
  //#region src/testing/launch.d.ts
@@ -163,4 +616,4 @@ interface HeadlessTestingLaunchOptions {
163
616
  }
164
617
  declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
165
618
  //#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 };
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 };