@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.
- package/LICENSE +21 -0
- package/dist/index.d.mts +489 -36
- package/dist/index.mjs +1844 -169
- 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/
|
|
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
|
-
|
|
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/
|
|
27
|
-
interface
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
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
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
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
|
|
41
|
-
declare function
|
|
42
|
-
|
|
43
|
-
|
|
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/
|
|
46
|
-
interface
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
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
|
-
|
|
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/
|
|
63
|
-
interface
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
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
|
|
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
|
-
|
|
86
|
-
|
|
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 };
|