@mpcore/simulator 0.4.2 → 0.5.0
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/README.md +9 -0
- package/dist/index.d.mts +385 -348
- package/dist/index.mjs +1326 -468
- package/package.json +8 -4
package/dist/index.d.mts
CHANGED
|
@@ -1,56 +1,56 @@
|
|
|
1
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> {
|
|
2
|
+
export interface HeadlessAppDefinition extends Record<string, any> {}
|
|
3
|
+
export interface HeadlessPageDefinition extends Record<string, any> {}
|
|
4
|
+
export interface HeadlessComponentDefinition extends Record<string, any> {}
|
|
5
|
+
export interface HeadlessBehaviorDefinition extends Record<string, any> {
|
|
6
6
|
__isHeadlessBehavior__?: boolean;
|
|
7
7
|
}
|
|
8
|
-
interface HeadlessHostLoadContext {
|
|
8
|
+
export interface HeadlessHostLoadContext {
|
|
9
9
|
kind: 'app' | 'page' | 'component';
|
|
10
10
|
componentDefinitions?: HeadlessComponentDefinition[];
|
|
11
11
|
route?: string;
|
|
12
12
|
}
|
|
13
|
-
interface HeadlessHostRegistries {
|
|
13
|
+
export interface HeadlessHostRegistries {
|
|
14
14
|
appDefinition: HeadlessAppDefinition | null;
|
|
15
15
|
components: Map<string, HeadlessComponentDefinition>;
|
|
16
16
|
currentLoadContext: HeadlessHostLoadContext | null;
|
|
17
17
|
pages: Map<string, HeadlessPageDefinition>;
|
|
18
18
|
}
|
|
19
|
-
declare function normalizeComponentPageDefinition(definition: HeadlessComponentDefinition): HeadlessPageDefinition;
|
|
20
|
-
declare function createHostRegistries(): HeadlessHostRegistries;
|
|
21
|
-
declare function registerAppDefinition(registries: HeadlessHostRegistries, definition: HeadlessAppDefinition): HeadlessAppDefinition;
|
|
22
|
-
declare function registerPageDefinition(registries: HeadlessHostRegistries, definition: HeadlessPageDefinition, explicitRoute?: string): HeadlessPageDefinition;
|
|
23
|
-
declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition): HeadlessPageDefinition;
|
|
24
|
-
declare function registerExportedComponentDefinition(registries: HeadlessHostRegistries, id: string, moduleExports: Record<string, any>, registeredDefinition?: HeadlessComponentDefinition): HeadlessComponentDefinition | null;
|
|
19
|
+
export declare function normalizeComponentPageDefinition(definition: HeadlessComponentDefinition): HeadlessPageDefinition;
|
|
20
|
+
export declare function createHostRegistries(): HeadlessHostRegistries;
|
|
21
|
+
export declare function registerAppDefinition(registries: HeadlessHostRegistries, definition: HeadlessAppDefinition): HeadlessAppDefinition;
|
|
22
|
+
export declare function registerPageDefinition(registries: HeadlessHostRegistries, definition: HeadlessPageDefinition, explicitRoute?: string): HeadlessPageDefinition;
|
|
23
|
+
export declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition): HeadlessPageDefinition;
|
|
24
|
+
export declare function registerExportedComponentDefinition(registries: HeadlessHostRegistries, id: string, moduleExports: Record<string, any>, registeredDefinition?: HeadlessComponentDefinition): HeadlessComponentDefinition | null;
|
|
25
25
|
//#endregion
|
|
26
26
|
//#region src/host/wx/core.d.ts
|
|
27
|
-
interface HeadlessWxCallbackOption<TResult = void> {
|
|
27
|
+
export interface HeadlessWxCallbackOption<TResult = void> {
|
|
28
28
|
complete?: (result?: TResult) => void;
|
|
29
29
|
fail?: (error: Error) => void;
|
|
30
30
|
success?: (result: TResult) => void;
|
|
31
31
|
}
|
|
32
|
-
interface HeadlessWxLoadFontFaceResult {
|
|
32
|
+
export interface HeadlessWxLoadFontFaceResult {
|
|
33
33
|
errMsg: string;
|
|
34
34
|
}
|
|
35
|
-
interface HeadlessWxLoadFontFaceOption extends HeadlessWxCallbackOption<HeadlessWxLoadFontFaceResult> {
|
|
35
|
+
export interface HeadlessWxLoadFontFaceOption extends HeadlessWxCallbackOption<HeadlessWxLoadFontFaceResult> {
|
|
36
36
|
descriptors?: Record<string, string>;
|
|
37
37
|
family: string;
|
|
38
38
|
global?: boolean;
|
|
39
39
|
scopes?: string[];
|
|
40
40
|
source: string;
|
|
41
41
|
}
|
|
42
|
-
interface HeadlessWxNavigateOption extends HeadlessWxCallbackOption {
|
|
42
|
+
export interface HeadlessWxNavigateOption extends HeadlessWxCallbackOption {
|
|
43
43
|
url: string;
|
|
44
44
|
}
|
|
45
|
-
interface HeadlessWxNavigateBackOption extends HeadlessWxCallbackOption {
|
|
45
|
+
export interface HeadlessWxNavigateBackOption extends HeadlessWxCallbackOption {
|
|
46
46
|
delta?: number;
|
|
47
47
|
}
|
|
48
|
-
interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
|
|
48
|
+
export interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
|
|
49
49
|
duration?: number;
|
|
50
50
|
scrollTop?: number;
|
|
51
51
|
selector?: string;
|
|
52
52
|
}
|
|
53
|
-
interface HeadlessWxVideoContext {
|
|
53
|
+
export interface HeadlessWxVideoContext {
|
|
54
54
|
exitFullScreen: () => void;
|
|
55
55
|
pause: () => void;
|
|
56
56
|
play: () => void;
|
|
@@ -58,23 +58,23 @@ interface HeadlessWxVideoContext {
|
|
|
58
58
|
seek: (position: number) => void;
|
|
59
59
|
stop: () => void;
|
|
60
60
|
}
|
|
61
|
-
interface HeadlessWxAnimationStepOption {
|
|
61
|
+
export interface HeadlessWxAnimationStepOption {
|
|
62
62
|
delay?: number;
|
|
63
63
|
duration?: number;
|
|
64
64
|
timingFunction?: 'ease' | 'ease-in' | 'ease-in-out' | 'ease-out' | 'linear' | 'step-end' | 'step-start';
|
|
65
65
|
transformOrigin?: string;
|
|
66
66
|
}
|
|
67
|
-
interface HeadlessWxAnimationAction {
|
|
67
|
+
export interface HeadlessWxAnimationAction {
|
|
68
68
|
args: unknown[];
|
|
69
69
|
type: string;
|
|
70
70
|
}
|
|
71
|
-
interface HeadlessWxAnimationExportResult {
|
|
71
|
+
export interface HeadlessWxAnimationExportResult {
|
|
72
72
|
actions: Array<{
|
|
73
73
|
animates: HeadlessWxAnimationAction[];
|
|
74
74
|
option: Required<HeadlessWxAnimationStepOption>;
|
|
75
75
|
}>;
|
|
76
76
|
}
|
|
77
|
-
interface HeadlessWxAnimation {
|
|
77
|
+
export interface HeadlessWxAnimation {
|
|
78
78
|
backgroundColor: (value: string) => HeadlessWxAnimation;
|
|
79
79
|
bottom: (value: number | string) => HeadlessWxAnimation;
|
|
80
80
|
export: () => HeadlessWxAnimationExportResult;
|
|
@@ -93,11 +93,11 @@ interface HeadlessWxAnimation {
|
|
|
93
93
|
translateZ: (translation: number) => HeadlessWxAnimation;
|
|
94
94
|
width: (value: number | string) => HeadlessWxAnimation;
|
|
95
95
|
}
|
|
96
|
-
interface HeadlessWxCanvasDrawCall {
|
|
96
|
+
export interface HeadlessWxCanvasDrawCall {
|
|
97
97
|
args: unknown[];
|
|
98
98
|
type: string;
|
|
99
99
|
}
|
|
100
|
-
interface HeadlessWxCanvasSnapshot {
|
|
100
|
+
export interface HeadlessWxCanvasSnapshot {
|
|
101
101
|
canvasId: string;
|
|
102
102
|
drawCalls: HeadlessWxCanvasDrawCall[];
|
|
103
103
|
fillStyle: string;
|
|
@@ -118,7 +118,7 @@ interface HeadlessWxCanvasSnapshot {
|
|
|
118
118
|
textAlign: string;
|
|
119
119
|
textBaseline: string;
|
|
120
120
|
}
|
|
121
|
-
interface HeadlessWxCanvasContext {
|
|
121
|
+
export interface HeadlessWxCanvasContext {
|
|
122
122
|
__getSnapshot: () => HeadlessWxCanvasSnapshot;
|
|
123
123
|
arc: (x: number, y: number, r: number, sAngle: number, eAngle: number, counterclockwise?: boolean) => void;
|
|
124
124
|
arcTo: (x1: number, y1: number, x2: number, y2: number, radius: number) => void;
|
|
@@ -160,29 +160,29 @@ interface HeadlessWxCanvasContext {
|
|
|
160
160
|
strokeText: (text: string, x: number, y: number, maxWidth?: number) => void;
|
|
161
161
|
translate: (x: number, y: number) => void;
|
|
162
162
|
}
|
|
163
|
-
interface HeadlessWxIntersectionObserverMargins {
|
|
163
|
+
export interface HeadlessWxIntersectionObserverMargins {
|
|
164
164
|
bottom?: number;
|
|
165
165
|
left?: number;
|
|
166
166
|
right?: number;
|
|
167
167
|
top?: number;
|
|
168
168
|
}
|
|
169
|
-
interface HeadlessWxIntersectionObserverObserveAllResult {
|
|
169
|
+
export interface HeadlessWxIntersectionObserverObserveAllResult {
|
|
170
170
|
boundingClientRect: HeadlessWxSelectorQueryBoundingClientRectResult;
|
|
171
171
|
id: string;
|
|
172
172
|
intersectionRatio: number;
|
|
173
173
|
intersectionRect: HeadlessWxSelectorQueryBoundingClientRectResult;
|
|
174
174
|
relativeRect: HeadlessWxSelectorQueryBoundingClientRectResult;
|
|
175
175
|
}
|
|
176
|
-
interface HeadlessWxIntersectionObserver {
|
|
176
|
+
export interface HeadlessWxIntersectionObserver {
|
|
177
177
|
disconnect: () => void;
|
|
178
178
|
observe: (selector: string, callback: (result: HeadlessWxIntersectionObserverObserveAllResult) => void) => void;
|
|
179
179
|
relativeTo: (selector: string, margins?: HeadlessWxIntersectionObserverMargins) => HeadlessWxIntersectionObserver;
|
|
180
180
|
relativeToViewport: (margins?: HeadlessWxIntersectionObserverMargins) => HeadlessWxIntersectionObserver;
|
|
181
181
|
}
|
|
182
|
-
interface HeadlessWxCreateIntersectionObserverOption {
|
|
182
|
+
export interface HeadlessWxCreateIntersectionObserverOption {
|
|
183
183
|
thresholds?: number[];
|
|
184
184
|
}
|
|
185
|
-
interface HeadlessWxObserveDescriptor {
|
|
185
|
+
export interface HeadlessWxObserveDescriptor {
|
|
186
186
|
height?: number;
|
|
187
187
|
maxHeight?: number;
|
|
188
188
|
maxWidth?: number;
|
|
@@ -191,14 +191,14 @@ interface HeadlessWxObserveDescriptor {
|
|
|
191
191
|
orientation?: string;
|
|
192
192
|
width?: number;
|
|
193
193
|
}
|
|
194
|
-
interface HeadlessWxMediaQueryObserverObserveCallbackResult {
|
|
194
|
+
export interface HeadlessWxMediaQueryObserverObserveCallbackResult {
|
|
195
195
|
matches: boolean;
|
|
196
196
|
}
|
|
197
|
-
interface HeadlessWxMediaQueryObserver {
|
|
197
|
+
export interface HeadlessWxMediaQueryObserver {
|
|
198
198
|
disconnect: () => void;
|
|
199
199
|
observe: (descriptor: HeadlessWxObserveDescriptor, callback: (result: HeadlessWxMediaQueryObserverObserveCallbackResult) => void) => void;
|
|
200
200
|
}
|
|
201
|
-
interface HeadlessWxSelectorQueryBoundingClientRectResult {
|
|
201
|
+
export interface HeadlessWxSelectorQueryBoundingClientRectResult {
|
|
202
202
|
bottom: number;
|
|
203
203
|
height: number;
|
|
204
204
|
left: number;
|
|
@@ -206,11 +206,11 @@ interface HeadlessWxSelectorQueryBoundingClientRectResult {
|
|
|
206
206
|
top: number;
|
|
207
207
|
width: number;
|
|
208
208
|
}
|
|
209
|
-
interface HeadlessWxSelectorQueryScrollOffsetResult {
|
|
209
|
+
export interface HeadlessWxSelectorQueryScrollOffsetResult {
|
|
210
210
|
scrollLeft: number;
|
|
211
211
|
scrollTop: number;
|
|
212
212
|
}
|
|
213
|
-
interface HeadlessWxSelectorQueryFieldsOption {
|
|
213
|
+
export interface HeadlessWxSelectorQueryFieldsOption {
|
|
214
214
|
computedStyle?: string[];
|
|
215
215
|
context?: boolean;
|
|
216
216
|
dataset?: boolean;
|
|
@@ -222,42 +222,42 @@ interface HeadlessWxSelectorQueryFieldsOption {
|
|
|
222
222
|
scrollOffset?: boolean;
|
|
223
223
|
size?: boolean;
|
|
224
224
|
}
|
|
225
|
-
interface HeadlessWxSelectorQueryRequest {
|
|
225
|
+
export interface HeadlessWxSelectorQueryRequest {
|
|
226
226
|
fields: HeadlessWxSelectorQueryFieldsOption;
|
|
227
227
|
selector?: string;
|
|
228
228
|
single: boolean;
|
|
229
229
|
target: 'selector' | 'viewport';
|
|
230
230
|
}
|
|
231
|
-
interface HeadlessWxSelectorQueryNode {
|
|
231
|
+
export interface HeadlessWxSelectorQueryNode {
|
|
232
232
|
boundingClientRect: (callback?: (result: HeadlessWxSelectorQueryBoundingClientRectResult | HeadlessWxSelectorQueryBoundingClientRectResult[] | null) => void) => HeadlessWxSelectorQuery;
|
|
233
233
|
fields: (fields: HeadlessWxSelectorQueryFieldsOption, callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
|
|
234
234
|
node: (callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
|
|
235
235
|
scrollOffset: (callback?: (result: HeadlessWxSelectorQueryScrollOffsetResult | HeadlessWxSelectorQueryScrollOffsetResult[] | null) => void) => HeadlessWxSelectorQuery;
|
|
236
236
|
}
|
|
237
|
-
interface HeadlessWxSelectorQuery {
|
|
237
|
+
export interface HeadlessWxSelectorQuery {
|
|
238
238
|
exec: (callback?: (result: unknown[]) => void) => unknown[];
|
|
239
239
|
in: (component: Record<string, any>) => HeadlessWxSelectorQuery;
|
|
240
240
|
select: (selector: string) => HeadlessWxSelectorQueryNode;
|
|
241
241
|
selectAll: (selector: string) => HeadlessWxSelectorQueryNode;
|
|
242
242
|
selectViewport: () => HeadlessWxSelectorQueryNode;
|
|
243
243
|
}
|
|
244
|
-
interface HeadlessWxStorageResult {
|
|
244
|
+
export interface HeadlessWxStorageResult {
|
|
245
245
|
errMsg: string;
|
|
246
246
|
}
|
|
247
|
-
interface HeadlessWxGetStorageResult extends HeadlessWxStorageResult {
|
|
247
|
+
export interface HeadlessWxGetStorageResult extends HeadlessWxStorageResult {
|
|
248
248
|
data: unknown;
|
|
249
249
|
}
|
|
250
|
-
interface HeadlessWxStorageInfoResult extends HeadlessWxStorageResult {
|
|
250
|
+
export interface HeadlessWxStorageInfoResult extends HeadlessWxStorageResult {
|
|
251
251
|
currentSize: number;
|
|
252
252
|
keys: string[];
|
|
253
253
|
limitSize: number;
|
|
254
254
|
}
|
|
255
|
-
type HeadlessWxNetworkType = '2g' | '3g' | '4g' | '5g' | 'none' | 'unknown' | 'wifi';
|
|
256
|
-
interface HeadlessWxGetNetworkTypeResult {
|
|
255
|
+
export type HeadlessWxNetworkType = '2g' | '3g' | '4g' | '5g' | 'none' | 'unknown' | 'wifi';
|
|
256
|
+
export interface HeadlessWxGetNetworkTypeResult {
|
|
257
257
|
errMsg: string;
|
|
258
258
|
networkType: HeadlessWxNetworkType;
|
|
259
259
|
}
|
|
260
|
-
interface HeadlessWxGetLocationResult {
|
|
260
|
+
export interface HeadlessWxGetLocationResult {
|
|
261
261
|
accuracy: number;
|
|
262
262
|
altitude: number;
|
|
263
263
|
errMsg: string;
|
|
@@ -267,12 +267,12 @@ interface HeadlessWxGetLocationResult {
|
|
|
267
267
|
speed: number;
|
|
268
268
|
verticalAccuracy: number;
|
|
269
269
|
}
|
|
270
|
-
interface HeadlessWxNetworkStatusChangeResult {
|
|
270
|
+
export interface HeadlessWxNetworkStatusChangeResult {
|
|
271
271
|
isConnected: boolean;
|
|
272
272
|
networkType: HeadlessWxNetworkType;
|
|
273
273
|
}
|
|
274
|
-
type HeadlessWxNetworkStatusChangeCallback = (result: HeadlessWxNetworkStatusChangeResult) => void;
|
|
275
|
-
interface HeadlessWxSystemInfoResult {
|
|
274
|
+
export type HeadlessWxNetworkStatusChangeCallback = (result: HeadlessWxNetworkStatusChangeResult) => void;
|
|
275
|
+
export interface HeadlessWxSystemInfoResult {
|
|
276
276
|
SDKVersion: string;
|
|
277
277
|
brand: string;
|
|
278
278
|
language: string;
|
|
@@ -288,7 +288,7 @@ interface HeadlessWxSystemInfoResult {
|
|
|
288
288
|
windowHeight: number;
|
|
289
289
|
windowWidth: number;
|
|
290
290
|
}
|
|
291
|
-
interface HeadlessWxSafeArea {
|
|
291
|
+
export interface HeadlessWxSafeArea {
|
|
292
292
|
bottom: number;
|
|
293
293
|
height: number;
|
|
294
294
|
left: number;
|
|
@@ -296,13 +296,13 @@ interface HeadlessWxSafeArea {
|
|
|
296
296
|
top: number;
|
|
297
297
|
width: number;
|
|
298
298
|
}
|
|
299
|
-
interface HeadlessWxSafeAreaInsets {
|
|
299
|
+
export interface HeadlessWxSafeAreaInsets {
|
|
300
300
|
bottom: number;
|
|
301
301
|
left: number;
|
|
302
302
|
right: number;
|
|
303
303
|
top: number;
|
|
304
304
|
}
|
|
305
|
-
interface HeadlessWxAppBaseInfoResult {
|
|
305
|
+
export interface HeadlessWxAppBaseInfoResult {
|
|
306
306
|
SDKVersion: string;
|
|
307
307
|
enableDebug: boolean;
|
|
308
308
|
host: {
|
|
@@ -312,7 +312,7 @@ interface HeadlessWxAppBaseInfoResult {
|
|
|
312
312
|
platform: string;
|
|
313
313
|
version: string;
|
|
314
314
|
}
|
|
315
|
-
interface HeadlessWxDeviceInfoResult {
|
|
315
|
+
export interface HeadlessWxDeviceInfoResult {
|
|
316
316
|
abi: string;
|
|
317
317
|
benchmarkLevel: number;
|
|
318
318
|
brand: string;
|
|
@@ -323,7 +323,7 @@ interface HeadlessWxDeviceInfoResult {
|
|
|
323
323
|
platform: string;
|
|
324
324
|
system: string;
|
|
325
325
|
}
|
|
326
|
-
interface HeadlessWxWindowInfoResult {
|
|
326
|
+
export interface HeadlessWxWindowInfoResult {
|
|
327
327
|
pixelRatio: number;
|
|
328
328
|
safeArea: HeadlessWxSafeArea;
|
|
329
329
|
safeAreaInsets: HeadlessWxSafeAreaInsets;
|
|
@@ -333,16 +333,21 @@ interface HeadlessWxWindowInfoResult {
|
|
|
333
333
|
windowHeight: number;
|
|
334
334
|
windowWidth: number;
|
|
335
335
|
}
|
|
336
|
-
interface HeadlessWxLaunchOptions {
|
|
336
|
+
export interface HeadlessWxLaunchOptions {
|
|
337
337
|
path: string;
|
|
338
338
|
query: Record<string, string>;
|
|
339
339
|
referrerInfo: {
|
|
340
|
-
appId
|
|
341
|
-
extraData
|
|
340
|
+
appId?: string;
|
|
341
|
+
extraData?: Record<string, never>;
|
|
342
342
|
};
|
|
343
343
|
scene: number;
|
|
344
344
|
}
|
|
345
|
-
interface
|
|
345
|
+
export interface HeadlessWxAppHideOptions {
|
|
346
|
+
reason: 0 | 1 | 2 | 3;
|
|
347
|
+
}
|
|
348
|
+
export type HeadlessWxAppHideCallback = (options: HeadlessWxAppHideOptions) => void;
|
|
349
|
+
export type HeadlessWxAppShowCallback = (options: HeadlessWxLaunchOptions) => void;
|
|
350
|
+
export interface HeadlessWxMenuButtonBoundingClientRectResult {
|
|
346
351
|
bottom: number;
|
|
347
352
|
height: number;
|
|
348
353
|
left: number;
|
|
@@ -350,110 +355,110 @@ interface HeadlessWxMenuButtonBoundingClientRectResult {
|
|
|
350
355
|
top: number;
|
|
351
356
|
width: number;
|
|
352
357
|
}
|
|
353
|
-
interface HeadlessWxSetStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
358
|
+
export interface HeadlessWxSetStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
354
359
|
data: unknown;
|
|
355
360
|
key: string;
|
|
356
361
|
}
|
|
357
|
-
interface HeadlessWxSetClipboardDataResult {
|
|
362
|
+
export interface HeadlessWxSetClipboardDataResult {
|
|
358
363
|
errMsg: string;
|
|
359
364
|
}
|
|
360
|
-
interface HeadlessWxSetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxSetClipboardDataResult> {
|
|
365
|
+
export interface HeadlessWxSetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxSetClipboardDataResult> {
|
|
361
366
|
data: string;
|
|
362
367
|
}
|
|
363
|
-
interface HeadlessWxGetClipboardDataResult {
|
|
368
|
+
export interface HeadlessWxGetClipboardDataResult {
|
|
364
369
|
data: string;
|
|
365
370
|
errMsg: string;
|
|
366
371
|
}
|
|
367
|
-
interface HeadlessWxGetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxGetClipboardDataResult> {}
|
|
368
|
-
interface HeadlessWxGetStorageOption extends HeadlessWxCallbackOption<HeadlessWxGetStorageResult> {
|
|
372
|
+
export interface HeadlessWxGetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxGetClipboardDataResult> {}
|
|
373
|
+
export interface HeadlessWxGetStorageOption extends HeadlessWxCallbackOption<HeadlessWxGetStorageResult> {
|
|
369
374
|
key: string;
|
|
370
375
|
}
|
|
371
|
-
interface HeadlessWxGetStorageInfoOption extends HeadlessWxCallbackOption<HeadlessWxStorageInfoResult> {}
|
|
372
|
-
interface HeadlessWxGetNetworkTypeOption extends HeadlessWxCallbackOption<HeadlessWxGetNetworkTypeResult> {}
|
|
373
|
-
interface HeadlessWxGetLocationOption extends HeadlessWxCallbackOption<HeadlessWxGetLocationResult> {
|
|
376
|
+
export interface HeadlessWxGetStorageInfoOption extends HeadlessWxCallbackOption<HeadlessWxStorageInfoResult> {}
|
|
377
|
+
export interface HeadlessWxGetNetworkTypeOption extends HeadlessWxCallbackOption<HeadlessWxGetNetworkTypeResult> {}
|
|
378
|
+
export interface HeadlessWxGetLocationOption extends HeadlessWxCallbackOption<HeadlessWxGetLocationResult> {
|
|
374
379
|
altitude?: boolean;
|
|
375
380
|
highAccuracyExpireTime?: number;
|
|
376
381
|
isHighAccuracy?: boolean;
|
|
377
382
|
type?: 'gcj02' | 'wgs84';
|
|
378
383
|
}
|
|
379
|
-
interface HeadlessWxGetSystemInfoOption extends HeadlessWxCallbackOption<HeadlessWxSystemInfoResult> {}
|
|
380
|
-
interface HeadlessWxGetWindowInfoOption extends HeadlessWxCallbackOption<HeadlessWxWindowInfoResult> {}
|
|
381
|
-
interface HeadlessWxGetAppBaseInfoOption extends HeadlessWxCallbackOption<HeadlessWxAppBaseInfoResult> {}
|
|
384
|
+
export interface HeadlessWxGetSystemInfoOption extends HeadlessWxCallbackOption<HeadlessWxSystemInfoResult> {}
|
|
385
|
+
export interface HeadlessWxGetWindowInfoOption extends HeadlessWxCallbackOption<HeadlessWxWindowInfoResult> {}
|
|
386
|
+
export interface HeadlessWxGetAppBaseInfoOption extends HeadlessWxCallbackOption<HeadlessWxAppBaseInfoResult> {}
|
|
382
387
|
//#endregion
|
|
383
388
|
//#region src/host/wx/eventBus.d.ts
|
|
384
|
-
type HeadlessUniEventHandler = (...args: any[]) => void;
|
|
385
|
-
interface HeadlessUniEventBus {
|
|
389
|
+
export type HeadlessUniEventHandler = (...args: any[]) => void;
|
|
390
|
+
export interface HeadlessUniEventBus {
|
|
386
391
|
$emit: (eventName: string, ...args: any[]) => void;
|
|
387
392
|
$off: (eventName?: string, handler?: HeadlessUniEventHandler) => void;
|
|
388
393
|
$on: (eventName: string, handler: HeadlessUniEventHandler) => void;
|
|
389
394
|
$once: (eventName: string, handler: HeadlessUniEventHandler) => void;
|
|
390
395
|
}
|
|
391
|
-
declare function createHeadlessUniEventBus(): HeadlessUniEventBus;
|
|
396
|
+
export declare function createHeadlessUniEventBus(): HeadlessUniEventBus;
|
|
392
397
|
//#endregion
|
|
393
398
|
//#region src/host/wx/fileSystem.d.ts
|
|
394
|
-
interface HeadlessWxFileSystemResult {
|
|
399
|
+
export interface HeadlessWxFileSystemResult {
|
|
395
400
|
errMsg: string;
|
|
396
401
|
}
|
|
397
|
-
interface HeadlessWxReadFileSuccessResult {
|
|
402
|
+
export interface HeadlessWxReadFileSuccessResult {
|
|
398
403
|
data: string;
|
|
399
404
|
errMsg: string;
|
|
400
405
|
}
|
|
401
|
-
interface HeadlessWxReadFileOption extends HeadlessWxCallbackOption<HeadlessWxReadFileSuccessResult> {
|
|
406
|
+
export interface HeadlessWxReadFileOption extends HeadlessWxCallbackOption<HeadlessWxReadFileSuccessResult> {
|
|
402
407
|
encoding?: string;
|
|
403
408
|
filePath: string;
|
|
404
409
|
}
|
|
405
|
-
interface HeadlessWxWriteFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
410
|
+
export interface HeadlessWxWriteFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
406
411
|
data: string;
|
|
407
412
|
encoding?: string;
|
|
408
413
|
filePath: string;
|
|
409
414
|
}
|
|
410
|
-
interface HeadlessWxAccessFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
415
|
+
export interface HeadlessWxAccessFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
411
416
|
path: string;
|
|
412
417
|
}
|
|
413
|
-
interface HeadlessWxAppendFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
418
|
+
export interface HeadlessWxAppendFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
414
419
|
data: string;
|
|
415
420
|
encoding?: string;
|
|
416
421
|
filePath: string;
|
|
417
422
|
}
|
|
418
|
-
interface HeadlessWxUnlinkOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
423
|
+
export interface HeadlessWxUnlinkOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
419
424
|
filePath: string;
|
|
420
425
|
}
|
|
421
|
-
interface HeadlessWxCopyFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
426
|
+
export interface HeadlessWxCopyFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
422
427
|
destPath: string;
|
|
423
428
|
srcPath: string;
|
|
424
429
|
}
|
|
425
|
-
interface HeadlessWxRenameOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
430
|
+
export interface HeadlessWxRenameOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
426
431
|
newPath: string;
|
|
427
432
|
oldPath: string;
|
|
428
433
|
}
|
|
429
|
-
interface HeadlessWxMkdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
434
|
+
export interface HeadlessWxMkdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
430
435
|
dirPath: string;
|
|
431
436
|
recursive?: boolean;
|
|
432
437
|
}
|
|
433
|
-
interface HeadlessWxRmdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
438
|
+
export interface HeadlessWxRmdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
434
439
|
dirPath: string;
|
|
435
440
|
recursive?: boolean;
|
|
436
441
|
}
|
|
437
|
-
interface HeadlessWxReadDirSuccessResult {
|
|
442
|
+
export interface HeadlessWxReadDirSuccessResult {
|
|
438
443
|
errMsg: string;
|
|
439
444
|
files: string[];
|
|
440
445
|
}
|
|
441
|
-
interface HeadlessWxReadDirOption extends HeadlessWxCallbackOption<HeadlessWxReadDirSuccessResult> {
|
|
446
|
+
export interface HeadlessWxReadDirOption extends HeadlessWxCallbackOption<HeadlessWxReadDirSuccessResult> {
|
|
442
447
|
dirPath: string;
|
|
443
448
|
}
|
|
444
|
-
interface HeadlessWxStats {
|
|
449
|
+
export interface HeadlessWxStats {
|
|
445
450
|
isDirectory: () => boolean;
|
|
446
451
|
isFile: () => boolean;
|
|
447
452
|
size: number;
|
|
448
453
|
}
|
|
449
|
-
interface HeadlessWxStatSuccessResult {
|
|
454
|
+
export interface HeadlessWxStatSuccessResult {
|
|
450
455
|
errMsg: string;
|
|
451
456
|
stats: HeadlessWxStats;
|
|
452
457
|
}
|
|
453
|
-
interface HeadlessWxStatOption extends HeadlessWxCallbackOption<HeadlessWxStatSuccessResult> {
|
|
458
|
+
export interface HeadlessWxStatOption extends HeadlessWxCallbackOption<HeadlessWxStatSuccessResult> {
|
|
454
459
|
path: string;
|
|
455
460
|
}
|
|
456
|
-
interface HeadlessWxFileSystemManager {
|
|
461
|
+
export interface HeadlessWxFileSystemManager {
|
|
457
462
|
access: (option: HeadlessWxAccessFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
458
463
|
accessSync: (path: string) => void;
|
|
459
464
|
appendFile: (option: HeadlessWxAppendFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
@@ -478,8 +483,20 @@ interface HeadlessWxFileSystemManager {
|
|
|
478
483
|
writeFileSync: (filePath: string, data: string, encoding?: string) => void;
|
|
479
484
|
}
|
|
480
485
|
//#endregion
|
|
486
|
+
//#region src/host/wx/logManager.d.ts
|
|
487
|
+
interface HeadlessWxGetLogManagerOption {
|
|
488
|
+
/** 控制宿主自动生命周期及 API 日志,不过滤显式日志方法。 */
|
|
489
|
+
level?: number;
|
|
490
|
+
}
|
|
491
|
+
interface HeadlessWxLogManager {
|
|
492
|
+
debug: (...args: unknown[]) => void;
|
|
493
|
+
info: (...args: unknown[]) => void;
|
|
494
|
+
log: (...args: unknown[]) => void;
|
|
495
|
+
warn: (...args: unknown[]) => void;
|
|
496
|
+
}
|
|
497
|
+
//#endregion
|
|
481
498
|
//#region src/host/wx/media.d.ts
|
|
482
|
-
interface HeadlessWxGetImageInfoResult {
|
|
499
|
+
export interface HeadlessWxGetImageInfoResult {
|
|
483
500
|
errMsg: string;
|
|
484
501
|
height: number;
|
|
485
502
|
orientation: 'up';
|
|
@@ -487,27 +504,27 @@ interface HeadlessWxGetImageInfoResult {
|
|
|
487
504
|
type: string;
|
|
488
505
|
width: number;
|
|
489
506
|
}
|
|
490
|
-
interface HeadlessWxGetImageInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetImageInfoResult> {
|
|
507
|
+
export interface HeadlessWxGetImageInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetImageInfoResult> {
|
|
491
508
|
src: string;
|
|
492
509
|
}
|
|
493
|
-
interface HeadlessWxGetFileInfoResult {
|
|
510
|
+
export interface HeadlessWxGetFileInfoResult {
|
|
494
511
|
digest: string;
|
|
495
512
|
errMsg: string;
|
|
496
513
|
size: number;
|
|
497
514
|
}
|
|
498
|
-
interface HeadlessWxGetFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetFileInfoResult> {
|
|
515
|
+
export interface HeadlessWxGetFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetFileInfoResult> {
|
|
499
516
|
digestAlgorithm?: 'md5' | 'sha1';
|
|
500
517
|
filePath: string;
|
|
501
518
|
}
|
|
502
|
-
interface HeadlessWxOpenDocumentResult {
|
|
519
|
+
export interface HeadlessWxOpenDocumentResult {
|
|
503
520
|
errMsg: string;
|
|
504
521
|
}
|
|
505
|
-
interface HeadlessWxOpenDocumentOption extends HeadlessWxCallbackOption<HeadlessWxOpenDocumentResult> {
|
|
522
|
+
export interface HeadlessWxOpenDocumentOption extends HeadlessWxCallbackOption<HeadlessWxOpenDocumentResult> {
|
|
506
523
|
filePath: string;
|
|
507
524
|
fileType?: string;
|
|
508
525
|
showMenu?: boolean;
|
|
509
526
|
}
|
|
510
|
-
interface HeadlessWxGetVideoInfoResult {
|
|
527
|
+
export interface HeadlessWxGetVideoInfoResult {
|
|
511
528
|
bitrate: number;
|
|
512
529
|
duration: number;
|
|
513
530
|
errMsg: string;
|
|
@@ -518,37 +535,37 @@ interface HeadlessWxGetVideoInfoResult {
|
|
|
518
535
|
type: string;
|
|
519
536
|
width: number;
|
|
520
537
|
}
|
|
521
|
-
interface HeadlessWxGetVideoInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetVideoInfoResult> {
|
|
538
|
+
export interface HeadlessWxGetVideoInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetVideoInfoResult> {
|
|
522
539
|
src: string;
|
|
523
540
|
}
|
|
524
|
-
interface HeadlessWxRemoveStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
541
|
+
export interface HeadlessWxRemoveStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
525
542
|
key: string;
|
|
526
543
|
}
|
|
527
|
-
interface HeadlessWxClearStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {}
|
|
528
|
-
interface HeadlessWxHideLoadingOption extends HeadlessWxCallbackOption<{
|
|
544
|
+
export interface HeadlessWxClearStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {}
|
|
545
|
+
export interface HeadlessWxHideLoadingOption extends HeadlessWxCallbackOption<{
|
|
529
546
|
errMsg: string;
|
|
530
547
|
}> {}
|
|
531
|
-
interface HeadlessWxStartPullDownRefreshOption extends HeadlessWxCallbackOption<{
|
|
548
|
+
export interface HeadlessWxStartPullDownRefreshOption extends HeadlessWxCallbackOption<{
|
|
532
549
|
errMsg: string;
|
|
533
550
|
}> {}
|
|
534
|
-
interface HeadlessWxSetBackgroundTextStyleOption extends HeadlessWxCallbackOption<{
|
|
551
|
+
export interface HeadlessWxSetBackgroundTextStyleOption extends HeadlessWxCallbackOption<{
|
|
535
552
|
errMsg: string;
|
|
536
553
|
}> {
|
|
537
554
|
textStyle: string;
|
|
538
555
|
}
|
|
539
|
-
interface HeadlessWxSetBackgroundColorOption extends HeadlessWxCallbackOption<{
|
|
556
|
+
export interface HeadlessWxSetBackgroundColorOption extends HeadlessWxCallbackOption<{
|
|
540
557
|
errMsg: string;
|
|
541
558
|
}> {
|
|
542
559
|
backgroundColor?: string;
|
|
543
560
|
backgroundColorBottom?: string;
|
|
544
561
|
backgroundColorTop?: string;
|
|
545
562
|
}
|
|
546
|
-
interface HeadlessWxSetNavigationBarTitleOption extends HeadlessWxCallbackOption<{
|
|
563
|
+
export interface HeadlessWxSetNavigationBarTitleOption extends HeadlessWxCallbackOption<{
|
|
547
564
|
errMsg: string;
|
|
548
565
|
}> {
|
|
549
566
|
title: string;
|
|
550
567
|
}
|
|
551
|
-
interface HeadlessWxSetNavigationBarColorOption extends HeadlessWxCallbackOption<{
|
|
568
|
+
export interface HeadlessWxSetNavigationBarColorOption extends HeadlessWxCallbackOption<{
|
|
552
569
|
errMsg: string;
|
|
553
570
|
}> {
|
|
554
571
|
animation?: {
|
|
@@ -558,43 +575,43 @@ interface HeadlessWxSetNavigationBarColorOption extends HeadlessWxCallbackOption
|
|
|
558
575
|
backgroundColor?: string;
|
|
559
576
|
frontColor?: string;
|
|
560
577
|
}
|
|
561
|
-
interface HeadlessWxShowNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
578
|
+
export interface HeadlessWxShowNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
562
579
|
errMsg: string;
|
|
563
580
|
}> {}
|
|
564
|
-
interface HeadlessWxHideNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
581
|
+
export interface HeadlessWxHideNavigationBarLoadingOption extends HeadlessWxCallbackOption<{
|
|
565
582
|
errMsg: string;
|
|
566
583
|
}> {}
|
|
567
|
-
interface HeadlessWxShareMenuOption extends HeadlessWxCallbackOption<{
|
|
584
|
+
export interface HeadlessWxShareMenuOption extends HeadlessWxCallbackOption<{
|
|
568
585
|
errMsg: string;
|
|
569
586
|
}> {
|
|
570
587
|
isUpdatableMessage?: boolean;
|
|
571
588
|
menus?: string[];
|
|
572
589
|
withShareTicket?: boolean;
|
|
573
590
|
}
|
|
574
|
-
interface HeadlessWxTabBarOption extends HeadlessWxCallbackOption<{
|
|
591
|
+
export interface HeadlessWxTabBarOption extends HeadlessWxCallbackOption<{
|
|
575
592
|
errMsg: string;
|
|
576
593
|
}> {}
|
|
577
|
-
interface HeadlessWxTabBarItemOption extends HeadlessWxCallbackOption<{
|
|
594
|
+
export interface HeadlessWxTabBarItemOption extends HeadlessWxCallbackOption<{
|
|
578
595
|
errMsg: string;
|
|
579
596
|
}> {
|
|
580
597
|
index: number;
|
|
581
598
|
}
|
|
582
|
-
interface HeadlessWxSetTabBarBadgeOption extends HeadlessWxTabBarItemOption {
|
|
599
|
+
export interface HeadlessWxSetTabBarBadgeOption extends HeadlessWxTabBarItemOption {
|
|
583
600
|
text: string;
|
|
584
601
|
}
|
|
585
|
-
interface HeadlessWxShowActionSheetResult {
|
|
602
|
+
export interface HeadlessWxShowActionSheetResult {
|
|
586
603
|
errMsg: string;
|
|
587
604
|
tapIndex: number;
|
|
588
605
|
}
|
|
589
|
-
interface HeadlessWxShowActionSheetOption extends HeadlessWxCallbackOption<HeadlessWxShowActionSheetResult> {
|
|
606
|
+
export interface HeadlessWxShowActionSheetOption extends HeadlessWxCallbackOption<HeadlessWxShowActionSheetResult> {
|
|
590
607
|
itemList: string[];
|
|
591
608
|
}
|
|
592
|
-
interface HeadlessWxShowModalResult {
|
|
609
|
+
export interface HeadlessWxShowModalResult {
|
|
593
610
|
cancel: boolean;
|
|
594
611
|
confirm: boolean;
|
|
595
612
|
errMsg: string;
|
|
596
613
|
}
|
|
597
|
-
interface HeadlessWxShowModalOption extends HeadlessWxCallbackOption<HeadlessWxShowModalResult> {
|
|
614
|
+
export interface HeadlessWxShowModalOption extends HeadlessWxCallbackOption<HeadlessWxShowModalResult> {
|
|
598
615
|
cancelColor?: string;
|
|
599
616
|
cancelText?: string;
|
|
600
617
|
confirmColor?: string;
|
|
@@ -603,7 +620,7 @@ interface HeadlessWxShowModalOption extends HeadlessWxCallbackOption<HeadlessWxS
|
|
|
603
620
|
showCancel?: boolean;
|
|
604
621
|
title?: string;
|
|
605
622
|
}
|
|
606
|
-
interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
|
|
623
|
+
export interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
|
|
607
624
|
errMsg: string;
|
|
608
625
|
}> {
|
|
609
626
|
duration?: number;
|
|
@@ -611,44 +628,44 @@ interface HeadlessWxShowToastOption extends HeadlessWxCallbackOption<{
|
|
|
611
628
|
mask?: boolean;
|
|
612
629
|
title: string;
|
|
613
630
|
}
|
|
614
|
-
interface HeadlessWxShowLoadingOption extends HeadlessWxCallbackOption<{
|
|
631
|
+
export interface HeadlessWxShowLoadingOption extends HeadlessWxCallbackOption<{
|
|
615
632
|
errMsg: string;
|
|
616
633
|
}> {
|
|
617
634
|
mask?: boolean;
|
|
618
635
|
title: string;
|
|
619
636
|
}
|
|
620
|
-
interface HeadlessWxRequestSuccessResult {
|
|
637
|
+
export interface HeadlessWxRequestSuccessResult {
|
|
621
638
|
cookies: string[];
|
|
622
639
|
data: unknown;
|
|
623
640
|
errMsg: string;
|
|
624
641
|
header: Record<string, string>;
|
|
625
642
|
statusCode: number;
|
|
626
643
|
}
|
|
627
|
-
interface HeadlessWxRequestOption extends HeadlessWxCallbackOption<HeadlessWxRequestSuccessResult> {
|
|
644
|
+
export interface HeadlessWxRequestOption extends HeadlessWxCallbackOption<HeadlessWxRequestSuccessResult> {
|
|
628
645
|
data?: unknown;
|
|
629
646
|
header?: Record<string, string>;
|
|
630
647
|
method?: string;
|
|
631
648
|
url: string;
|
|
632
649
|
}
|
|
633
|
-
interface HeadlessWxRequestTask {
|
|
650
|
+
export interface HeadlessWxRequestTask {
|
|
634
651
|
abort: () => void;
|
|
635
652
|
}
|
|
636
|
-
interface HeadlessWxDownloadFileSuccessResult {
|
|
653
|
+
export interface HeadlessWxDownloadFileSuccessResult {
|
|
637
654
|
errMsg: string;
|
|
638
655
|
statusCode: number;
|
|
639
656
|
tempFilePath: string;
|
|
640
657
|
}
|
|
641
|
-
interface HeadlessWxDownloadFileOption extends HeadlessWxCallbackOption<HeadlessWxDownloadFileSuccessResult> {
|
|
658
|
+
export interface HeadlessWxDownloadFileOption extends HeadlessWxCallbackOption<HeadlessWxDownloadFileSuccessResult> {
|
|
642
659
|
filePath?: string;
|
|
643
660
|
header?: Record<string, string>;
|
|
644
661
|
url: string;
|
|
645
662
|
}
|
|
646
|
-
interface HeadlessWxUploadFileSuccessResult {
|
|
663
|
+
export interface HeadlessWxUploadFileSuccessResult {
|
|
647
664
|
data: string;
|
|
648
665
|
errMsg: string;
|
|
649
666
|
statusCode: number;
|
|
650
667
|
}
|
|
651
|
-
interface HeadlessWxUploadFileOption extends HeadlessWxCallbackOption<HeadlessWxUploadFileSuccessResult> {
|
|
668
|
+
export interface HeadlessWxUploadFileOption extends HeadlessWxCallbackOption<HeadlessWxUploadFileSuccessResult> {
|
|
652
669
|
fileName?: string;
|
|
653
670
|
filePath: string;
|
|
654
671
|
formData?: Record<string, unknown>;
|
|
@@ -656,19 +673,19 @@ interface HeadlessWxUploadFileOption extends HeadlessWxCallbackOption<HeadlessWx
|
|
|
656
673
|
name: string;
|
|
657
674
|
url: string;
|
|
658
675
|
}
|
|
659
|
-
interface HeadlessWxSaveFileSuccessResult {
|
|
676
|
+
export interface HeadlessWxSaveFileSuccessResult {
|
|
660
677
|
errMsg: string;
|
|
661
678
|
savedFilePath: string;
|
|
662
679
|
}
|
|
663
|
-
interface HeadlessWxSaveFileOption extends HeadlessWxCallbackOption<HeadlessWxSaveFileSuccessResult> {
|
|
680
|
+
export interface HeadlessWxSaveFileOption extends HeadlessWxCallbackOption<HeadlessWxSaveFileSuccessResult> {
|
|
664
681
|
filePath?: string;
|
|
665
682
|
tempFilePath: string;
|
|
666
683
|
}
|
|
667
|
-
interface HeadlessWxCanvasToTempFilePathSuccessResult {
|
|
684
|
+
export interface HeadlessWxCanvasToTempFilePathSuccessResult {
|
|
668
685
|
errMsg: string;
|
|
669
686
|
tempFilePath: string;
|
|
670
687
|
}
|
|
671
|
-
interface HeadlessWxCanvasToTempFilePathOption extends HeadlessWxCallbackOption<HeadlessWxCanvasToTempFilePathSuccessResult> {
|
|
688
|
+
export interface HeadlessWxCanvasToTempFilePathOption extends HeadlessWxCallbackOption<HeadlessWxCanvasToTempFilePathSuccessResult> {
|
|
672
689
|
canvasId: string;
|
|
673
690
|
component?: Record<string, any>;
|
|
674
691
|
destHeight?: number;
|
|
@@ -680,66 +697,66 @@ interface HeadlessWxCanvasToTempFilePathOption extends HeadlessWxCallbackOption<
|
|
|
680
697
|
x?: number;
|
|
681
698
|
y?: number;
|
|
682
699
|
}
|
|
683
|
-
interface HeadlessWxSaveImageToPhotosAlbumResult {
|
|
700
|
+
export interface HeadlessWxSaveImageToPhotosAlbumResult {
|
|
684
701
|
errMsg: string;
|
|
685
702
|
}
|
|
686
|
-
interface HeadlessWxSaveImageToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveImageToPhotosAlbumResult> {
|
|
703
|
+
export interface HeadlessWxSaveImageToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveImageToPhotosAlbumResult> {
|
|
687
704
|
filePath: string;
|
|
688
705
|
}
|
|
689
|
-
interface HeadlessWxSaveVideoToPhotosAlbumResult {
|
|
706
|
+
export interface HeadlessWxSaveVideoToPhotosAlbumResult {
|
|
690
707
|
errMsg: string;
|
|
691
708
|
}
|
|
692
|
-
interface HeadlessWxSaveVideoToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveVideoToPhotosAlbumResult> {
|
|
709
|
+
export interface HeadlessWxSaveVideoToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveVideoToPhotosAlbumResult> {
|
|
693
710
|
filePath: string;
|
|
694
711
|
}
|
|
695
|
-
interface HeadlessWxPreviewImageResult {
|
|
712
|
+
export interface HeadlessWxPreviewImageResult {
|
|
696
713
|
errMsg: string;
|
|
697
714
|
}
|
|
698
|
-
interface HeadlessWxPreviewImageOption extends HeadlessWxCallbackOption<HeadlessWxPreviewImageResult> {
|
|
715
|
+
export interface HeadlessWxPreviewImageOption extends HeadlessWxCallbackOption<HeadlessWxPreviewImageResult> {
|
|
699
716
|
current?: string;
|
|
700
717
|
urls: string[];
|
|
701
718
|
}
|
|
702
|
-
interface HeadlessWxChooseImageTempFile {
|
|
719
|
+
export interface HeadlessWxChooseImageTempFile {
|
|
703
720
|
path: string;
|
|
704
721
|
size: number;
|
|
705
722
|
}
|
|
706
|
-
interface HeadlessWxChooseImageResult {
|
|
723
|
+
export interface HeadlessWxChooseImageResult {
|
|
707
724
|
errMsg: string;
|
|
708
725
|
tempFilePaths: string[];
|
|
709
726
|
tempFiles: HeadlessWxChooseImageTempFile[];
|
|
710
727
|
}
|
|
711
|
-
interface HeadlessWxChooseImageOption extends HeadlessWxCallbackOption<HeadlessWxChooseImageResult> {
|
|
728
|
+
export interface HeadlessWxChooseImageOption extends HeadlessWxCallbackOption<HeadlessWxChooseImageResult> {
|
|
712
729
|
count?: number;
|
|
713
730
|
sizeType?: string[];
|
|
714
731
|
sourceType?: string[];
|
|
715
732
|
}
|
|
716
|
-
interface HeadlessWxChooseMessageFileTempFile {
|
|
733
|
+
export interface HeadlessWxChooseMessageFileTempFile {
|
|
717
734
|
name: string;
|
|
718
735
|
path: string;
|
|
719
736
|
size: number;
|
|
720
737
|
time: number;
|
|
721
738
|
type: string;
|
|
722
739
|
}
|
|
723
|
-
interface HeadlessWxChooseMessageFileResult {
|
|
740
|
+
export interface HeadlessWxChooseMessageFileResult {
|
|
724
741
|
errMsg: string;
|
|
725
742
|
tempFiles: HeadlessWxChooseMessageFileTempFile[];
|
|
726
743
|
}
|
|
727
|
-
interface HeadlessWxChooseMessageFileOption extends HeadlessWxCallbackOption<HeadlessWxChooseMessageFileResult> {
|
|
744
|
+
export interface HeadlessWxChooseMessageFileOption extends HeadlessWxCallbackOption<HeadlessWxChooseMessageFileResult> {
|
|
728
745
|
count?: number;
|
|
729
746
|
extension?: string[];
|
|
730
747
|
type?: 'all' | 'file' | 'image' | 'video';
|
|
731
748
|
}
|
|
732
|
-
interface HeadlessWxCompressImageResult {
|
|
749
|
+
export interface HeadlessWxCompressImageResult {
|
|
733
750
|
errMsg: string;
|
|
734
751
|
tempFilePath: string;
|
|
735
752
|
}
|
|
736
|
-
interface HeadlessWxCompressImageOption extends HeadlessWxCallbackOption<HeadlessWxCompressImageResult> {
|
|
753
|
+
export interface HeadlessWxCompressImageOption extends HeadlessWxCallbackOption<HeadlessWxCompressImageResult> {
|
|
737
754
|
compressedHeight?: number;
|
|
738
755
|
compressedWidth?: number;
|
|
739
756
|
quality?: number;
|
|
740
757
|
src: string;
|
|
741
758
|
}
|
|
742
|
-
interface HeadlessWxChooseVideoResult {
|
|
759
|
+
export interface HeadlessWxChooseVideoResult {
|
|
743
760
|
duration: number;
|
|
744
761
|
errMsg: string;
|
|
745
762
|
height: number;
|
|
@@ -747,13 +764,13 @@ interface HeadlessWxChooseVideoResult {
|
|
|
747
764
|
tempFilePath: string;
|
|
748
765
|
width: number;
|
|
749
766
|
}
|
|
750
|
-
interface HeadlessWxChooseVideoOption extends HeadlessWxCallbackOption<HeadlessWxChooseVideoResult> {
|
|
767
|
+
export interface HeadlessWxChooseVideoOption extends HeadlessWxCallbackOption<HeadlessWxChooseVideoResult> {
|
|
751
768
|
camera?: string[];
|
|
752
769
|
compressed?: boolean;
|
|
753
770
|
maxDuration?: number;
|
|
754
771
|
sourceType?: string[];
|
|
755
772
|
}
|
|
756
|
-
interface HeadlessWxChooseMediaTempFile {
|
|
773
|
+
export interface HeadlessWxChooseMediaTempFile {
|
|
757
774
|
duration?: number;
|
|
758
775
|
fileType: 'image' | 'video';
|
|
759
776
|
height: number;
|
|
@@ -762,12 +779,12 @@ interface HeadlessWxChooseMediaTempFile {
|
|
|
762
779
|
thumbTempFilePath?: string;
|
|
763
780
|
width: number;
|
|
764
781
|
}
|
|
765
|
-
interface HeadlessWxChooseMediaResult {
|
|
782
|
+
export interface HeadlessWxChooseMediaResult {
|
|
766
783
|
errMsg: string;
|
|
767
784
|
tempFiles: HeadlessWxChooseMediaTempFile[];
|
|
768
785
|
type: 'image' | 'mix' | 'video';
|
|
769
786
|
}
|
|
770
|
-
interface HeadlessWxChooseMediaOption extends HeadlessWxCallbackOption<HeadlessWxChooseMediaResult> {
|
|
787
|
+
export interface HeadlessWxChooseMediaOption extends HeadlessWxCallbackOption<HeadlessWxChooseMediaResult> {
|
|
771
788
|
camera?: string[];
|
|
772
789
|
count?: number;
|
|
773
790
|
maxDuration?: number;
|
|
@@ -775,30 +792,30 @@ interface HeadlessWxChooseMediaOption extends HeadlessWxCallbackOption<HeadlessW
|
|
|
775
792
|
sizeType?: string[];
|
|
776
793
|
sourceType?: string[];
|
|
777
794
|
}
|
|
778
|
-
interface HeadlessWxSavedFileInfo {
|
|
795
|
+
export interface HeadlessWxSavedFileInfo {
|
|
779
796
|
createTime: number;
|
|
780
797
|
filePath: string;
|
|
781
798
|
size: number;
|
|
782
799
|
}
|
|
783
|
-
interface HeadlessWxGetSavedFileListSuccessResult {
|
|
800
|
+
export interface HeadlessWxGetSavedFileListSuccessResult {
|
|
784
801
|
errMsg: string;
|
|
785
802
|
fileList: HeadlessWxSavedFileInfo[];
|
|
786
803
|
}
|
|
787
|
-
interface HeadlessWxGetSavedFileListOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileListSuccessResult> {}
|
|
788
|
-
interface HeadlessWxGetSavedFileInfoSuccessResult {
|
|
804
|
+
export interface HeadlessWxGetSavedFileListOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileListSuccessResult> {}
|
|
805
|
+
export interface HeadlessWxGetSavedFileInfoSuccessResult {
|
|
789
806
|
createTime: number;
|
|
790
807
|
errMsg: string;
|
|
791
808
|
size: number;
|
|
792
809
|
}
|
|
793
|
-
interface HeadlessWxGetSavedFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileInfoSuccessResult> {
|
|
810
|
+
export interface HeadlessWxGetSavedFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetSavedFileInfoSuccessResult> {
|
|
794
811
|
filePath: string;
|
|
795
812
|
}
|
|
796
|
-
interface HeadlessWxRemoveSavedFileOption extends HeadlessWxCallbackOption<{
|
|
813
|
+
export interface HeadlessWxRemoveSavedFileOption extends HeadlessWxCallbackOption<{
|
|
797
814
|
errMsg: string;
|
|
798
815
|
}> {
|
|
799
816
|
filePath: string;
|
|
800
817
|
}
|
|
801
|
-
interface HeadlessWxDriverCapabilities {
|
|
818
|
+
export interface HeadlessWxDriverCapabilities {
|
|
802
819
|
clearStorageSync: () => void;
|
|
803
820
|
createAnimation: (option?: HeadlessWxAnimationStepOption) => HeadlessWxAnimation;
|
|
804
821
|
createCanvasContext: (canvasId: string, scope?: Record<string, any>) => HeadlessWxCanvasContext;
|
|
@@ -837,7 +854,11 @@ interface HeadlessWxDriverCapabilities {
|
|
|
837
854
|
navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
|
|
838
855
|
navigateTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
839
856
|
nextTick: (callback?: () => void) => void;
|
|
857
|
+
offAppHide: (callback?: HeadlessWxAppHideCallback) => void;
|
|
858
|
+
offAppShow: (callback?: HeadlessWxAppShowCallback) => void;
|
|
840
859
|
offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
860
|
+
onAppHide: (callback: HeadlessWxAppHideCallback) => void;
|
|
861
|
+
onAppShow: (callback: HeadlessWxAppShowCallback) => void;
|
|
841
862
|
onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
842
863
|
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
843
864
|
reLaunch: (option: HeadlessWxNavigateOption) => unknown;
|
|
@@ -894,7 +915,7 @@ interface HeadlessWxDriverCapabilities {
|
|
|
894
915
|
}
|
|
895
916
|
//#endregion
|
|
896
917
|
//#region src/host/wx/api.d.ts
|
|
897
|
-
interface HeadlessWxDriver extends HeadlessWxDriverCapabilities {
|
|
918
|
+
export interface HeadlessWxDriver extends HeadlessWxDriverCapabilities {
|
|
898
919
|
chooseImage: (option: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult;
|
|
899
920
|
chooseMessageFile: (option: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult;
|
|
900
921
|
chooseMedia: (option: HeadlessWxChooseMediaOption) => HeadlessWxChooseMediaResult;
|
|
@@ -920,7 +941,7 @@ interface HeadlessWxDriver extends HeadlessWxDriverCapabilities {
|
|
|
920
941
|
canvasToTempFilePath: (option: HeadlessWxCanvasToTempFilePathOption) => HeadlessWxCanvasToTempFilePathSuccessResult;
|
|
921
942
|
uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
|
|
922
943
|
}
|
|
923
|
-
interface HeadlessWx extends HeadlessUniEventBus {
|
|
944
|
+
export interface HeadlessWx extends HeadlessUniEventBus {
|
|
924
945
|
canIUse: (schema: string) => boolean;
|
|
925
946
|
chooseImage: (option?: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult | undefined;
|
|
926
947
|
chooseMessageFile: (option?: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult | undefined;
|
|
@@ -947,6 +968,7 @@ interface HeadlessWx extends HeadlessUniEventBus {
|
|
|
947
968
|
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
948
969
|
getDeviceInfo: () => HeadlessWxDeviceInfoResult;
|
|
949
970
|
getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
|
|
971
|
+
getLogManager: (option?: HeadlessWxGetLogManagerOption) => HeadlessWxLogManager;
|
|
950
972
|
getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
|
|
951
973
|
getClipboardData: (option?: HeadlessWxGetClipboardDataOption) => HeadlessWxGetClipboardDataResult | undefined;
|
|
952
974
|
getLocation: (option?: HeadlessWxGetLocationOption) => HeadlessWxGetLocationResult | undefined;
|
|
@@ -970,7 +992,11 @@ interface HeadlessWx extends HeadlessUniEventBus {
|
|
|
970
992
|
navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
|
|
971
993
|
navigateTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
972
994
|
nextTick: (callback?: () => void) => void;
|
|
995
|
+
offAppHide: (callback?: HeadlessWxAppHideCallback) => void;
|
|
996
|
+
offAppShow: (callback?: HeadlessWxAppShowCallback) => void;
|
|
973
997
|
offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
998
|
+
onAppHide: (callback: HeadlessWxAppHideCallback) => void;
|
|
999
|
+
onAppShow: (callback: HeadlessWxAppShowCallback) => void;
|
|
974
1000
|
onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
975
1001
|
openDocument: (option: HeadlessWxOpenDocumentOption) => HeadlessWxOpenDocumentResult | undefined;
|
|
976
1002
|
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
@@ -1055,29 +1081,29 @@ interface HeadlessWx extends HeadlessUniEventBus {
|
|
|
1055
1081
|
}
|
|
1056
1082
|
//#endregion
|
|
1057
1083
|
//#region src/host/wx/index.d.ts
|
|
1058
|
-
declare function createHeadlessWx(driver: HeadlessWxDriver): HeadlessWx;
|
|
1084
|
+
export declare function createHeadlessWx(driver: HeadlessWxDriver, runtimeConsole?: Pick<Console, 'debug' | 'info' | 'log' | 'warn'>): HeadlessWx;
|
|
1059
1085
|
//#endregion
|
|
1060
1086
|
//#region src/kernel/artifactSource.d.ts
|
|
1061
|
-
interface ArtifactSource {
|
|
1087
|
+
export interface ArtifactSource {
|
|
1062
1088
|
has: (filePath: string) => boolean;
|
|
1063
1089
|
readText: (filePath: string) => string | undefined;
|
|
1064
1090
|
}
|
|
1065
|
-
declare function createFileSystemArtifactSource(): ArtifactSource;
|
|
1066
|
-
declare function createMemoryArtifactSource(entries: Iterable<[string, string]>): ArtifactSource;
|
|
1067
|
-
declare function createOverlayArtifactSource(overlay: ArtifactSource, fallback: ArtifactSource): ArtifactSource;
|
|
1091
|
+
export declare function createFileSystemArtifactSource(): ArtifactSource;
|
|
1092
|
+
export declare function createMemoryArtifactSource(entries: Iterable<[string, string]>): ArtifactSource;
|
|
1093
|
+
export declare function createOverlayArtifactSource(overlay: ArtifactSource, fallback: ArtifactSource): ArtifactSource;
|
|
1068
1094
|
//#endregion
|
|
1069
1095
|
//#region src/kernel/diagnostics.d.ts
|
|
1070
|
-
type RuntimeDiagnosticLevel = 'error' | 'exception' | 'warn';
|
|
1071
|
-
interface RuntimeDiagnosticEntry {
|
|
1096
|
+
export type RuntimeDiagnosticLevel = 'error' | 'exception' | 'warn';
|
|
1097
|
+
export interface RuntimeDiagnosticEntry {
|
|
1072
1098
|
args: unknown[];
|
|
1073
1099
|
level: RuntimeDiagnosticLevel;
|
|
1074
1100
|
timestamp: number;
|
|
1075
1101
|
}
|
|
1076
|
-
interface RuntimeConsoleEntry {
|
|
1102
|
+
export interface RuntimeConsoleEntry {
|
|
1077
1103
|
args: unknown[];
|
|
1078
1104
|
level: 'debug' | 'error' | 'info' | 'log' | 'warn';
|
|
1079
1105
|
}
|
|
1080
|
-
declare class RuntimeDiagnostics {
|
|
1106
|
+
export declare class RuntimeDiagnostics {
|
|
1081
1107
|
private readonly entries;
|
|
1082
1108
|
clear(): void;
|
|
1083
1109
|
getEntries(): {
|
|
@@ -1090,15 +1116,15 @@ declare class RuntimeDiagnostics {
|
|
|
1090
1116
|
}
|
|
1091
1117
|
//#endregion
|
|
1092
1118
|
//#region src/kernel/platform.d.ts
|
|
1093
|
-
interface PlatformAdapter {
|
|
1119
|
+
export interface PlatformAdapter {
|
|
1094
1120
|
readonly name: string;
|
|
1095
1121
|
}
|
|
1096
|
-
declare function wechat(): PlatformAdapter;
|
|
1122
|
+
export declare function wechat(): PlatformAdapter;
|
|
1097
1123
|
//#endregion
|
|
1098
1124
|
//#region src/kernel/scheduler.d.ts
|
|
1099
1125
|
type TimeoutHandle = ReturnType<typeof setTimeout>;
|
|
1100
1126
|
type IntervalHandle = ReturnType<typeof setInterval>;
|
|
1101
|
-
declare class RuntimeScheduler {
|
|
1127
|
+
export declare class RuntimeScheduler {
|
|
1102
1128
|
private readonly intervals;
|
|
1103
1129
|
private readonly timeouts;
|
|
1104
1130
|
private closed;
|
|
@@ -1113,7 +1139,7 @@ declare class RuntimeScheduler {
|
|
|
1113
1139
|
}
|
|
1114
1140
|
//#endregion
|
|
1115
1141
|
//#region src/kernel/runtimeKernel.d.ts
|
|
1116
|
-
declare class RuntimeKernel {
|
|
1142
|
+
export declare class RuntimeKernel {
|
|
1117
1143
|
readonly diagnostics: RuntimeDiagnostics;
|
|
1118
1144
|
readonly scheduler: RuntimeScheduler;
|
|
1119
1145
|
private closed;
|
|
@@ -1123,38 +1149,38 @@ declare class RuntimeKernel {
|
|
|
1123
1149
|
}
|
|
1124
1150
|
//#endregion
|
|
1125
1151
|
//#region src/project/plugins.d.ts
|
|
1126
|
-
declare const HEADLESS_PLUGIN_VIRTUAL_ROOT = "__plugins__";
|
|
1127
|
-
interface HeadlessPluginDescriptor {
|
|
1152
|
+
export declare const HEADLESS_PLUGIN_VIRTUAL_ROOT = "__plugins__";
|
|
1153
|
+
export interface HeadlessPluginDescriptor {
|
|
1128
1154
|
alias: string;
|
|
1129
1155
|
config: Record<string, any>;
|
|
1130
1156
|
provider: string;
|
|
1131
1157
|
rootPath: string;
|
|
1132
1158
|
virtualRoot: string;
|
|
1133
1159
|
}
|
|
1134
|
-
declare function createPluginVirtualRoot(alias: string): string;
|
|
1135
|
-
declare function resolvePluginRequest(plugins: HeadlessPluginDescriptor[], request: string, kind: 'page' | 'publicComponent'): {
|
|
1160
|
+
export declare function createPluginVirtualRoot(alias: string): string;
|
|
1161
|
+
export declare function resolvePluginRequest(plugins: HeadlessPluginDescriptor[], request: string, kind: 'page' | 'publicComponent'): {
|
|
1136
1162
|
plugin: HeadlessPluginDescriptor;
|
|
1137
1163
|
publicName: string;
|
|
1138
1164
|
resourcePath: string;
|
|
1139
1165
|
} | undefined;
|
|
1140
|
-
declare function createPluginArtifactSource(fallback: ArtifactSource, miniprogramRootPath: string, plugins: HeadlessPluginDescriptor[]): ArtifactSource;
|
|
1166
|
+
export declare function createPluginArtifactSource(fallback: ArtifactSource, miniprogramRootPath: string, plugins: HeadlessPluginDescriptor[]): ArtifactSource;
|
|
1141
1167
|
//#endregion
|
|
1142
1168
|
//#region src/project/resolveRoutes.d.ts
|
|
1143
|
-
interface HeadlessRouteRecord {
|
|
1169
|
+
export interface HeadlessRouteRecord {
|
|
1144
1170
|
kind: 'page';
|
|
1145
1171
|
route: string;
|
|
1146
1172
|
source: 'pages' | 'plugin' | 'subPackages';
|
|
1147
1173
|
resourcePath?: string;
|
|
1148
1174
|
subpackageRoot?: string;
|
|
1149
1175
|
}
|
|
1150
|
-
declare function resolveRoutesFromAppConfig(config: Record<string, any>, plugins?: HeadlessPluginDescriptor[]): HeadlessRouteRecord[];
|
|
1176
|
+
export declare function resolveRoutesFromAppConfig(config: Record<string, any>, plugins?: HeadlessPluginDescriptor[]): HeadlessRouteRecord[];
|
|
1151
1177
|
//#endregion
|
|
1152
1178
|
//#region src/project/createProjectDescriptor.d.ts
|
|
1153
|
-
interface HeadlessProjectConfigFile {
|
|
1179
|
+
export interface HeadlessProjectConfigFile {
|
|
1154
1180
|
filePath: string;
|
|
1155
1181
|
value: Record<string, any>;
|
|
1156
1182
|
}
|
|
1157
|
-
interface HeadlessProjectDescriptor {
|
|
1183
|
+
export interface HeadlessProjectDescriptor {
|
|
1158
1184
|
artifactSource: ArtifactSource;
|
|
1159
1185
|
appConfig: Record<string, any>;
|
|
1160
1186
|
appConfigPath: string;
|
|
@@ -1165,7 +1191,7 @@ interface HeadlessProjectDescriptor {
|
|
|
1165
1191
|
projectConfigFiles: HeadlessProjectConfigFile[];
|
|
1166
1192
|
routes: HeadlessRouteRecord[];
|
|
1167
1193
|
}
|
|
1168
|
-
interface CreateProjectDescriptorOptions {
|
|
1194
|
+
export interface CreateProjectDescriptorOptions {
|
|
1169
1195
|
artifactSource?: ArtifactSource;
|
|
1170
1196
|
appConfig: Record<string, any>;
|
|
1171
1197
|
appConfigPath: string;
|
|
@@ -1175,42 +1201,42 @@ interface CreateProjectDescriptorOptions {
|
|
|
1175
1201
|
projectPath: string;
|
|
1176
1202
|
projectConfigFiles?: HeadlessProjectConfigFile[];
|
|
1177
1203
|
}
|
|
1178
|
-
declare function createProjectDescriptor(options: CreateProjectDescriptorOptions): HeadlessProjectDescriptor;
|
|
1204
|
+
export declare function createProjectDescriptor(options: CreateProjectDescriptorOptions): HeadlessProjectDescriptor;
|
|
1179
1205
|
//#endregion
|
|
1180
1206
|
//#region src/project/createArtifactProject.d.ts
|
|
1181
|
-
interface CreateArtifactProjectOptions {
|
|
1207
|
+
export interface CreateArtifactProjectOptions {
|
|
1182
1208
|
appConfigPath?: string;
|
|
1183
1209
|
artifactSource?: ArtifactSource;
|
|
1184
1210
|
miniprogramRootPath: string;
|
|
1185
1211
|
projectPath?: string;
|
|
1186
1212
|
}
|
|
1187
|
-
declare function createArtifactProject(options: CreateArtifactProjectOptions): HeadlessProjectDescriptor;
|
|
1213
|
+
export declare function createArtifactProject(options: CreateArtifactProjectOptions): HeadlessProjectDescriptor;
|
|
1188
1214
|
//#endregion
|
|
1189
1215
|
//#region src/project/loadProject.d.ts
|
|
1190
|
-
declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
|
|
1216
|
+
export declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
|
|
1191
1217
|
//#endregion
|
|
1192
1218
|
//#region src/browser/virtualFiles.d.ts
|
|
1193
|
-
interface BrowserDirectoryFileLike {
|
|
1219
|
+
export interface BrowserDirectoryFileLike {
|
|
1194
1220
|
name: string;
|
|
1195
1221
|
text: () => Promise<string>;
|
|
1196
1222
|
webkitRelativePath?: string;
|
|
1197
1223
|
}
|
|
1198
|
-
type BrowserVirtualFiles = Map<string, string>;
|
|
1199
|
-
declare function normalizeBrowserFilePath(filePath: string): string;
|
|
1200
|
-
declare function createBrowserVirtualFiles(entries: Iterable<[string, string]>): BrowserVirtualFiles;
|
|
1201
|
-
declare function createBrowserVirtualFilesFromDirectory(files: BrowserDirectoryFileLike[]): Promise<BrowserVirtualFiles>;
|
|
1202
|
-
declare function readBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): string | undefined;
|
|
1203
|
-
declare function hasBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): boolean;
|
|
1224
|
+
export type BrowserVirtualFiles = Map<string, string>;
|
|
1225
|
+
export declare function normalizeBrowserFilePath(filePath: string): string;
|
|
1226
|
+
export declare function createBrowserVirtualFiles(entries: Iterable<[string, string]>): BrowserVirtualFiles;
|
|
1227
|
+
export declare function createBrowserVirtualFilesFromDirectory(files: BrowserDirectoryFileLike[]): Promise<BrowserVirtualFiles>;
|
|
1228
|
+
export declare function readBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): string | undefined;
|
|
1229
|
+
export declare function hasBrowserVirtualFile(files: BrowserVirtualFiles, filePath: string): boolean;
|
|
1204
1230
|
//#endregion
|
|
1205
1231
|
//#region src/browser/moduleLoader.d.ts
|
|
1206
|
-
interface BrowserModuleLoader {
|
|
1232
|
+
export interface BrowserModuleLoader {
|
|
1207
1233
|
close: () => void;
|
|
1208
1234
|
executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
|
|
1209
1235
|
executeAppModule: (filePath: string) => HeadlessAppDefinition;
|
|
1210
1236
|
executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
|
|
1211
1237
|
wx: HeadlessWx;
|
|
1212
1238
|
}
|
|
1213
|
-
declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0], options: {
|
|
1239
|
+
export declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0], options: {
|
|
1214
1240
|
globals?: Record<string, unknown>;
|
|
1215
1241
|
kernel: RuntimeKernel;
|
|
1216
1242
|
miniprogramRootPath: string;
|
|
@@ -1218,14 +1244,14 @@ declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registrie
|
|
|
1218
1244
|
}): BrowserModuleLoader;
|
|
1219
1245
|
//#endregion
|
|
1220
1246
|
//#region src/browser/project.d.ts
|
|
1221
|
-
interface CreateBrowserProjectOptions {
|
|
1247
|
+
export interface CreateBrowserProjectOptions {
|
|
1222
1248
|
appConfigPath?: string;
|
|
1223
1249
|
miniprogramRoot?: string;
|
|
1224
1250
|
miniprogramRootPath?: string;
|
|
1225
1251
|
plugins?: HeadlessPluginDescriptor[];
|
|
1226
1252
|
projectPath?: string;
|
|
1227
1253
|
}
|
|
1228
|
-
declare function createBrowserProject(files: BrowserVirtualFiles, options?: CreateBrowserProjectOptions): HeadlessProjectDescriptor;
|
|
1254
|
+
export declare function createBrowserProject(files: BrowserVirtualFiles, options?: CreateBrowserProjectOptions): HeadlessProjectDescriptor;
|
|
1229
1255
|
//#endregion
|
|
1230
1256
|
//#region src/project/pageConfig.d.ts
|
|
1231
1257
|
interface HeadlessNavigationBarSnapshot {
|
|
@@ -1246,30 +1272,6 @@ interface HeadlessBackgroundSnapshot {
|
|
|
1246
1272
|
textStyle: HeadlessBackgroundTextStyle;
|
|
1247
1273
|
}
|
|
1248
1274
|
//#endregion
|
|
1249
|
-
//#region src/runtime/pageInstance.d.ts
|
|
1250
|
-
interface HeadlessPageInstance extends Record<string, any> {
|
|
1251
|
-
__background__?: HeadlessBackgroundSnapshot;
|
|
1252
|
-
__backgroundTextStyle__?: HeadlessBackgroundTextStyle;
|
|
1253
|
-
__lastChangedKeys__?: string[];
|
|
1254
|
-
__navigationBar__?: HeadlessNavigationBarSnapshot;
|
|
1255
|
-
__navigationBarTitle__?: string;
|
|
1256
|
-
__route__: string;
|
|
1257
|
-
__scrollTop__?: number;
|
|
1258
|
-
data: Record<string, any>;
|
|
1259
|
-
options: Record<string, string>;
|
|
1260
|
-
route: string;
|
|
1261
|
-
createIntersectionObserver?: (options?: Record<string, any>) => any;
|
|
1262
|
-
createMediaQueryObserver?: () => HeadlessWxMediaQueryObserver;
|
|
1263
|
-
selectAllComponents?: (selector: string) => any[];
|
|
1264
|
-
selectComponent?: (selector: string) => any;
|
|
1265
|
-
setData: (patch: Record<string, any>, callback?: () => void) => void;
|
|
1266
|
-
}
|
|
1267
|
-
declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>, pageState?: {
|
|
1268
|
-
background?: HeadlessBackgroundSnapshot;
|
|
1269
|
-
backgroundTextStyle?: HeadlessBackgroundTextStyle;
|
|
1270
|
-
navigationBar?: HeadlessNavigationBarSnapshot;
|
|
1271
|
-
}): HeadlessPageInstance;
|
|
1272
|
-
//#endregion
|
|
1273
1275
|
//#region src/runtime/componentInstance/types.d.ts
|
|
1274
1276
|
interface HeadlessComponentInstance extends Record<string, any> {
|
|
1275
1277
|
__definition__?: HeadlessComponentDefinition;
|
|
@@ -1278,6 +1280,8 @@ interface HeadlessComponentInstance extends Record<string, any> {
|
|
|
1278
1280
|
__ready__?: boolean;
|
|
1279
1281
|
createIntersectionObserver?: (options?: Record<string, any>) => any;
|
|
1280
1282
|
createMediaQueryObserver?: () => HeadlessWxMediaQueryObserver;
|
|
1283
|
+
createSelectorQuery?: () => HeadlessWxSelectorQuery;
|
|
1284
|
+
getRelationNodes: (relationKey: string) => HeadlessComponentInstance[];
|
|
1281
1285
|
data: Record<string, any>;
|
|
1282
1286
|
properties: Record<string, any>;
|
|
1283
1287
|
selectAllComponents?: (selector: string) => any[];
|
|
@@ -1294,33 +1298,83 @@ interface CreateComponentInstanceOptions {
|
|
|
1294
1298
|
}
|
|
1295
1299
|
//#endregion
|
|
1296
1300
|
//#region src/runtime/componentInstance/observers.d.ts
|
|
1297
|
-
declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
|
|
1301
|
+
export declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
|
|
1298
1302
|
//#endregion
|
|
1299
1303
|
//#region src/runtime/componentInstance/properties.d.ts
|
|
1300
|
-
declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
|
|
1301
|
-
declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): any;
|
|
1304
|
+
export declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
|
|
1305
|
+
export declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): any;
|
|
1302
1306
|
//#endregion
|
|
1303
1307
|
//#region src/runtime/componentInstance/shared.d.ts
|
|
1304
|
-
declare function cloneValue<T>(value: T): T;
|
|
1305
|
-
declare function hasComponentPropertyValueChanged(currentValue: unknown, previousSnapshot: unknown, nextValue: unknown, bindingAffected: boolean): boolean;
|
|
1308
|
+
export declare function cloneValue<T>(value: T): T;
|
|
1309
|
+
export declare function hasComponentPropertyValueChanged(currentValue: unknown, previousSnapshot: unknown, nextValue: unknown, bindingAffected: boolean): boolean;
|
|
1306
1310
|
//#endregion
|
|
1307
1311
|
//#region src/runtime/componentInstance/index.d.ts
|
|
1308
|
-
declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
|
|
1309
|
-
declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
|
|
1310
|
-
declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
|
|
1312
|
+
export declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
|
|
1313
|
+
export declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
|
|
1314
|
+
export declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
|
|
1315
|
+
//#endregion
|
|
1316
|
+
//#region src/runtime/pageInstance.d.ts
|
|
1317
|
+
export interface HeadlessPageInstance extends Record<string, any> {
|
|
1318
|
+
__background__?: HeadlessBackgroundSnapshot;
|
|
1319
|
+
__backgroundTextStyle__?: HeadlessBackgroundTextStyle;
|
|
1320
|
+
__lastChangedKeys__?: string[];
|
|
1321
|
+
__navigationBar__?: HeadlessNavigationBarSnapshot;
|
|
1322
|
+
__navigationBarTitle__?: string;
|
|
1323
|
+
__route__: string;
|
|
1324
|
+
__scrollTop__?: number;
|
|
1325
|
+
data: Record<string, any>;
|
|
1326
|
+
properties: Record<string, any>;
|
|
1327
|
+
options: Record<string, string>;
|
|
1328
|
+
route: string;
|
|
1329
|
+
createIntersectionObserver?: (options?: Record<string, any>) => any;
|
|
1330
|
+
createMediaQueryObserver?: () => HeadlessWxMediaQueryObserver;
|
|
1331
|
+
getTabBar?: () => HeadlessComponentInstance | null;
|
|
1332
|
+
selectAllComponents?: (selector: string) => any[];
|
|
1333
|
+
selectComponent?: (selector: string) => any;
|
|
1334
|
+
setData: (patch: Record<string, any>, callback?: () => void) => void;
|
|
1335
|
+
}
|
|
1336
|
+
export declare function getPageInstanceId(page: HeadlessPageInstance): number;
|
|
1337
|
+
export declare function createPageInstance(route: string, definition: HeadlessPageDefinition, options?: Record<string, string>, pageState?: {
|
|
1338
|
+
background?: HeadlessBackgroundSnapshot;
|
|
1339
|
+
backgroundTextStyle?: HeadlessBackgroundTextStyle;
|
|
1340
|
+
navigationBar?: HeadlessNavigationBarSnapshot;
|
|
1341
|
+
requestRender?: (callback?: () => void) => void;
|
|
1342
|
+
}): HeadlessPageInstance;
|
|
1343
|
+
//#endregion
|
|
1344
|
+
//#region src/view/wxs.d.ts
|
|
1345
|
+
type WxsModuleBindings = Record<string, unknown>;
|
|
1311
1346
|
//#endregion
|
|
1312
1347
|
//#region src/view/templateRuntime.d.ts
|
|
1313
1348
|
interface TemplateNodeLike {
|
|
1314
1349
|
attribs?: Record<string, string>;
|
|
1315
1350
|
children?: TemplateNodeLike[];
|
|
1351
|
+
data?: string;
|
|
1316
1352
|
name?: string;
|
|
1317
1353
|
type?: string;
|
|
1318
1354
|
}
|
|
1319
1355
|
interface TemplateRenderState<T extends TemplateNodeLike> {
|
|
1320
1356
|
definitions: Map<string, T>;
|
|
1357
|
+
definitionScopes?: Map<T, Map<string, T>>;
|
|
1358
|
+
definitionWxsScopes?: Map<T, WxsModuleBindings>;
|
|
1359
|
+
wxsModules?: WxsModuleBindings;
|
|
1321
1360
|
stack: string[];
|
|
1322
1361
|
}
|
|
1323
1362
|
//#endregion
|
|
1363
|
+
//#region src/browser/styles/index.d.ts
|
|
1364
|
+
export interface BrowserPageStyles {
|
|
1365
|
+
/** 按实际遍历顺序去重的项目相对样式依赖。 */
|
|
1366
|
+
dependencies: string[];
|
|
1367
|
+
/** 已展开本地导入的页面 CSS;不包含嵌套组件样式隔离转换。 */
|
|
1368
|
+
cssText: string;
|
|
1369
|
+
/** Component 页面的 page-* 隔离选项可关闭隐式 app.wxss。 */
|
|
1370
|
+
appWxssEnabled: boolean;
|
|
1371
|
+
}
|
|
1372
|
+
/** 读取当前文件内容并展开页面样式依赖,保持 app 在前、页面声明在后的层叠顺序。 */
|
|
1373
|
+
export declare function resolveBrowserPageStyles(files: BrowserVirtualFiles, route: string, options?: {
|
|
1374
|
+
miniprogramRootPath?: string;
|
|
1375
|
+
styleIsolation?: string;
|
|
1376
|
+
}): BrowserPageStyles;
|
|
1377
|
+
//#endregion
|
|
1324
1378
|
//#region src/browser/render/types.d.ts
|
|
1325
1379
|
interface DomNodeLike$5 {
|
|
1326
1380
|
attribs?: Record<string, string>;
|
|
@@ -1331,6 +1385,7 @@ interface DomNodeLike$5 {
|
|
|
1331
1385
|
type?: string;
|
|
1332
1386
|
}
|
|
1333
1387
|
interface BrowserRenderScope {
|
|
1388
|
+
wxs?: WxsModuleBindings;
|
|
1334
1389
|
alias?: string;
|
|
1335
1390
|
classList?: string[];
|
|
1336
1391
|
data: Record<string, any>;
|
|
@@ -1358,6 +1413,7 @@ interface BrowserSlotContent {
|
|
|
1358
1413
|
}
|
|
1359
1414
|
interface BrowserRenderedPageTree {
|
|
1360
1415
|
root: DomNodeLike$5;
|
|
1416
|
+
styles: BrowserPageStyles;
|
|
1361
1417
|
wxml: string;
|
|
1362
1418
|
}
|
|
1363
1419
|
interface BrowserRendererContext {
|
|
@@ -1378,17 +1434,18 @@ interface BrowserRendererContext {
|
|
|
1378
1434
|
}
|
|
1379
1435
|
//#endregion
|
|
1380
1436
|
//#region src/browser/render/index.d.ts
|
|
1381
|
-
declare function renderBrowserPageTree(context: BrowserRendererContext, page: HeadlessPageInstance): BrowserRenderedPageTree;
|
|
1437
|
+
export declare function renderBrowserPageTree(context: BrowserRendererContext, page: HeadlessPageInstance): BrowserRenderedPageTree;
|
|
1382
1438
|
//#endregion
|
|
1383
1439
|
//#region src/runtime/appInstance.d.ts
|
|
1384
|
-
interface HeadlessAppInstance extends Record<string, any> {
|
|
1440
|
+
export interface HeadlessAppInstance extends Record<string, any> {
|
|
1385
1441
|
globalData: Record<string, any>;
|
|
1386
1442
|
}
|
|
1387
|
-
declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
|
|
1443
|
+
export declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
|
|
1388
1444
|
//#endregion
|
|
1389
1445
|
//#region src/runtime/moduleLoader.d.ts
|
|
1390
1446
|
interface HeadlessModuleLoader {
|
|
1391
1447
|
close: () => void;
|
|
1448
|
+
evaluate: <T>(source: string, args: any[]) => T;
|
|
1392
1449
|
executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
|
|
1393
1450
|
executeAppModule: (filePath: string) => HeadlessAppDefinition;
|
|
1394
1451
|
executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
|
|
@@ -1405,6 +1462,7 @@ interface DomNodeLike$4 {
|
|
|
1405
1462
|
type?: string;
|
|
1406
1463
|
}
|
|
1407
1464
|
interface RuntimeRenderScope {
|
|
1465
|
+
wxs?: WxsModuleBindings;
|
|
1408
1466
|
alias?: string;
|
|
1409
1467
|
classList?: string[];
|
|
1410
1468
|
data: Record<string, any>;
|
|
@@ -1452,53 +1510,53 @@ interface RuntimeRendererContext {
|
|
|
1452
1510
|
}
|
|
1453
1511
|
//#endregion
|
|
1454
1512
|
//#region src/runtime/render/index.d.ts
|
|
1455
|
-
declare function renderRuntimePageTree(context: RuntimeRendererContext, page: HeadlessPageInstance): RuntimeRenderedPageTree;
|
|
1513
|
+
export declare function renderRuntimePageTree(context: RuntimeRendererContext, page: HeadlessPageInstance): RuntimeRenderedPageTree;
|
|
1456
1514
|
//#endregion
|
|
1457
1515
|
//#region src/runtime/wxState.d.ts
|
|
1458
|
-
interface HeadlessWxLoadingSnapshot {
|
|
1516
|
+
export interface HeadlessWxLoadingSnapshot {
|
|
1459
1517
|
mask: boolean;
|
|
1460
1518
|
title: string;
|
|
1461
1519
|
}
|
|
1462
|
-
interface HeadlessWxToastSnapshot {
|
|
1520
|
+
export interface HeadlessWxToastSnapshot {
|
|
1463
1521
|
duration: number;
|
|
1464
1522
|
icon: string;
|
|
1465
1523
|
mask: boolean;
|
|
1466
1524
|
title: string;
|
|
1467
1525
|
}
|
|
1468
|
-
interface HeadlessWxPreviewImageSnapshot {
|
|
1526
|
+
export interface HeadlessWxPreviewImageSnapshot {
|
|
1469
1527
|
current: string;
|
|
1470
1528
|
urls: string[];
|
|
1471
1529
|
visible: boolean;
|
|
1472
1530
|
}
|
|
1473
|
-
interface HeadlessWxOpenDocumentSnapshot {
|
|
1531
|
+
export interface HeadlessWxOpenDocumentSnapshot {
|
|
1474
1532
|
filePath: string;
|
|
1475
1533
|
fileType: string;
|
|
1476
1534
|
showMenu: boolean;
|
|
1477
1535
|
visible: boolean;
|
|
1478
1536
|
}
|
|
1479
|
-
interface HeadlessWxNetworkSnapshot extends HeadlessWxNetworkStatusChangeResult {}
|
|
1480
|
-
interface HeadlessWxShareMenuSnapshot {
|
|
1537
|
+
export interface HeadlessWxNetworkSnapshot extends HeadlessWxNetworkStatusChangeResult {}
|
|
1538
|
+
export interface HeadlessWxShareMenuSnapshot {
|
|
1481
1539
|
isUpdatableMessage: boolean;
|
|
1482
1540
|
menus: string[];
|
|
1483
1541
|
visible: boolean;
|
|
1484
1542
|
withShareTicket: boolean;
|
|
1485
1543
|
}
|
|
1486
|
-
interface HeadlessWxClipboardSnapshot {
|
|
1544
|
+
export interface HeadlessWxClipboardSnapshot {
|
|
1487
1545
|
data: string;
|
|
1488
1546
|
}
|
|
1489
|
-
interface HeadlessWxActionSheetMockDefinition {
|
|
1547
|
+
export interface HeadlessWxActionSheetMockDefinition {
|
|
1490
1548
|
cancel?: boolean;
|
|
1491
1549
|
tapIndex?: number;
|
|
1492
1550
|
}
|
|
1493
|
-
interface HeadlessWxActionSheetLogEntry {
|
|
1551
|
+
export interface HeadlessWxActionSheetLogEntry {
|
|
1494
1552
|
itemList: string[];
|
|
1495
1553
|
result?: HeadlessWxShowActionSheetResult;
|
|
1496
1554
|
}
|
|
1497
|
-
interface HeadlessWxModalMockDefinition {
|
|
1555
|
+
export interface HeadlessWxModalMockDefinition {
|
|
1498
1556
|
cancel?: boolean;
|
|
1499
1557
|
confirm?: boolean;
|
|
1500
1558
|
}
|
|
1501
|
-
interface HeadlessWxModalLogEntry {
|
|
1559
|
+
export interface HeadlessWxModalLogEntry {
|
|
1502
1560
|
cancelColor: string;
|
|
1503
1561
|
cancelText: string;
|
|
1504
1562
|
confirmColor: string;
|
|
@@ -1508,7 +1566,7 @@ interface HeadlessWxModalLogEntry {
|
|
|
1508
1566
|
showCancel: boolean;
|
|
1509
1567
|
title: string;
|
|
1510
1568
|
}
|
|
1511
|
-
interface HeadlessWxRequestMockDefinition {
|
|
1569
|
+
export interface HeadlessWxRequestMockDefinition {
|
|
1512
1570
|
delay?: number;
|
|
1513
1571
|
header?: Record<string, string>;
|
|
1514
1572
|
method?: string;
|
|
@@ -1516,7 +1574,7 @@ interface HeadlessWxRequestMockDefinition {
|
|
|
1516
1574
|
statusCode?: number;
|
|
1517
1575
|
url: RegExp | string;
|
|
1518
1576
|
}
|
|
1519
|
-
interface HeadlessWxRequestLogEntry {
|
|
1577
|
+
export interface HeadlessWxRequestLogEntry {
|
|
1520
1578
|
data: unknown;
|
|
1521
1579
|
header: Record<string, string>;
|
|
1522
1580
|
matched: boolean;
|
|
@@ -1524,21 +1582,21 @@ interface HeadlessWxRequestLogEntry {
|
|
|
1524
1582
|
response?: HeadlessWxRequestSuccessResult;
|
|
1525
1583
|
url: string;
|
|
1526
1584
|
}
|
|
1527
|
-
interface HeadlessWxDownloadFileMockDefinition {
|
|
1585
|
+
export interface HeadlessWxDownloadFileMockDefinition {
|
|
1528
1586
|
delay?: number;
|
|
1529
1587
|
fileContent: string | ((option: HeadlessWxDownloadFileOption) => string);
|
|
1530
1588
|
header?: Record<string, string>;
|
|
1531
1589
|
statusCode?: number;
|
|
1532
1590
|
url: RegExp | string;
|
|
1533
1591
|
}
|
|
1534
|
-
interface HeadlessWxDownloadFileLogEntry {
|
|
1592
|
+
export interface HeadlessWxDownloadFileLogEntry {
|
|
1535
1593
|
header: Record<string, string>;
|
|
1536
1594
|
matched: boolean;
|
|
1537
1595
|
response?: HeadlessWxDownloadFileSuccessResult;
|
|
1538
1596
|
tempFilePath?: string;
|
|
1539
1597
|
url: string;
|
|
1540
1598
|
}
|
|
1541
|
-
interface HeadlessWxUploadFileMockDefinition {
|
|
1599
|
+
export interface HeadlessWxUploadFileMockDefinition {
|
|
1542
1600
|
delay?: number;
|
|
1543
1601
|
header?: Record<string, string>;
|
|
1544
1602
|
method?: string;
|
|
@@ -1548,7 +1606,7 @@ interface HeadlessWxUploadFileMockDefinition {
|
|
|
1548
1606
|
statusCode?: number;
|
|
1549
1607
|
url: RegExp | string;
|
|
1550
1608
|
}
|
|
1551
|
-
interface HeadlessWxUploadFileLogEntry {
|
|
1609
|
+
export interface HeadlessWxUploadFileLogEntry {
|
|
1552
1610
|
fileContent: string;
|
|
1553
1611
|
fileName?: string;
|
|
1554
1612
|
filePath: string;
|
|
@@ -1559,10 +1617,10 @@ interface HeadlessWxUploadFileLogEntry {
|
|
|
1559
1617
|
response?: HeadlessWxUploadFileSuccessResult;
|
|
1560
1618
|
url: string;
|
|
1561
1619
|
}
|
|
1562
|
-
interface HeadlessWxStateOptions {
|
|
1620
|
+
export interface HeadlessWxStateOptions {
|
|
1563
1621
|
strictMocks?: boolean;
|
|
1564
1622
|
}
|
|
1565
|
-
declare function createHeadlessWxState(scheduler?: Pick<RuntimeScheduler, 'clearTimeout' | 'setTimeout'>, options?: HeadlessWxStateOptions): {
|
|
1623
|
+
export declare function createHeadlessWxState(scheduler?: Pick<RuntimeScheduler, 'clearTimeout' | 'setTimeout'>, options?: HeadlessWxStateOptions): {
|
|
1566
1624
|
close(): void;
|
|
1567
1625
|
clearStorageSync(): void;
|
|
1568
1626
|
downloadFile(option: HeadlessWxDownloadFileOption): HeadlessWxRequestTask;
|
|
@@ -1835,17 +1893,18 @@ declare function createHeadlessWxState(scheduler?: Pick<RuntimeScheduler, 'clear
|
|
|
1835
1893
|
};
|
|
1836
1894
|
//#endregion
|
|
1837
1895
|
//#region src/runtime/session.d.ts
|
|
1838
|
-
interface HeadlessSessionOptions {
|
|
1896
|
+
export interface HeadlessSessionOptions {
|
|
1839
1897
|
globals?: Record<string, unknown>;
|
|
1840
1898
|
project?: HeadlessProjectDescriptor;
|
|
1841
1899
|
projectPath?: string;
|
|
1842
1900
|
strictHostMocks?: boolean;
|
|
1843
1901
|
}
|
|
1844
|
-
declare class HeadlessSession {
|
|
1902
|
+
export declare class HeadlessSession {
|
|
1845
1903
|
readonly project: HeadlessProjectDescriptor;
|
|
1846
1904
|
private readonly kernel;
|
|
1847
1905
|
private appDefinition;
|
|
1848
1906
|
private appInstance;
|
|
1907
|
+
private readonly appLifecycle;
|
|
1849
1908
|
private readonly moduleLoader;
|
|
1850
1909
|
private readonly eventListeners;
|
|
1851
1910
|
private readonly registries;
|
|
@@ -1879,6 +1938,8 @@ declare class HeadlessSession {
|
|
|
1879
1938
|
getApp(): HeadlessAppInstance | null;
|
|
1880
1939
|
getCurrentPages(): HeadlessPageInstance[];
|
|
1881
1940
|
getWx(): HeadlessWx;
|
|
1941
|
+
/** 在当前小程序实例的上下文执行测试函数,复用应用全局对象与调度器。 */
|
|
1942
|
+
evaluateRuntime<T = unknown>(source: string, args?: any[]): T;
|
|
1882
1943
|
callWxMethod(methodName: string, ...args: any[]): any;
|
|
1883
1944
|
getCurrentPageNavigationBarTitle(): string | null;
|
|
1884
1945
|
getCurrentPageNavigationBar(): {
|
|
@@ -2045,32 +2106,8 @@ declare class HeadlessSession {
|
|
|
2045
2106
|
getWindowInfo(): HeadlessWxWindowInfoResult;
|
|
2046
2107
|
getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
|
|
2047
2108
|
getDeviceInfo(): HeadlessWxDeviceInfoResult;
|
|
2048
|
-
getLaunchOptions():
|
|
2049
|
-
|
|
2050
|
-
[x: string]: string;
|
|
2051
|
-
};
|
|
2052
|
-
referrerInfo: {
|
|
2053
|
-
extraData: {
|
|
2054
|
-
[x: string]: never;
|
|
2055
|
-
};
|
|
2056
|
-
appId: string;
|
|
2057
|
-
};
|
|
2058
|
-
path: string;
|
|
2059
|
-
scene: number;
|
|
2060
|
-
};
|
|
2061
|
-
getEnterOptions(): {
|
|
2062
|
-
query: {
|
|
2063
|
-
[x: string]: string;
|
|
2064
|
-
};
|
|
2065
|
-
referrerInfo: {
|
|
2066
|
-
extraData: {
|
|
2067
|
-
[x: string]: never;
|
|
2068
|
-
};
|
|
2069
|
-
appId: string;
|
|
2070
|
-
};
|
|
2071
|
-
path: string;
|
|
2072
|
-
scene: number;
|
|
2073
|
-
};
|
|
2109
|
+
getLaunchOptions(): HeadlessWxLaunchOptions;
|
|
2110
|
+
getEnterOptions(): HeadlessWxLaunchOptions;
|
|
2074
2111
|
getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
|
|
2075
2112
|
getLocation(): HeadlessWxGetLocationResult;
|
|
2076
2113
|
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
@@ -2161,7 +2198,9 @@ declare class HeadlessSession {
|
|
|
2161
2198
|
navigateTo(url: string): HeadlessPageInstance;
|
|
2162
2199
|
redirectTo(url: string): HeadlessPageInstance;
|
|
2163
2200
|
navigateBack(delta?: number): HeadlessPageInstance | null;
|
|
2164
|
-
switchTab(url: string): HeadlessPageInstance;
|
|
2201
|
+
switchTab(url: string): HeadlessPageInstance | null;
|
|
2202
|
+
private prepareSwitchTab;
|
|
2203
|
+
private commitSwitchTab;
|
|
2165
2204
|
pageScrollTo(option: {
|
|
2166
2205
|
scrollTop?: number;
|
|
2167
2206
|
duration?: number;
|
|
@@ -2170,6 +2209,8 @@ declare class HeadlessSession {
|
|
|
2170
2209
|
fail?: (error: Error) => void;
|
|
2171
2210
|
complete?: () => void;
|
|
2172
2211
|
}): void;
|
|
2212
|
+
triggerAppHide(options: HeadlessWxAppHideOptions): void;
|
|
2213
|
+
triggerAppShow(options?: HeadlessWxLaunchOptions): void;
|
|
2173
2214
|
triggerPullDownRefresh(): HeadlessPageInstance;
|
|
2174
2215
|
startPullDownRefresh(): {
|
|
2175
2216
|
errMsg: string;
|
|
@@ -2202,21 +2243,22 @@ declare class HeadlessSession {
|
|
|
2202
2243
|
private createIntersectionObserver;
|
|
2203
2244
|
private createMediaQueryObserver;
|
|
2204
2245
|
}
|
|
2205
|
-
declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
|
|
2246
|
+
export declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
|
|
2206
2247
|
//#endregion
|
|
2207
2248
|
//#region src/browser/session.d.ts
|
|
2208
|
-
interface BrowserHeadlessSessionOptions {
|
|
2249
|
+
export interface BrowserHeadlessSessionOptions {
|
|
2209
2250
|
files: BrowserVirtualFiles;
|
|
2210
2251
|
globals?: Record<string, unknown>;
|
|
2211
2252
|
onRender?: () => void;
|
|
2212
2253
|
project?: HeadlessProjectDescriptor;
|
|
2213
2254
|
strictHostMocks?: boolean;
|
|
2214
2255
|
}
|
|
2215
|
-
declare class BrowserHeadlessSession {
|
|
2256
|
+
export declare class BrowserHeadlessSession {
|
|
2216
2257
|
readonly files: BrowserVirtualFiles;
|
|
2217
2258
|
readonly project: HeadlessProjectDescriptor;
|
|
2218
2259
|
private appDefinition;
|
|
2219
2260
|
private appInstance;
|
|
2261
|
+
private readonly appLifecycle;
|
|
2220
2262
|
private readonly moduleLoader;
|
|
2221
2263
|
private readonly onRender?;
|
|
2222
2264
|
private readonly registries;
|
|
@@ -2383,32 +2425,8 @@ declare class BrowserHeadlessSession {
|
|
|
2383
2425
|
getWindowInfo(): HeadlessWxWindowInfoResult;
|
|
2384
2426
|
getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
|
|
2385
2427
|
getDeviceInfo(): HeadlessWxDeviceInfoResult;
|
|
2386
|
-
getLaunchOptions():
|
|
2387
|
-
|
|
2388
|
-
[x: string]: string;
|
|
2389
|
-
};
|
|
2390
|
-
referrerInfo: {
|
|
2391
|
-
extraData: {
|
|
2392
|
-
[x: string]: never;
|
|
2393
|
-
};
|
|
2394
|
-
appId: string;
|
|
2395
|
-
};
|
|
2396
|
-
path: string;
|
|
2397
|
-
scene: number;
|
|
2398
|
-
};
|
|
2399
|
-
getEnterOptions(): {
|
|
2400
|
-
query: {
|
|
2401
|
-
[x: string]: string;
|
|
2402
|
-
};
|
|
2403
|
-
referrerInfo: {
|
|
2404
|
-
extraData: {
|
|
2405
|
-
[x: string]: never;
|
|
2406
|
-
};
|
|
2407
|
-
appId: string;
|
|
2408
|
-
};
|
|
2409
|
-
path: string;
|
|
2410
|
-
scene: number;
|
|
2411
|
-
};
|
|
2428
|
+
getLaunchOptions(): HeadlessWxLaunchOptions;
|
|
2429
|
+
getEnterOptions(): HeadlessWxLaunchOptions;
|
|
2412
2430
|
getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
|
|
2413
2431
|
getLocation(): HeadlessWxGetLocationResult;
|
|
2414
2432
|
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
@@ -2542,12 +2560,16 @@ declare class BrowserHeadlessSession {
|
|
|
2542
2560
|
navigateTo(url: string): HeadlessPageInstance;
|
|
2543
2561
|
redirectTo(url: string): HeadlessPageInstance;
|
|
2544
2562
|
navigateBack(delta?: number): HeadlessPageInstance | null;
|
|
2545
|
-
switchTab(url: string): HeadlessPageInstance;
|
|
2563
|
+
switchTab(url: string): HeadlessPageInstance | null;
|
|
2564
|
+
private prepareSwitchTab;
|
|
2565
|
+
private commitSwitchTab;
|
|
2546
2566
|
pageScrollTo(option: {
|
|
2547
2567
|
duration?: number;
|
|
2548
2568
|
selector?: string;
|
|
2549
2569
|
scrollTop?: number;
|
|
2550
2570
|
}): void;
|
|
2571
|
+
triggerAppHide(options: HeadlessWxAppHideOptions): void;
|
|
2572
|
+
triggerAppShow(options?: HeadlessWxLaunchOptions): void;
|
|
2551
2573
|
triggerPullDownRefresh(): HeadlessPageInstance;
|
|
2552
2574
|
startPullDownRefresh(): {
|
|
2553
2575
|
errMsg: string;
|
|
@@ -2579,18 +2601,18 @@ declare class BrowserHeadlessSession {
|
|
|
2579
2601
|
private createIntersectionObserver;
|
|
2580
2602
|
private createMediaQueryObserver;
|
|
2581
2603
|
}
|
|
2582
|
-
declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
|
|
2604
|
+
export declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
|
|
2583
2605
|
//#endregion
|
|
2584
2606
|
//#region src/testing/pageWait.d.ts
|
|
2585
|
-
interface HeadlessTestingWaitOptions {
|
|
2607
|
+
export interface HeadlessTestingWaitOptions {
|
|
2586
2608
|
interval?: number;
|
|
2587
2609
|
timeout?: number;
|
|
2588
2610
|
}
|
|
2589
|
-
type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
|
|
2590
|
-
interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
|
|
2611
|
+
export type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
|
|
2612
|
+
export interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
|
|
2591
2613
|
state?: 'attached' | 'detached';
|
|
2592
2614
|
}
|
|
2593
|
-
interface HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle> {
|
|
2615
|
+
export interface HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle> {
|
|
2594
2616
|
data: (path?: string) => Promise<unknown>;
|
|
2595
2617
|
findOne: (selector: string) => Promise<NodeHandle | null>;
|
|
2596
2618
|
selectComponent: (selector: string) => Promise<ScopeHandle | null>;
|
|
@@ -2598,20 +2620,20 @@ interface HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle> {
|
|
|
2598
2620
|
waitFor: (ms?: number) => Promise<void>;
|
|
2599
2621
|
wxml: () => Promise<string>;
|
|
2600
2622
|
}
|
|
2601
|
-
declare function waitForPageSelector<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<NonNullable<Awaited<NodeHandle>> | null>;
|
|
2602
|
-
declare function waitForPageComponent<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitOptions): Promise<NonNullable<Awaited<ScopeHandle>>>;
|
|
2603
|
-
declare function waitForPageComponents<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<ScopeHandle[]>;
|
|
2604
|
-
declare function waitForPageText<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
|
|
2605
|
-
declare function waitForPageTextGone<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
|
|
2606
|
-
declare function waitForPageData<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, path: string, matcher: HeadlessTestingDataMatcher, hasMatcher: boolean, options?: HeadlessTestingWaitOptions): Promise<{}>;
|
|
2623
|
+
export declare function waitForPageSelector<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<NonNullable<Awaited<NodeHandle>> | null>;
|
|
2624
|
+
export declare function waitForPageComponent<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitOptions): Promise<NonNullable<Awaited<ScopeHandle>>>;
|
|
2625
|
+
export declare function waitForPageComponents<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<ScopeHandle[]>;
|
|
2626
|
+
export declare function waitForPageText<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
|
|
2627
|
+
export declare function waitForPageTextGone<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
|
|
2628
|
+
export declare function waitForPageData<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, path: string, matcher: HeadlessTestingDataMatcher, hasMatcher: boolean, options?: HeadlessTestingWaitOptions): Promise<{}>;
|
|
2607
2629
|
//#endregion
|
|
2608
2630
|
//#region src/view/eventBinding.d.ts
|
|
2609
|
-
interface MiniProgramEventBinding {
|
|
2631
|
+
export interface MiniProgramEventBinding {
|
|
2610
2632
|
method: string;
|
|
2611
2633
|
stopAfter: boolean;
|
|
2612
2634
|
}
|
|
2613
|
-
declare function collectMiniProgramEventBindings(attributes?: Record<string, string>): Map<string, MiniProgramEventBinding>;
|
|
2614
|
-
declare function resolveMiniProgramEventBinding(attributes: Record<string, string> | undefined, eventName: string): MiniProgramEventBinding | null;
|
|
2635
|
+
export declare function collectMiniProgramEventBindings(attributes?: Record<string, string>): Map<string, MiniProgramEventBinding>;
|
|
2636
|
+
export declare function resolveMiniProgramEventBinding(attributes: Record<string, string> | undefined, eventName: string): MiniProgramEventBinding | null;
|
|
2615
2637
|
//#endregion
|
|
2616
2638
|
//#region src/view/nodeHandle.d.ts
|
|
2617
2639
|
interface DomNodeLike$3 {
|
|
@@ -2654,13 +2676,15 @@ interface HeadlessTestingNodeInteractionHandlers {
|
|
|
2654
2676
|
};
|
|
2655
2677
|
ownerScopeId: (scopeId: string | null) => string | null;
|
|
2656
2678
|
}
|
|
2657
|
-
declare class HeadlessTestingNodeHandle {
|
|
2679
|
+
export declare class HeadlessTestingNodeHandle {
|
|
2658
2680
|
private readonly node;
|
|
2659
2681
|
private readonly interactions?;
|
|
2660
2682
|
constructor(node: DomNodeLike$3, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
|
|
2661
2683
|
private assertActive;
|
|
2684
|
+
private query;
|
|
2662
2685
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
2663
2686
|
$$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
2687
|
+
getElementsByXpath(expression: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
2664
2688
|
attr(name: string): Promise<string | undefined>;
|
|
2665
2689
|
dataset(): Promise<Record<string, string>>;
|
|
2666
2690
|
scope(): Promise<{
|
|
@@ -2701,11 +2725,11 @@ interface DomNodeLike$2 {
|
|
|
2701
2725
|
parent?: DomNodeLike$2 | null;
|
|
2702
2726
|
type?: string;
|
|
2703
2727
|
}
|
|
2704
|
-
interface RenderedPageTree {
|
|
2728
|
+
export interface RenderedPageTree {
|
|
2705
2729
|
root: DomNodeLike$2;
|
|
2706
2730
|
wxml: string;
|
|
2707
2731
|
}
|
|
2708
|
-
declare function renderPageTree(project: HeadlessProjectDescriptor, page: HeadlessPageInstance): RenderedPageTree;
|
|
2732
|
+
export declare function renderPageTree(project: HeadlessProjectDescriptor, page: HeadlessPageInstance): RenderedPageTree;
|
|
2709
2733
|
//#endregion
|
|
2710
2734
|
//#region src/view/selectorQuery.d.ts
|
|
2711
2735
|
interface DomNodeLike$1 {
|
|
@@ -2716,15 +2740,15 @@ interface DomNodeLike$1 {
|
|
|
2716
2740
|
parent?: DomNodeLike$1 | null;
|
|
2717
2741
|
type?: string;
|
|
2718
2742
|
}
|
|
2719
|
-
interface HeadlessSelectorQueryResolverOptions {
|
|
2743
|
+
export interface HeadlessSelectorQueryResolverOptions {
|
|
2720
2744
|
page: HeadlessPageInstance;
|
|
2721
2745
|
resolveContext?: (node: DomNodeLike$1) => unknown;
|
|
2722
2746
|
root: DomNodeLike$1;
|
|
2723
2747
|
windowInfo: HeadlessWxWindowInfoResult;
|
|
2724
2748
|
}
|
|
2725
|
-
declare function resolveSelectorScrollTop(root: DomNodeLike$1, selector?: string | null): number | null;
|
|
2726
|
-
declare function executeSelectorQueryRequests(requests: HeadlessWxSelectorQueryRequest[], options: HeadlessSelectorQueryResolverOptions): (Record<string, any> | Record<string, any>[] | null)[];
|
|
2727
|
-
declare function resolveSelectorQueryScopeRoot(root: DomNodeLike$1, scopeId?: string | null): DomNodeLike$1;
|
|
2749
|
+
export declare function resolveSelectorScrollTop(root: DomNodeLike$1, selector?: string | null): number | null;
|
|
2750
|
+
export declare function executeSelectorQueryRequests(requests: HeadlessWxSelectorQueryRequest[], options: HeadlessSelectorQueryResolverOptions): (Record<string, any> | Record<string, any>[] | null)[];
|
|
2751
|
+
export declare function resolveSelectorQueryScopeRoot(root: DomNodeLike$1, scopeId?: string | null): DomNodeLike$1;
|
|
2728
2752
|
//#endregion
|
|
2729
2753
|
//#region src/view/selectors.d.ts
|
|
2730
2754
|
interface DomNodeLike {
|
|
@@ -2735,22 +2759,22 @@ interface DomNodeLike {
|
|
|
2735
2759
|
parent?: DomNodeLike | null;
|
|
2736
2760
|
type?: string;
|
|
2737
2761
|
}
|
|
2738
|
-
declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
|
|
2762
|
+
export declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
|
|
2739
2763
|
//#endregion
|
|
2740
2764
|
//#region src/testing/rendered.d.ts
|
|
2741
|
-
interface HeadlessTestingPageQueryOptions extends HeadlessTestingWaitOptions {
|
|
2765
|
+
export interface HeadlessTestingPageQueryOptions extends HeadlessTestingWaitOptions {
|
|
2742
2766
|
componentSelectors?: string[];
|
|
2743
2767
|
fallback?: boolean;
|
|
2744
2768
|
routeOnly?: boolean;
|
|
2745
2769
|
}
|
|
2746
|
-
interface HeadlessTestingRenderedOptions extends HeadlessTestingWaitOptions {
|
|
2770
|
+
export interface HeadlessTestingRenderedOptions extends HeadlessTestingWaitOptions {
|
|
2747
2771
|
componentSelectors?: string[];
|
|
2748
2772
|
dataset?: Record<string, boolean | number | string>;
|
|
2749
2773
|
predicate?: (wxml: string) => boolean;
|
|
2750
2774
|
selector?: string;
|
|
2751
2775
|
text?: string;
|
|
2752
2776
|
}
|
|
2753
|
-
interface HeadlessTestingRenderedNodeSnapshot {
|
|
2777
|
+
export interface HeadlessTestingRenderedNodeSnapshot {
|
|
2754
2778
|
bottom?: number;
|
|
2755
2779
|
dataset?: Record<string, unknown>;
|
|
2756
2780
|
height?: number;
|
|
@@ -2760,19 +2784,19 @@ interface HeadlessTestingRenderedNodeSnapshot {
|
|
|
2760
2784
|
top?: number;
|
|
2761
2785
|
width?: number;
|
|
2762
2786
|
}
|
|
2763
|
-
type HeadlessTestingRenderedSelectorNodesSnapshot = Record<string, HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2764
|
-
interface HeadlessTestingRenderedPageAccess {
|
|
2787
|
+
export type HeadlessTestingRenderedSelectorNodesSnapshot = Record<string, HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2788
|
+
export interface HeadlessTestingRenderedPageAccess {
|
|
2765
2789
|
assertActive: () => void;
|
|
2766
2790
|
findAll: (selector: string) => Promise<HeadlessTestingNodeHandle[]>;
|
|
2767
2791
|
waitFor: (ms?: number) => Promise<void>;
|
|
2768
2792
|
wxml: () => Promise<string>;
|
|
2769
2793
|
}
|
|
2770
|
-
declare function readRenderedNodes(access: HeadlessTestingRenderedPageAccess, selector: string, _options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2771
|
-
declare function readRenderedSelectorNodes(access: HeadlessTestingRenderedPageAccess, selectors: string[], options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedSelectorNodesSnapshot>;
|
|
2772
|
-
declare function waitForRenderedPage(access: HeadlessTestingRenderedPageAccess, options?: HeadlessTestingRenderedOptions): Promise<string>;
|
|
2794
|
+
export declare function readRenderedNodes(access: HeadlessTestingRenderedPageAccess, selector: string, _options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2795
|
+
export declare function readRenderedSelectorNodes(access: HeadlessTestingRenderedPageAccess, selectors: string[], options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedSelectorNodesSnapshot>;
|
|
2796
|
+
export declare function waitForRenderedPage(access: HeadlessTestingRenderedPageAccess, options?: HeadlessTestingRenderedOptions): Promise<string>;
|
|
2773
2797
|
//#endregion
|
|
2774
2798
|
//#region src/testing/logicalSnapshot.d.ts
|
|
2775
|
-
interface HeadlessTestingLogicalNode {
|
|
2799
|
+
export interface HeadlessTestingLogicalNode {
|
|
2776
2800
|
attrs: Record<string, string>;
|
|
2777
2801
|
children: HeadlessTestingLogicalNode[];
|
|
2778
2802
|
nodeId?: string;
|
|
@@ -2780,26 +2804,28 @@ interface HeadlessTestingLogicalNode {
|
|
|
2780
2804
|
text: string;
|
|
2781
2805
|
type: 'element' | 'text';
|
|
2782
2806
|
}
|
|
2783
|
-
interface HeadlessTestingPageSnapshot {
|
|
2807
|
+
export interface HeadlessTestingPageSnapshot {
|
|
2784
2808
|
data: Record<string, any>;
|
|
2785
2809
|
path: string;
|
|
2786
2810
|
query: Record<string, string>;
|
|
2787
2811
|
root: HeadlessTestingLogicalNode;
|
|
2788
2812
|
wxml: string;
|
|
2789
2813
|
}
|
|
2790
|
-
declare function createLogicalNode(node: any): HeadlessTestingLogicalNode;
|
|
2814
|
+
export declare function createLogicalNode(node: any): HeadlessTestingLogicalNode;
|
|
2791
2815
|
//#endregion
|
|
2792
2816
|
//#region src/testing/pageHandle.d.ts
|
|
2793
|
-
interface HeadlessTestingPageCallMethodOptions {
|
|
2817
|
+
export interface HeadlessTestingPageCallMethodOptions {
|
|
2794
2818
|
fallback?: boolean;
|
|
2795
2819
|
routeOnly?: boolean;
|
|
2796
2820
|
timeout?: number;
|
|
2797
2821
|
}
|
|
2798
|
-
declare class HeadlessTestingPageHandle {
|
|
2822
|
+
export declare class HeadlessTestingPageHandle {
|
|
2799
2823
|
private readonly project;
|
|
2800
2824
|
private readonly page;
|
|
2801
2825
|
private readonly session?;
|
|
2802
2826
|
constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance, session?: HeadlessSession | undefined);
|
|
2827
|
+
/** 返回底层页面实例身份;重新获取 handle 不会改变该身份。 */
|
|
2828
|
+
get pageId(): number;
|
|
2803
2829
|
get path(): string;
|
|
2804
2830
|
get query(): {
|
|
2805
2831
|
[x: string]: string;
|
|
@@ -2810,11 +2836,13 @@ declare class HeadlessTestingPageHandle {
|
|
|
2810
2836
|
callMethod(methodName: string, ...args: any[]): Promise<any>;
|
|
2811
2837
|
callMethodWithOptions(methodName: string, options?: HeadlessTestingPageCallMethodOptions, ...args: any[]): Promise<any>;
|
|
2812
2838
|
data(path?: string): Promise<any>;
|
|
2839
|
+
setData(data: Record<string, unknown>): Promise<void>;
|
|
2813
2840
|
selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
|
|
2814
2841
|
selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
|
|
2815
2842
|
waitFor(ms?: number): Promise<void>;
|
|
2816
2843
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
2817
2844
|
$$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
2845
|
+
getElementsByXpath(expression: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
2818
2846
|
renderedNodes(selector: string, options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2819
2847
|
renderedSelectorNodes(selectors: string[], options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedSelectorNodesSnapshot>;
|
|
2820
2848
|
waitForRendered(options?: HeadlessTestingRenderedOptions): Promise<string>;
|
|
@@ -2831,7 +2859,7 @@ declare class HeadlessTestingPageHandle {
|
|
|
2831
2859
|
}
|
|
2832
2860
|
//#endregion
|
|
2833
2861
|
//#region src/testing/sessionHandle/scope.d.ts
|
|
2834
|
-
declare class HeadlessTestingScopeHandle {
|
|
2862
|
+
export declare class HeadlessTestingScopeHandle {
|
|
2835
2863
|
readonly scopeId: string;
|
|
2836
2864
|
private readonly project;
|
|
2837
2865
|
private readonly session;
|
|
@@ -2881,11 +2909,15 @@ interface HeadlessTestingProtocolOptions {
|
|
|
2881
2909
|
timeout?: number;
|
|
2882
2910
|
}
|
|
2883
2911
|
type HeadlessTestingEvaluator<T = unknown> = ((...args: any[]) => T | PromiseLike<T>) | string;
|
|
2884
|
-
|
|
2912
|
+
interface HeadlessTestingToolInfo {
|
|
2913
|
+
version: 'mpcore-simulator';
|
|
2914
|
+
}
|
|
2915
|
+
export declare class HeadlessTestingSessionHandle {
|
|
2885
2916
|
private readonly project;
|
|
2886
2917
|
private readonly session;
|
|
2887
2918
|
constructor(project: HeadlessProjectDescriptor, session: HeadlessSession);
|
|
2888
2919
|
close(): Promise<void>;
|
|
2920
|
+
toolInfo(): Promise<HeadlessTestingToolInfo>;
|
|
2889
2921
|
on(eventName: string, handler: (...args: any[]) => void): this;
|
|
2890
2922
|
removeListener(eventName: string, handler: (...args: any[]) => void): this;
|
|
2891
2923
|
off(eventName: string, handler: (...args: any[]) => void): this;
|
|
@@ -2925,18 +2957,23 @@ declare class HeadlessTestingSessionHandle {
|
|
|
2925
2957
|
switchTab(route: string): Promise<HeadlessTestingPageHandle>;
|
|
2926
2958
|
waitForCurrentPage(route?: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingPageHandle>;
|
|
2927
2959
|
pageScrollTo(scrollTop: number): Promise<void>;
|
|
2960
|
+
triggerAppHide(options: HeadlessWxAppHideOptions): Promise<void>;
|
|
2961
|
+
triggerAppShow(options?: HeadlessWxLaunchOptions): Promise<void>;
|
|
2928
2962
|
triggerPullDownRefresh(): Promise<void>;
|
|
2929
2963
|
triggerReachBottom(): Promise<void>;
|
|
2930
2964
|
triggerResize(options: Record<string, any>): Promise<void>;
|
|
2931
2965
|
triggerRouteDone(options?: Record<string, any>): Promise<void>;
|
|
2966
|
+
private invokeNavigation;
|
|
2932
2967
|
private requireCurrentPage;
|
|
2933
2968
|
private evaluateInRuntime;
|
|
2934
2969
|
}
|
|
2935
2970
|
//#endregion
|
|
2936
2971
|
//#region src/testing/launch.d.ts
|
|
2937
|
-
interface HeadlessTestingLaunchOptions {
|
|
2972
|
+
export interface HeadlessTestingLaunchOptions {
|
|
2938
2973
|
projectPath: string;
|
|
2974
|
+
configureSession?: (session: HeadlessSession) => void | Promise<void>;
|
|
2975
|
+
onSessionCreated?: (session: HeadlessTestingSessionHandle) => void | Promise<void>;
|
|
2939
2976
|
}
|
|
2940
|
-
declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
|
|
2977
|
+
export declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
|
|
2941
2978
|
//#endregion
|
|
2942
|
-
export {
|
|
2979
|
+
export type { BrowserRenderedPageTree, BrowserRendererContext, CreateComponentInstanceOptions, HeadlessComponentInstance, HeadlessTestingToolInfo, HeadlessWxGetLogManagerOption, HeadlessWxLogManager, RuntimeRenderedPageTree, RuntimeRendererContext };
|