@mpcore/simulator 0.1.4 → 0.3.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 +4 -0
- package/dist/index.d.mts +522 -180
- package/dist/index.mjs +1930 -690
- package/package.json +4 -2
package/dist/index.d.mts
CHANGED
|
@@ -18,14 +18,25 @@ interface HeadlessHostRegistries {
|
|
|
18
18
|
declare function createHostRegistries(): HeadlessHostRegistries;
|
|
19
19
|
declare function registerAppDefinition(registries: HeadlessHostRegistries, definition: HeadlessAppDefinition): HeadlessAppDefinition;
|
|
20
20
|
declare function registerPageDefinition(registries: HeadlessHostRegistries, definition: HeadlessPageDefinition): HeadlessPageDefinition;
|
|
21
|
-
declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition):
|
|
21
|
+
declare function registerComponentDefinition(registries: HeadlessHostRegistries, definition: HeadlessComponentDefinition): HeadlessPageDefinition;
|
|
22
|
+
declare function registerExportedComponentDefinition(registries: HeadlessHostRegistries, id: string, moduleExports: Record<string, any>, registeredDefinition?: HeadlessComponentDefinition): HeadlessComponentDefinition | null;
|
|
22
23
|
//#endregion
|
|
23
|
-
//#region src/host/wx.d.ts
|
|
24
|
+
//#region src/host/wx/core.d.ts
|
|
24
25
|
interface HeadlessWxCallbackOption<TResult = void> {
|
|
25
26
|
complete?: (result?: TResult) => void;
|
|
26
27
|
fail?: (error: Error) => void;
|
|
27
28
|
success?: (result: TResult) => void;
|
|
28
29
|
}
|
|
30
|
+
interface HeadlessWxLoadFontFaceResult {
|
|
31
|
+
errMsg: string;
|
|
32
|
+
}
|
|
33
|
+
interface HeadlessWxLoadFontFaceOption extends HeadlessWxCallbackOption<HeadlessWxLoadFontFaceResult> {
|
|
34
|
+
descriptors?: Record<string, string>;
|
|
35
|
+
family: string;
|
|
36
|
+
global?: boolean;
|
|
37
|
+
scopes?: string[];
|
|
38
|
+
source: string;
|
|
39
|
+
}
|
|
29
40
|
interface HeadlessWxNavigateOption extends HeadlessWxCallbackOption {
|
|
30
41
|
url: string;
|
|
31
42
|
}
|
|
@@ -218,6 +229,7 @@ interface HeadlessWxSelectorQueryRequest {
|
|
|
218
229
|
interface HeadlessWxSelectorQueryNode {
|
|
219
230
|
boundingClientRect: (callback?: (result: HeadlessWxSelectorQueryBoundingClientRectResult | HeadlessWxSelectorQueryBoundingClientRectResult[] | null) => void) => HeadlessWxSelectorQuery;
|
|
220
231
|
fields: (fields: HeadlessWxSelectorQueryFieldsOption, callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
|
|
232
|
+
node: (callback?: (result: Record<string, any> | Record<string, any>[] | null) => void) => HeadlessWxSelectorQuery;
|
|
221
233
|
scrollOffset: (callback?: (result: HeadlessWxSelectorQueryScrollOffsetResult | HeadlessWxSelectorQueryScrollOffsetResult[] | null) => void) => HeadlessWxSelectorQuery;
|
|
222
234
|
}
|
|
223
235
|
interface HeadlessWxSelectorQuery {
|
|
@@ -243,6 +255,16 @@ interface HeadlessWxGetNetworkTypeResult {
|
|
|
243
255
|
errMsg: string;
|
|
244
256
|
networkType: HeadlessWxNetworkType;
|
|
245
257
|
}
|
|
258
|
+
interface HeadlessWxGetLocationResult {
|
|
259
|
+
accuracy: number;
|
|
260
|
+
altitude: number;
|
|
261
|
+
errMsg: string;
|
|
262
|
+
horizontalAccuracy: number;
|
|
263
|
+
latitude: number;
|
|
264
|
+
longitude: number;
|
|
265
|
+
speed: number;
|
|
266
|
+
verticalAccuracy: number;
|
|
267
|
+
}
|
|
246
268
|
interface HeadlessWxNetworkStatusChangeResult {
|
|
247
269
|
isConnected: boolean;
|
|
248
270
|
networkType: HeadlessWxNetworkType;
|
|
@@ -255,6 +277,8 @@ interface HeadlessWxSystemInfoResult {
|
|
|
255
277
|
model: string;
|
|
256
278
|
pixelRatio: number;
|
|
257
279
|
platform: string;
|
|
280
|
+
safeArea: HeadlessWxSafeArea;
|
|
281
|
+
safeAreaInsets: HeadlessWxSafeAreaInsets;
|
|
258
282
|
screenHeight: number;
|
|
259
283
|
screenWidth: number;
|
|
260
284
|
system: string;
|
|
@@ -262,6 +286,20 @@ interface HeadlessWxSystemInfoResult {
|
|
|
262
286
|
windowHeight: number;
|
|
263
287
|
windowWidth: number;
|
|
264
288
|
}
|
|
289
|
+
interface HeadlessWxSafeArea {
|
|
290
|
+
bottom: number;
|
|
291
|
+
height: number;
|
|
292
|
+
left: number;
|
|
293
|
+
right: number;
|
|
294
|
+
top: number;
|
|
295
|
+
width: number;
|
|
296
|
+
}
|
|
297
|
+
interface HeadlessWxSafeAreaInsets {
|
|
298
|
+
bottom: number;
|
|
299
|
+
left: number;
|
|
300
|
+
right: number;
|
|
301
|
+
top: number;
|
|
302
|
+
}
|
|
265
303
|
interface HeadlessWxAppBaseInfoResult {
|
|
266
304
|
SDKVersion: string;
|
|
267
305
|
enableDebug: boolean;
|
|
@@ -272,8 +310,21 @@ interface HeadlessWxAppBaseInfoResult {
|
|
|
272
310
|
platform: string;
|
|
273
311
|
version: string;
|
|
274
312
|
}
|
|
313
|
+
interface HeadlessWxDeviceInfoResult {
|
|
314
|
+
abi: string;
|
|
315
|
+
benchmarkLevel: number;
|
|
316
|
+
brand: string;
|
|
317
|
+
cpuType: string;
|
|
318
|
+
deviceAbi: string;
|
|
319
|
+
memorySize: number;
|
|
320
|
+
model: string;
|
|
321
|
+
platform: string;
|
|
322
|
+
system: string;
|
|
323
|
+
}
|
|
275
324
|
interface HeadlessWxWindowInfoResult {
|
|
276
325
|
pixelRatio: number;
|
|
326
|
+
safeArea: HeadlessWxSafeArea;
|
|
327
|
+
safeAreaInsets: HeadlessWxSafeAreaInsets;
|
|
277
328
|
screenHeight: number;
|
|
278
329
|
screenWidth: number;
|
|
279
330
|
statusBarHeight: number;
|
|
@@ -317,9 +368,115 @@ interface HeadlessWxGetStorageOption extends HeadlessWxCallbackOption<HeadlessWx
|
|
|
317
368
|
}
|
|
318
369
|
interface HeadlessWxGetStorageInfoOption extends HeadlessWxCallbackOption<HeadlessWxStorageInfoResult> {}
|
|
319
370
|
interface HeadlessWxGetNetworkTypeOption extends HeadlessWxCallbackOption<HeadlessWxGetNetworkTypeResult> {}
|
|
371
|
+
interface HeadlessWxGetLocationOption extends HeadlessWxCallbackOption<HeadlessWxGetLocationResult> {
|
|
372
|
+
altitude?: boolean;
|
|
373
|
+
highAccuracyExpireTime?: number;
|
|
374
|
+
isHighAccuracy?: boolean;
|
|
375
|
+
type?: 'gcj02' | 'wgs84';
|
|
376
|
+
}
|
|
320
377
|
interface HeadlessWxGetSystemInfoOption extends HeadlessWxCallbackOption<HeadlessWxSystemInfoResult> {}
|
|
321
378
|
interface HeadlessWxGetWindowInfoOption extends HeadlessWxCallbackOption<HeadlessWxWindowInfoResult> {}
|
|
322
379
|
interface HeadlessWxGetAppBaseInfoOption extends HeadlessWxCallbackOption<HeadlessWxAppBaseInfoResult> {}
|
|
380
|
+
//#endregion
|
|
381
|
+
//#region src/host/wx/eventBus.d.ts
|
|
382
|
+
type HeadlessUniEventHandler = (...args: any[]) => void;
|
|
383
|
+
interface HeadlessUniEventBus {
|
|
384
|
+
$emit: (eventName: string, ...args: any[]) => void;
|
|
385
|
+
$off: (eventName?: string, handler?: HeadlessUniEventHandler) => void;
|
|
386
|
+
$on: (eventName: string, handler: HeadlessUniEventHandler) => void;
|
|
387
|
+
$once: (eventName: string, handler: HeadlessUniEventHandler) => void;
|
|
388
|
+
}
|
|
389
|
+
declare function createHeadlessUniEventBus(): HeadlessUniEventBus;
|
|
390
|
+
//#endregion
|
|
391
|
+
//#region src/host/wx/fileSystem.d.ts
|
|
392
|
+
interface HeadlessWxFileSystemResult {
|
|
393
|
+
errMsg: string;
|
|
394
|
+
}
|
|
395
|
+
interface HeadlessWxReadFileSuccessResult {
|
|
396
|
+
data: string;
|
|
397
|
+
errMsg: string;
|
|
398
|
+
}
|
|
399
|
+
interface HeadlessWxReadFileOption extends HeadlessWxCallbackOption<HeadlessWxReadFileSuccessResult> {
|
|
400
|
+
encoding?: string;
|
|
401
|
+
filePath: string;
|
|
402
|
+
}
|
|
403
|
+
interface HeadlessWxWriteFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
404
|
+
data: string;
|
|
405
|
+
encoding?: string;
|
|
406
|
+
filePath: string;
|
|
407
|
+
}
|
|
408
|
+
interface HeadlessWxAccessFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
409
|
+
path: string;
|
|
410
|
+
}
|
|
411
|
+
interface HeadlessWxAppendFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
412
|
+
data: string;
|
|
413
|
+
encoding?: string;
|
|
414
|
+
filePath: string;
|
|
415
|
+
}
|
|
416
|
+
interface HeadlessWxUnlinkOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
417
|
+
filePath: string;
|
|
418
|
+
}
|
|
419
|
+
interface HeadlessWxCopyFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
420
|
+
destPath: string;
|
|
421
|
+
srcPath: string;
|
|
422
|
+
}
|
|
423
|
+
interface HeadlessWxRenameOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
424
|
+
newPath: string;
|
|
425
|
+
oldPath: string;
|
|
426
|
+
}
|
|
427
|
+
interface HeadlessWxMkdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
428
|
+
dirPath: string;
|
|
429
|
+
recursive?: boolean;
|
|
430
|
+
}
|
|
431
|
+
interface HeadlessWxRmdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
432
|
+
dirPath: string;
|
|
433
|
+
recursive?: boolean;
|
|
434
|
+
}
|
|
435
|
+
interface HeadlessWxReadDirSuccessResult {
|
|
436
|
+
errMsg: string;
|
|
437
|
+
files: string[];
|
|
438
|
+
}
|
|
439
|
+
interface HeadlessWxReadDirOption extends HeadlessWxCallbackOption<HeadlessWxReadDirSuccessResult> {
|
|
440
|
+
dirPath: string;
|
|
441
|
+
}
|
|
442
|
+
interface HeadlessWxStats {
|
|
443
|
+
isDirectory: () => boolean;
|
|
444
|
+
isFile: () => boolean;
|
|
445
|
+
size: number;
|
|
446
|
+
}
|
|
447
|
+
interface HeadlessWxStatSuccessResult {
|
|
448
|
+
errMsg: string;
|
|
449
|
+
stats: HeadlessWxStats;
|
|
450
|
+
}
|
|
451
|
+
interface HeadlessWxStatOption extends HeadlessWxCallbackOption<HeadlessWxStatSuccessResult> {
|
|
452
|
+
path: string;
|
|
453
|
+
}
|
|
454
|
+
interface HeadlessWxFileSystemManager {
|
|
455
|
+
access: (option: HeadlessWxAccessFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
456
|
+
accessSync: (path: string) => void;
|
|
457
|
+
appendFile: (option: HeadlessWxAppendFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
458
|
+
appendFileSync: (filePath: string, data: string, encoding?: string) => void;
|
|
459
|
+
copyFile: (option: HeadlessWxCopyFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
460
|
+
copyFileSync: (srcPath: string, destPath: string) => void;
|
|
461
|
+
mkdir: (option: HeadlessWxMkdirOption) => HeadlessWxFileSystemResult | undefined;
|
|
462
|
+
mkdirSync: (dirPath: string, recursive?: boolean) => void;
|
|
463
|
+
readFile: (option: HeadlessWxReadFileOption) => HeadlessWxReadFileSuccessResult | undefined;
|
|
464
|
+
readFileSync: (filePath: string, encoding?: string) => string;
|
|
465
|
+
readdir: (option: HeadlessWxReadDirOption) => HeadlessWxReadDirSuccessResult | undefined;
|
|
466
|
+
readdirSync: (dirPath: string) => string[];
|
|
467
|
+
rmdir: (option: HeadlessWxRmdirOption) => HeadlessWxFileSystemResult | undefined;
|
|
468
|
+
rmdirSync: (dirPath: string, recursive?: boolean) => void;
|
|
469
|
+
rename: (option: HeadlessWxRenameOption) => HeadlessWxFileSystemResult | undefined;
|
|
470
|
+
renameSync: (oldPath: string, newPath: string) => void;
|
|
471
|
+
stat: (option: HeadlessWxStatOption) => HeadlessWxStatSuccessResult | undefined;
|
|
472
|
+
statSync: (path: string) => HeadlessWxStats;
|
|
473
|
+
unlink: (option: HeadlessWxUnlinkOption) => HeadlessWxFileSystemResult | undefined;
|
|
474
|
+
unlinkSync: (filePath: string) => void;
|
|
475
|
+
writeFile: (option: HeadlessWxWriteFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
476
|
+
writeFileSync: (filePath: string, data: string, encoding?: string) => void;
|
|
477
|
+
}
|
|
478
|
+
//#endregion
|
|
479
|
+
//#region src/host/wx/media.d.ts
|
|
323
480
|
interface HeadlessWxGetImageInfoResult {
|
|
324
481
|
errMsg: string;
|
|
325
482
|
height: number;
|
|
@@ -639,116 +796,19 @@ interface HeadlessWxRemoveSavedFileOption extends HeadlessWxCallbackOption<{
|
|
|
639
796
|
}> {
|
|
640
797
|
filePath: string;
|
|
641
798
|
}
|
|
642
|
-
interface
|
|
643
|
-
|
|
644
|
-
}
|
|
645
|
-
interface HeadlessWxReadFileSuccessResult {
|
|
646
|
-
data: string;
|
|
647
|
-
errMsg: string;
|
|
648
|
-
}
|
|
649
|
-
interface HeadlessWxReadFileOption extends HeadlessWxCallbackOption<HeadlessWxReadFileSuccessResult> {
|
|
650
|
-
encoding?: string;
|
|
651
|
-
filePath: string;
|
|
652
|
-
}
|
|
653
|
-
interface HeadlessWxWriteFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
654
|
-
data: string;
|
|
655
|
-
encoding?: string;
|
|
656
|
-
filePath: string;
|
|
657
|
-
}
|
|
658
|
-
interface HeadlessWxAccessFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
659
|
-
path: string;
|
|
660
|
-
}
|
|
661
|
-
interface HeadlessWxAppendFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
662
|
-
data: string;
|
|
663
|
-
encoding?: string;
|
|
664
|
-
filePath: string;
|
|
665
|
-
}
|
|
666
|
-
interface HeadlessWxUnlinkOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
667
|
-
filePath: string;
|
|
668
|
-
}
|
|
669
|
-
interface HeadlessWxCopyFileOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
670
|
-
destPath: string;
|
|
671
|
-
srcPath: string;
|
|
672
|
-
}
|
|
673
|
-
interface HeadlessWxRenameOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
674
|
-
newPath: string;
|
|
675
|
-
oldPath: string;
|
|
676
|
-
}
|
|
677
|
-
interface HeadlessWxMkdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
678
|
-
dirPath: string;
|
|
679
|
-
recursive?: boolean;
|
|
680
|
-
}
|
|
681
|
-
interface HeadlessWxRmdirOption extends HeadlessWxCallbackOption<HeadlessWxFileSystemResult> {
|
|
682
|
-
dirPath: string;
|
|
683
|
-
recursive?: boolean;
|
|
684
|
-
}
|
|
685
|
-
interface HeadlessWxReadDirSuccessResult {
|
|
686
|
-
errMsg: string;
|
|
687
|
-
files: string[];
|
|
688
|
-
}
|
|
689
|
-
interface HeadlessWxReadDirOption extends HeadlessWxCallbackOption<HeadlessWxReadDirSuccessResult> {
|
|
690
|
-
dirPath: string;
|
|
691
|
-
}
|
|
692
|
-
interface HeadlessWxStats {
|
|
693
|
-
isDirectory: () => boolean;
|
|
694
|
-
isFile: () => boolean;
|
|
695
|
-
size: number;
|
|
696
|
-
}
|
|
697
|
-
interface HeadlessWxStatSuccessResult {
|
|
698
|
-
errMsg: string;
|
|
699
|
-
stats: HeadlessWxStats;
|
|
700
|
-
}
|
|
701
|
-
interface HeadlessWxStatOption extends HeadlessWxCallbackOption<HeadlessWxStatSuccessResult> {
|
|
702
|
-
path: string;
|
|
703
|
-
}
|
|
704
|
-
interface HeadlessWxFileSystemManager {
|
|
705
|
-
access: (option: HeadlessWxAccessFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
706
|
-
accessSync: (path: string) => void;
|
|
707
|
-
appendFile: (option: HeadlessWxAppendFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
708
|
-
appendFileSync: (filePath: string, data: string, encoding?: string) => void;
|
|
709
|
-
copyFile: (option: HeadlessWxCopyFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
710
|
-
copyFileSync: (srcPath: string, destPath: string) => void;
|
|
711
|
-
mkdir: (option: HeadlessWxMkdirOption) => HeadlessWxFileSystemResult | undefined;
|
|
712
|
-
mkdirSync: (dirPath: string, recursive?: boolean) => void;
|
|
713
|
-
readFile: (option: HeadlessWxReadFileOption) => HeadlessWxReadFileSuccessResult | undefined;
|
|
714
|
-
readFileSync: (filePath: string, encoding?: string) => string;
|
|
715
|
-
readdir: (option: HeadlessWxReadDirOption) => HeadlessWxReadDirSuccessResult | undefined;
|
|
716
|
-
readdirSync: (dirPath: string) => string[];
|
|
717
|
-
rmdir: (option: HeadlessWxRmdirOption) => HeadlessWxFileSystemResult | undefined;
|
|
718
|
-
rmdirSync: (dirPath: string, recursive?: boolean) => void;
|
|
719
|
-
rename: (option: HeadlessWxRenameOption) => HeadlessWxFileSystemResult | undefined;
|
|
720
|
-
renameSync: (oldPath: string, newPath: string) => void;
|
|
721
|
-
stat: (option: HeadlessWxStatOption) => HeadlessWxStatSuccessResult | undefined;
|
|
722
|
-
statSync: (path: string) => HeadlessWxStats;
|
|
723
|
-
unlink: (option: HeadlessWxUnlinkOption) => HeadlessWxFileSystemResult | undefined;
|
|
724
|
-
unlinkSync: (filePath: string) => void;
|
|
725
|
-
writeFile: (option: HeadlessWxWriteFileOption) => HeadlessWxFileSystemResult | undefined;
|
|
726
|
-
writeFileSync: (filePath: string, data: string, encoding?: string) => void;
|
|
727
|
-
}
|
|
728
|
-
interface HeadlessWxDriver {
|
|
729
|
-
chooseImage: (option: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult;
|
|
730
|
-
chooseMessageFile: (option: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult;
|
|
731
|
-
chooseMedia: (option: HeadlessWxChooseMediaOption) => HeadlessWxChooseMediaResult;
|
|
732
|
-
chooseVideo: (option: HeadlessWxChooseVideoOption) => HeadlessWxChooseVideoResult;
|
|
733
|
-
compressImage: (option: HeadlessWxCompressImageOption) => HeadlessWxCompressImageResult;
|
|
799
|
+
interface HeadlessWxDriverCapabilities {
|
|
800
|
+
clearStorageSync: () => void;
|
|
734
801
|
createAnimation: (option?: HeadlessWxAnimationStepOption) => HeadlessWxAnimation;
|
|
735
802
|
createCanvasContext: (canvasId: string, scope?: Record<string, any>) => HeadlessWxCanvasContext;
|
|
736
|
-
canvasToTempFilePath: (option: HeadlessWxCanvasToTempFilePathOption) => HeadlessWxCanvasToTempFilePathSuccessResult;
|
|
737
803
|
createIntersectionObserver: (scope: Record<string, any> | undefined, options?: HeadlessWxCreateIntersectionObserverOption) => HeadlessWxIntersectionObserver;
|
|
738
804
|
createVideoContext: (videoId: string, scope?: Record<string, any>) => HeadlessWxVideoContext;
|
|
739
805
|
executeSelectorQuery: (requests: HeadlessWxSelectorQueryRequest[], scope?: Record<string, any>) => unknown[];
|
|
740
806
|
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
getVideoInfo: (option: HeadlessWxGetVideoInfoOption) => HeadlessWxGetVideoInfoResult;
|
|
744
|
-
getFileSystemManager: () => HeadlessWxFileSystemManager;
|
|
745
|
-
getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult;
|
|
746
|
-
getSavedFileList: (option?: HeadlessWxGetSavedFileListOption) => HeadlessWxGetSavedFileListSuccessResult;
|
|
747
|
-
clearStorageSync: () => void;
|
|
807
|
+
getDeviceInfo: () => HeadlessWxDeviceInfoResult;
|
|
808
|
+
getClipboardData: () => HeadlessWxGetClipboardDataResult;
|
|
748
809
|
getEnterOptionsSync: () => HeadlessWxLaunchOptions;
|
|
749
810
|
getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
|
|
750
811
|
getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
|
|
751
|
-
getClipboardData: () => HeadlessWxGetClipboardDataResult;
|
|
752
812
|
getNetworkType: () => HeadlessWxGetNetworkTypeResult;
|
|
753
813
|
getStorageInfoSync: () => HeadlessWxStorageInfoResult;
|
|
754
814
|
getStorageSync: (key: string) => unknown;
|
|
@@ -760,25 +820,28 @@ interface HeadlessWxDriver {
|
|
|
760
820
|
hideToast: () => {
|
|
761
821
|
errMsg: string;
|
|
762
822
|
};
|
|
763
|
-
|
|
823
|
+
hideNavigationBarLoading: () => {
|
|
824
|
+
errMsg: string;
|
|
825
|
+
};
|
|
826
|
+
hideShareMenu: () => {
|
|
827
|
+
errMsg: string;
|
|
828
|
+
};
|
|
829
|
+
hideTabBar: () => {
|
|
830
|
+
errMsg: string;
|
|
831
|
+
};
|
|
832
|
+
hideTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
|
|
833
|
+
errMsg: string;
|
|
834
|
+
};
|
|
764
835
|
navigateBack: (option?: HeadlessWxNavigateBackOption) => unknown;
|
|
765
836
|
navigateTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
766
837
|
nextTick: (callback?: () => void) => void;
|
|
767
838
|
offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
768
839
|
onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
769
|
-
openDocument: (option: HeadlessWxOpenDocumentOption) => HeadlessWxOpenDocumentResult;
|
|
770
840
|
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
771
841
|
reLaunch: (option: HeadlessWxNavigateOption) => unknown;
|
|
772
842
|
redirectTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
773
843
|
removeStorageSync: (key: string) => void;
|
|
774
|
-
|
|
775
|
-
previewImage: (option: HeadlessWxPreviewImageOption) => HeadlessWxPreviewImageResult;
|
|
776
|
-
removeSavedFile: (option: HeadlessWxRemoveSavedFileOption) => {
|
|
777
|
-
errMsg: string;
|
|
778
|
-
};
|
|
779
|
-
saveImageToPhotosAlbum: (option: HeadlessWxSaveImageToPhotosAlbumOption) => HeadlessWxSaveImageToPhotosAlbumResult;
|
|
780
|
-
saveVideoToPhotosAlbum: (option: HeadlessWxSaveVideoToPhotosAlbumOption) => HeadlessWxSaveVideoToPhotosAlbumResult;
|
|
781
|
-
saveFile: (option: HeadlessWxSaveFileOption) => HeadlessWxSaveFileSuccessResult;
|
|
844
|
+
setStorageSync: (key: string, value: unknown) => void;
|
|
782
845
|
setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
|
|
783
846
|
errMsg: string;
|
|
784
847
|
};
|
|
@@ -786,42 +849,29 @@ interface HeadlessWxDriver {
|
|
|
786
849
|
errMsg: string;
|
|
787
850
|
};
|
|
788
851
|
setClipboardData: (option: HeadlessWxSetClipboardDataOption) => HeadlessWxSetClipboardDataResult;
|
|
789
|
-
setStorageSync: (key: string, value: unknown) => void;
|
|
790
852
|
setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
|
|
791
853
|
errMsg: string;
|
|
792
854
|
};
|
|
793
855
|
setNavigationBarTitle: (option: HeadlessWxSetNavigationBarTitleOption) => {
|
|
794
856
|
errMsg: string;
|
|
795
857
|
};
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
};
|
|
799
|
-
hideNavigationBarLoading: () => {
|
|
800
|
-
errMsg: string;
|
|
801
|
-
};
|
|
802
|
-
hideTabBar: () => {
|
|
858
|
+
showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult;
|
|
859
|
+
showLoading: (option: HeadlessWxShowLoadingOption) => {
|
|
803
860
|
errMsg: string;
|
|
804
861
|
};
|
|
805
|
-
|
|
862
|
+
showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult;
|
|
863
|
+
showNavigationBarLoading: () => {
|
|
806
864
|
errMsg: string;
|
|
807
865
|
};
|
|
808
866
|
showShareMenu: (option: HeadlessWxShareMenuOption) => {
|
|
809
867
|
errMsg: string;
|
|
810
868
|
};
|
|
811
|
-
showNavigationBarLoading: () => {
|
|
812
|
-
errMsg: string;
|
|
813
|
-
};
|
|
814
869
|
showTabBar: () => {
|
|
815
870
|
errMsg: string;
|
|
816
871
|
};
|
|
817
872
|
showTabBarRedDot: (option: HeadlessWxTabBarItemOption) => {
|
|
818
873
|
errMsg: string;
|
|
819
874
|
};
|
|
820
|
-
showActionSheet: (option: HeadlessWxShowActionSheetOption) => HeadlessWxShowActionSheetResult;
|
|
821
|
-
showLoading: (option: HeadlessWxShowLoadingOption) => {
|
|
822
|
-
errMsg: string;
|
|
823
|
-
};
|
|
824
|
-
showModal: (option: HeadlessWxShowModalOption) => HeadlessWxShowModalResult;
|
|
825
875
|
showToast: (option: HeadlessWxShowToastOption) => {
|
|
826
876
|
errMsg: string;
|
|
827
877
|
};
|
|
@@ -830,7 +880,6 @@ interface HeadlessWxDriver {
|
|
|
830
880
|
};
|
|
831
881
|
stopPullDownRefresh: () => void;
|
|
832
882
|
switchTab: (option: HeadlessWxNavigateOption) => unknown;
|
|
833
|
-
uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
|
|
834
883
|
removeTabBarBadge: (option: HeadlessWxTabBarItemOption) => {
|
|
835
884
|
errMsg: string;
|
|
836
885
|
};
|
|
@@ -841,7 +890,35 @@ interface HeadlessWxDriver {
|
|
|
841
890
|
errMsg: string;
|
|
842
891
|
};
|
|
843
892
|
}
|
|
844
|
-
|
|
893
|
+
//#endregion
|
|
894
|
+
//#region src/host/wx/api.d.ts
|
|
895
|
+
interface HeadlessWxDriver extends HeadlessWxDriverCapabilities {
|
|
896
|
+
chooseImage: (option: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult;
|
|
897
|
+
chooseMessageFile: (option: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult;
|
|
898
|
+
chooseMedia: (option: HeadlessWxChooseMediaOption) => HeadlessWxChooseMediaResult;
|
|
899
|
+
chooseVideo: (option: HeadlessWxChooseVideoOption) => HeadlessWxChooseVideoResult;
|
|
900
|
+
compressImage: (option: HeadlessWxCompressImageOption) => HeadlessWxCompressImageResult;
|
|
901
|
+
getFileInfo: (option: HeadlessWxGetFileInfoOption) => HeadlessWxGetFileInfoResult;
|
|
902
|
+
getImageInfo: (option: HeadlessWxGetImageInfoOption) => HeadlessWxGetImageInfoResult;
|
|
903
|
+
getLocation: (option?: HeadlessWxGetLocationOption) => HeadlessWxGetLocationResult;
|
|
904
|
+
getVideoInfo: (option: HeadlessWxGetVideoInfoOption) => HeadlessWxGetVideoInfoResult;
|
|
905
|
+
getFileSystemManager: () => HeadlessWxFileSystemManager;
|
|
906
|
+
getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult;
|
|
907
|
+
getSavedFileList: (option?: HeadlessWxGetSavedFileListOption) => HeadlessWxGetSavedFileListSuccessResult;
|
|
908
|
+
downloadFile: (option: HeadlessWxDownloadFileOption) => HeadlessWxRequestTask;
|
|
909
|
+
openDocument: (option: HeadlessWxOpenDocumentOption) => HeadlessWxOpenDocumentResult;
|
|
910
|
+
previewImage: (option: HeadlessWxPreviewImageOption) => HeadlessWxPreviewImageResult;
|
|
911
|
+
removeSavedFile: (option: HeadlessWxRemoveSavedFileOption) => {
|
|
912
|
+
errMsg: string;
|
|
913
|
+
};
|
|
914
|
+
request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
|
|
915
|
+
saveFile: (option: HeadlessWxSaveFileOption) => HeadlessWxSaveFileSuccessResult;
|
|
916
|
+
saveImageToPhotosAlbum: (option: HeadlessWxSaveImageToPhotosAlbumOption) => HeadlessWxSaveImageToPhotosAlbumResult;
|
|
917
|
+
saveVideoToPhotosAlbum: (option: HeadlessWxSaveVideoToPhotosAlbumOption) => HeadlessWxSaveVideoToPhotosAlbumResult;
|
|
918
|
+
canvasToTempFilePath: (option: HeadlessWxCanvasToTempFilePathOption) => HeadlessWxCanvasToTempFilePathSuccessResult;
|
|
919
|
+
uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
|
|
920
|
+
}
|
|
921
|
+
interface HeadlessWx extends HeadlessUniEventBus {
|
|
845
922
|
canIUse: (schema: string) => boolean;
|
|
846
923
|
chooseImage: (option?: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult | undefined;
|
|
847
924
|
chooseMessageFile: (option?: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult | undefined;
|
|
@@ -858,6 +935,7 @@ interface HeadlessWx {
|
|
|
858
935
|
createSelectorQuery: () => HeadlessWxSelectorQuery;
|
|
859
936
|
getFileInfo: (option: HeadlessWxGetFileInfoOption) => HeadlessWxGetFileInfoResult | undefined;
|
|
860
937
|
getImageInfo: (option: HeadlessWxGetImageInfoOption) => HeadlessWxGetImageInfoResult | undefined;
|
|
938
|
+
getLocale: () => string;
|
|
861
939
|
getVideoInfo: (option: HeadlessWxGetVideoInfoOption) => HeadlessWxGetVideoInfoResult | undefined;
|
|
862
940
|
getFileSystemManager: () => HeadlessWxFileSystemManager;
|
|
863
941
|
getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult | undefined;
|
|
@@ -865,9 +943,11 @@ interface HeadlessWx {
|
|
|
865
943
|
getEnterOptionsSync: () => HeadlessWxLaunchOptions;
|
|
866
944
|
getAppBaseInfo: (option?: HeadlessWxGetAppBaseInfoOption) => HeadlessWxAppBaseInfoResult | undefined;
|
|
867
945
|
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
946
|
+
getDeviceInfo: () => HeadlessWxDeviceInfoResult;
|
|
868
947
|
getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
|
|
869
948
|
getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
|
|
870
949
|
getClipboardData: (option?: HeadlessWxGetClipboardDataOption) => HeadlessWxGetClipboardDataResult | undefined;
|
|
950
|
+
getLocation: (option?: HeadlessWxGetLocationOption) => HeadlessWxGetLocationResult | undefined;
|
|
871
951
|
getNetworkType: (option?: HeadlessWxGetNetworkTypeOption) => HeadlessWxGetNetworkTypeResult | undefined;
|
|
872
952
|
getStorageInfo: (option?: HeadlessWxGetStorageInfoOption) => HeadlessWxStorageInfoResult | undefined;
|
|
873
953
|
getStorageInfoSync: () => HeadlessWxStorageInfoResult;
|
|
@@ -877,6 +957,7 @@ interface HeadlessWx {
|
|
|
877
957
|
getSystemInfoSync: () => HeadlessWxSystemInfoResult;
|
|
878
958
|
getWindowInfo: (option?: HeadlessWxGetWindowInfoOption) => HeadlessWxWindowInfoResult | undefined;
|
|
879
959
|
getWindowInfoSync: () => HeadlessWxWindowInfoResult;
|
|
960
|
+
loadFontFace: (option: HeadlessWxLoadFontFaceOption) => HeadlessWxLoadFontFaceResult | undefined;
|
|
880
961
|
hideLoading: (option?: HeadlessWxHideLoadingOption) => {
|
|
881
962
|
errMsg: string;
|
|
882
963
|
} | undefined;
|
|
@@ -901,6 +982,7 @@ interface HeadlessWx {
|
|
|
901
982
|
saveVideoToPhotosAlbum: (option: HeadlessWxSaveVideoToPhotosAlbumOption) => HeadlessWxSaveVideoToPhotosAlbumResult | undefined;
|
|
902
983
|
removeStorage: (option: HeadlessWxRemoveStorageOption) => HeadlessWxStorageResult | undefined;
|
|
903
984
|
removeStorageSync: (key: string) => void;
|
|
985
|
+
rpx2px: (value: number) => number;
|
|
904
986
|
request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
|
|
905
987
|
saveFile: (option: HeadlessWxSaveFileOption) => HeadlessWxSaveFileSuccessResult | undefined;
|
|
906
988
|
setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
|
|
@@ -967,9 +1049,73 @@ interface HeadlessWx {
|
|
|
967
1049
|
updateShareMenu: (option?: HeadlessWxShareMenuOption) => {
|
|
968
1050
|
errMsg: string;
|
|
969
1051
|
} | undefined;
|
|
1052
|
+
upx2px: (value: number) => number;
|
|
970
1053
|
}
|
|
1054
|
+
//#endregion
|
|
1055
|
+
//#region src/host/wx/index.d.ts
|
|
971
1056
|
declare function createHeadlessWx(driver: HeadlessWxDriver): HeadlessWx;
|
|
972
1057
|
//#endregion
|
|
1058
|
+
//#region src/kernel/artifactSource.d.ts
|
|
1059
|
+
interface ArtifactSource {
|
|
1060
|
+
has: (filePath: string) => boolean;
|
|
1061
|
+
readText: (filePath: string) => string | undefined;
|
|
1062
|
+
}
|
|
1063
|
+
declare function createFileSystemArtifactSource(): ArtifactSource;
|
|
1064
|
+
declare function createMemoryArtifactSource(entries: Iterable<[string, string]>): ArtifactSource;
|
|
1065
|
+
declare function createOverlayArtifactSource(overlay: ArtifactSource, fallback: ArtifactSource): ArtifactSource;
|
|
1066
|
+
//#endregion
|
|
1067
|
+
//#region src/kernel/diagnostics.d.ts
|
|
1068
|
+
type RuntimeDiagnosticLevel = 'error' | 'exception' | 'warn';
|
|
1069
|
+
interface RuntimeDiagnosticEntry {
|
|
1070
|
+
args: unknown[];
|
|
1071
|
+
level: RuntimeDiagnosticLevel;
|
|
1072
|
+
timestamp: number;
|
|
1073
|
+
}
|
|
1074
|
+
declare class RuntimeDiagnostics {
|
|
1075
|
+
private readonly entries;
|
|
1076
|
+
clear(): void;
|
|
1077
|
+
getEntries(): {
|
|
1078
|
+
args: unknown[];
|
|
1079
|
+
level: RuntimeDiagnosticLevel;
|
|
1080
|
+
timestamp: number;
|
|
1081
|
+
}[];
|
|
1082
|
+
record(level: RuntimeDiagnosticLevel, args: unknown[]): void;
|
|
1083
|
+
createConsole(baseConsole?: Console): Console;
|
|
1084
|
+
}
|
|
1085
|
+
//#endregion
|
|
1086
|
+
//#region src/kernel/platform.d.ts
|
|
1087
|
+
interface PlatformAdapter {
|
|
1088
|
+
readonly name: string;
|
|
1089
|
+
}
|
|
1090
|
+
declare function wechat(): PlatformAdapter;
|
|
1091
|
+
//#endregion
|
|
1092
|
+
//#region src/kernel/scheduler.d.ts
|
|
1093
|
+
type TimeoutHandle = ReturnType<typeof setTimeout>;
|
|
1094
|
+
type IntervalHandle = ReturnType<typeof setInterval>;
|
|
1095
|
+
declare class RuntimeScheduler {
|
|
1096
|
+
private readonly intervals;
|
|
1097
|
+
private readonly timeouts;
|
|
1098
|
+
private closed;
|
|
1099
|
+
private readonly onError;
|
|
1100
|
+
constructor(onError: (error: unknown) => void);
|
|
1101
|
+
clearInterval(handle: IntervalHandle): void;
|
|
1102
|
+
clearTimeout(handle: TimeoutHandle): void;
|
|
1103
|
+
close(): void;
|
|
1104
|
+
queueMicrotask(handler: () => void): void;
|
|
1105
|
+
setInterval(handler: (...args: any[]) => void, timeout?: number, ...args: any[]): NodeJS.Timeout;
|
|
1106
|
+
setTimeout(handler: (...args: any[]) => void, timeout?: number, ...args: any[]): NodeJS.Timeout;
|
|
1107
|
+
}
|
|
1108
|
+
//#endregion
|
|
1109
|
+
//#region src/kernel/runtimeKernel.d.ts
|
|
1110
|
+
declare class RuntimeKernel {
|
|
1111
|
+
readonly diagnostics: RuntimeDiagnostics;
|
|
1112
|
+
readonly scheduler: RuntimeScheduler;
|
|
1113
|
+
private closed;
|
|
1114
|
+
assertActive(): void;
|
|
1115
|
+
close(): void;
|
|
1116
|
+
get isClosed(): boolean;
|
|
1117
|
+
}
|
|
1118
|
+
//#endregion
|
|
973
1119
|
//#region src/browser/virtualFiles.d.ts
|
|
974
1120
|
interface BrowserDirectoryFileLike {
|
|
975
1121
|
name: string;
|
|
@@ -985,11 +1131,16 @@ declare function hasBrowserVirtualFile(files: BrowserVirtualFiles, filePath: str
|
|
|
985
1131
|
//#endregion
|
|
986
1132
|
//#region src/browser/moduleLoader.d.ts
|
|
987
1133
|
interface BrowserModuleLoader {
|
|
1134
|
+
close: () => void;
|
|
988
1135
|
executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
|
|
989
1136
|
executeAppModule: (filePath: string) => HeadlessAppDefinition;
|
|
990
1137
|
executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
|
|
1138
|
+
wx: HeadlessWx;
|
|
991
1139
|
}
|
|
992
|
-
declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0]
|
|
1140
|
+
declare function createBrowserModuleLoader(files: BrowserVirtualFiles, registries: HeadlessHostRegistries, getCurrentPages: () => any[], getApp: () => any, wxDriver: Parameters<typeof createHeadlessWx>[0], options: {
|
|
1141
|
+
globals?: Record<string, unknown>;
|
|
1142
|
+
kernel: RuntimeKernel;
|
|
1143
|
+
}): BrowserModuleLoader;
|
|
993
1144
|
//#endregion
|
|
994
1145
|
//#region src/project/resolveRoutes.d.ts
|
|
995
1146
|
interface HeadlessRouteRecord {
|
|
@@ -1006,6 +1157,7 @@ interface HeadlessProjectConfigFile {
|
|
|
1006
1157
|
value: Record<string, any>;
|
|
1007
1158
|
}
|
|
1008
1159
|
interface HeadlessProjectDescriptor {
|
|
1160
|
+
artifactSource: ArtifactSource;
|
|
1009
1161
|
appConfig: Record<string, any>;
|
|
1010
1162
|
appConfigPath: string;
|
|
1011
1163
|
miniprogramRoot: string;
|
|
@@ -1015,6 +1167,7 @@ interface HeadlessProjectDescriptor {
|
|
|
1015
1167
|
routes: HeadlessRouteRecord[];
|
|
1016
1168
|
}
|
|
1017
1169
|
interface CreateProjectDescriptorOptions {
|
|
1170
|
+
artifactSource?: ArtifactSource;
|
|
1018
1171
|
appConfig: Record<string, any>;
|
|
1019
1172
|
appConfigPath: string;
|
|
1020
1173
|
miniprogramRoot: string;
|
|
@@ -1033,35 +1186,6 @@ interface CreateBrowserProjectOptions {
|
|
|
1033
1186
|
}
|
|
1034
1187
|
declare function createBrowserProject(files: BrowserVirtualFiles, options?: CreateBrowserProjectOptions): HeadlessProjectDescriptor;
|
|
1035
1188
|
//#endregion
|
|
1036
|
-
//#region src/runtime/componentInstance.d.ts
|
|
1037
|
-
interface HeadlessComponentInstance extends Record<string, any> {
|
|
1038
|
-
__definition__?: HeadlessComponentDefinition;
|
|
1039
|
-
__lastInteractionEvent__?: Record<string, any>;
|
|
1040
|
-
__propertySnapshots__?: Record<string, any>;
|
|
1041
|
-
__ready__?: boolean;
|
|
1042
|
-
createIntersectionObserver?: (options?: Record<string, any>) => any;
|
|
1043
|
-
createMediaQueryObserver?: () => HeadlessWxMediaQueryObserver;
|
|
1044
|
-
data: Record<string, any>;
|
|
1045
|
-
properties: Record<string, any>;
|
|
1046
|
-
selectAllComponents?: (selector: string) => any[];
|
|
1047
|
-
selectComponent?: (selector: string) => any;
|
|
1048
|
-
selectOwnerComponent?: () => any;
|
|
1049
|
-
setData: (patch: Record<string, any>, callback?: () => void) => void;
|
|
1050
|
-
triggerEvent: (eventName: string, detail?: unknown, options?: Record<string, any>) => void;
|
|
1051
|
-
}
|
|
1052
|
-
declare function cloneValue<T>(value: T): T;
|
|
1053
|
-
declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
|
|
1054
|
-
interface CreateComponentInstanceOptions {
|
|
1055
|
-
definition: HeadlessComponentDefinition;
|
|
1056
|
-
properties?: Record<string, any>;
|
|
1057
|
-
triggerEvent?: (instance: HeadlessComponentInstance, eventName: string, detail?: unknown, options?: Record<string, any>) => void;
|
|
1058
|
-
}
|
|
1059
|
-
declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
|
|
1060
|
-
declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): unknown;
|
|
1061
|
-
declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
|
|
1062
|
-
declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
|
|
1063
|
-
declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
|
|
1064
|
-
//#endregion
|
|
1065
1189
|
//#region src/project/pageConfig.d.ts
|
|
1066
1190
|
interface HeadlessNavigationBarSnapshot {
|
|
1067
1191
|
animation: {
|
|
@@ -1105,7 +1229,46 @@ declare function createPageInstance(route: string, definition: HeadlessPageDefin
|
|
|
1105
1229
|
navigationBar?: HeadlessNavigationBarSnapshot;
|
|
1106
1230
|
}): HeadlessPageInstance;
|
|
1107
1231
|
//#endregion
|
|
1108
|
-
//#region src/
|
|
1232
|
+
//#region src/runtime/componentInstance/types.d.ts
|
|
1233
|
+
interface HeadlessComponentInstance extends Record<string, any> {
|
|
1234
|
+
__definition__?: HeadlessComponentDefinition;
|
|
1235
|
+
__lastInteractionEvent__?: Record<string, any>;
|
|
1236
|
+
__propertySnapshots__?: Record<string, any>;
|
|
1237
|
+
__ready__?: boolean;
|
|
1238
|
+
createIntersectionObserver?: (options?: Record<string, any>) => any;
|
|
1239
|
+
createMediaQueryObserver?: () => HeadlessWxMediaQueryObserver;
|
|
1240
|
+
data: Record<string, any>;
|
|
1241
|
+
properties: Record<string, any>;
|
|
1242
|
+
selectAllComponents?: (selector: string) => any[];
|
|
1243
|
+
selectComponent?: (selector: string) => any;
|
|
1244
|
+
selectOwnerComponent?: () => any;
|
|
1245
|
+
setData: (patch: Record<string, any>, callback?: () => void) => void;
|
|
1246
|
+
triggerEvent: (eventName: string, detail?: unknown, options?: Record<string, any>) => void;
|
|
1247
|
+
}
|
|
1248
|
+
interface CreateComponentInstanceOptions {
|
|
1249
|
+
definition: HeadlessComponentDefinition;
|
|
1250
|
+
properties?: Record<string, any>;
|
|
1251
|
+
requestRender?: (callback?: () => void) => void;
|
|
1252
|
+
triggerEvent?: (instance: HeadlessComponentInstance, eventName: string, detail?: unknown, options?: Record<string, any>) => void;
|
|
1253
|
+
}
|
|
1254
|
+
//#endregion
|
|
1255
|
+
//#region src/runtime/componentInstance/observers.d.ts
|
|
1256
|
+
declare function runComponentObservers(definition: HeadlessComponentDefinition, instance: HeadlessComponentInstance, changedKeys: string[], previousProperties?: Record<string, any>): void;
|
|
1257
|
+
//#endregion
|
|
1258
|
+
//#region src/runtime/componentInstance/properties.d.ts
|
|
1259
|
+
declare function coerceComponentPropertyValue(rawValue: unknown, option: unknown): unknown;
|
|
1260
|
+
declare function normalizeComponentPropertyValue(definition: HeadlessComponentDefinition, key: string, rawValue: unknown): any;
|
|
1261
|
+
//#endregion
|
|
1262
|
+
//#region src/runtime/componentInstance/shared.d.ts
|
|
1263
|
+
declare function cloneValue<T>(value: T): T;
|
|
1264
|
+
declare function hasComponentPropertyValueChanged(currentValue: unknown, previousSnapshot: unknown, nextValue: unknown, bindingAffected: boolean): boolean;
|
|
1265
|
+
//#endregion
|
|
1266
|
+
//#region src/runtime/componentInstance/index.d.ts
|
|
1267
|
+
declare function createComponentInstance(options: CreateComponentInstanceOptions): HeadlessComponentInstance;
|
|
1268
|
+
declare function runComponentLifecycle(instance: HeadlessComponentInstance, lifecycleName: 'attached' | 'created' | 'detached' | 'ready'): void;
|
|
1269
|
+
declare function runComponentPageLifetime(instance: HeadlessComponentInstance, lifetimeName: 'hide' | 'resize' | 'show', payload?: unknown): void;
|
|
1270
|
+
//#endregion
|
|
1271
|
+
//#region src/browser/render/types.d.ts
|
|
1109
1272
|
interface DomNodeLike$5 {
|
|
1110
1273
|
attribs?: Record<string, string>;
|
|
1111
1274
|
children?: DomNodeLike$5[];
|
|
@@ -1125,10 +1288,19 @@ interface BrowserRenderScope {
|
|
|
1125
1288
|
}>;
|
|
1126
1289
|
getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
|
|
1127
1290
|
getScopeId: () => string;
|
|
1291
|
+
genericComponents?: Map<string, string>;
|
|
1128
1292
|
hostId?: string;
|
|
1129
1293
|
listenerScopeId?: string;
|
|
1130
1294
|
id?: string;
|
|
1131
1295
|
ownerScopeId?: string;
|
|
1296
|
+
slots?: Map<string, BrowserSlotContent[]>;
|
|
1297
|
+
}
|
|
1298
|
+
interface BrowserSlotContent {
|
|
1299
|
+
instancePath: string;
|
|
1300
|
+
node: DomNodeLike$5;
|
|
1301
|
+
ownerFilePath: string;
|
|
1302
|
+
ownerJsonPath: string;
|
|
1303
|
+
scope: BrowserRenderScope;
|
|
1132
1304
|
}
|
|
1133
1305
|
interface BrowserRenderedPageTree {
|
|
1134
1306
|
root: DomNodeLike$5;
|
|
@@ -1144,11 +1316,14 @@ interface BrowserRendererContext {
|
|
|
1144
1316
|
session: {
|
|
1145
1317
|
createIntersectionObserver: (scope: any, options?: Record<string, any>) => any;
|
|
1146
1318
|
createMediaQueryObserver: (scope: any) => any;
|
|
1319
|
+
requestRender: (callback?: () => void) => void;
|
|
1147
1320
|
selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
|
|
1148
1321
|
selectComponentWithin: (scopeId: string, selector: string) => any;
|
|
1149
1322
|
selectOwnerComponent: (scopeId: string) => any;
|
|
1150
1323
|
};
|
|
1151
1324
|
}
|
|
1325
|
+
//#endregion
|
|
1326
|
+
//#region src/browser/render/index.d.ts
|
|
1152
1327
|
declare function renderBrowserPageTree(context: BrowserRendererContext, page: HeadlessPageInstance): BrowserRenderedPageTree;
|
|
1153
1328
|
//#endregion
|
|
1154
1329
|
//#region src/runtime/appInstance.d.ts
|
|
@@ -1157,17 +1332,28 @@ interface HeadlessAppInstance extends Record<string, any> {
|
|
|
1157
1332
|
}
|
|
1158
1333
|
declare function createAppInstance(definition: HeadlessAppDefinition): HeadlessAppInstance;
|
|
1159
1334
|
//#endregion
|
|
1335
|
+
//#region src/project/createArtifactProject.d.ts
|
|
1336
|
+
interface CreateArtifactProjectOptions {
|
|
1337
|
+
appConfigPath?: string;
|
|
1338
|
+
artifactSource?: ArtifactSource;
|
|
1339
|
+
miniprogramRootPath: string;
|
|
1340
|
+
projectPath?: string;
|
|
1341
|
+
}
|
|
1342
|
+
declare function createArtifactProject(options: CreateArtifactProjectOptions): HeadlessProjectDescriptor;
|
|
1343
|
+
//#endregion
|
|
1160
1344
|
//#region src/project/loadProject.d.ts
|
|
1161
1345
|
declare function loadProject(projectPath: string): HeadlessProjectDescriptor;
|
|
1162
1346
|
//#endregion
|
|
1163
1347
|
//#region src/runtime/moduleLoader.d.ts
|
|
1164
1348
|
interface HeadlessModuleLoader {
|
|
1349
|
+
close: () => void;
|
|
1165
1350
|
executeComponentModule: (filePath: string, id: string) => HeadlessComponentDefinition;
|
|
1166
1351
|
executeAppModule: (filePath: string) => HeadlessAppDefinition;
|
|
1167
1352
|
executePageModule: (filePath: string, route: string) => HeadlessPageDefinition;
|
|
1353
|
+
wx: HeadlessWx;
|
|
1168
1354
|
}
|
|
1169
1355
|
//#endregion
|
|
1170
|
-
//#region src/runtime/render.d.ts
|
|
1356
|
+
//#region src/runtime/render/types.d.ts
|
|
1171
1357
|
interface DomNodeLike$4 {
|
|
1172
1358
|
attribs?: Record<string, string>;
|
|
1173
1359
|
children?: DomNodeLike$4[];
|
|
@@ -1187,16 +1373,26 @@ interface RuntimeRenderScope {
|
|
|
1187
1373
|
}>;
|
|
1188
1374
|
getMethod: (methodName: string) => ((...args: any[]) => any) | undefined;
|
|
1189
1375
|
getScopeId: () => string;
|
|
1376
|
+
genericComponents?: Map<string, string>;
|
|
1190
1377
|
hostId?: string;
|
|
1191
1378
|
listenerScopeId?: string;
|
|
1192
1379
|
id?: string;
|
|
1193
1380
|
ownerScopeId?: string;
|
|
1381
|
+
slots?: Map<string, RuntimeSlotContent[]>;
|
|
1382
|
+
}
|
|
1383
|
+
interface RuntimeSlotContent {
|
|
1384
|
+
instancePath: string;
|
|
1385
|
+
node: DomNodeLike$4;
|
|
1386
|
+
ownerFilePath: string;
|
|
1387
|
+
ownerJsonPath: string;
|
|
1388
|
+
scope: RuntimeRenderScope;
|
|
1194
1389
|
}
|
|
1195
1390
|
interface RuntimeRenderedPageTree {
|
|
1196
1391
|
root: DomNodeLike$4;
|
|
1197
1392
|
wxml: string;
|
|
1198
1393
|
}
|
|
1199
1394
|
interface RuntimeRendererContext {
|
|
1395
|
+
artifactSource: ArtifactSource;
|
|
1200
1396
|
changedPageKeys: string[];
|
|
1201
1397
|
componentCache: Map<string, HeadlessComponentInstance>;
|
|
1202
1398
|
componentScopes: Map<string, RuntimeRenderScope>;
|
|
@@ -1205,11 +1401,14 @@ interface RuntimeRendererContext {
|
|
|
1205
1401
|
session: {
|
|
1206
1402
|
createIntersectionObserver: (scope: any, options?: Record<string, any>) => any;
|
|
1207
1403
|
createMediaQueryObserver: (scope: any) => any;
|
|
1404
|
+
requestRender: (callback?: () => void) => void;
|
|
1208
1405
|
selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
|
|
1209
1406
|
selectComponentWithin: (scopeId: string, selector: string) => any;
|
|
1210
1407
|
selectOwnerComponent: (scopeId: string) => any;
|
|
1211
1408
|
};
|
|
1212
1409
|
}
|
|
1410
|
+
//#endregion
|
|
1411
|
+
//#region src/runtime/render/index.d.ts
|
|
1213
1412
|
declare function renderRuntimePageTree(context: RuntimeRendererContext, page: HeadlessPageInstance): RuntimeRenderedPageTree;
|
|
1214
1413
|
//#endregion
|
|
1215
1414
|
//#region src/runtime/wxState.d.ts
|
|
@@ -1317,7 +1516,11 @@ interface HeadlessWxUploadFileLogEntry {
|
|
|
1317
1516
|
response?: HeadlessWxUploadFileSuccessResult;
|
|
1318
1517
|
url: string;
|
|
1319
1518
|
}
|
|
1320
|
-
|
|
1519
|
+
interface HeadlessWxStateOptions {
|
|
1520
|
+
strictMocks?: boolean;
|
|
1521
|
+
}
|
|
1522
|
+
declare function createHeadlessWxState(scheduler?: Pick<RuntimeScheduler, 'clearTimeout' | 'setTimeout'>, options?: HeadlessWxStateOptions): {
|
|
1523
|
+
close(): void;
|
|
1321
1524
|
clearStorageSync(): void;
|
|
1322
1525
|
downloadFile(option: HeadlessWxDownloadFileOption): HeadlessWxRequestTask;
|
|
1323
1526
|
getActionSheetLogs(): {
|
|
@@ -1590,10 +1793,14 @@ declare function createHeadlessWxState(): {
|
|
|
1590
1793
|
//#endregion
|
|
1591
1794
|
//#region src/runtime/session.d.ts
|
|
1592
1795
|
interface HeadlessSessionOptions {
|
|
1593
|
-
|
|
1796
|
+
globals?: Record<string, unknown>;
|
|
1797
|
+
project?: HeadlessProjectDescriptor;
|
|
1798
|
+
projectPath?: string;
|
|
1799
|
+
strictHostMocks?: boolean;
|
|
1594
1800
|
}
|
|
1595
1801
|
declare class HeadlessSession {
|
|
1596
1802
|
readonly project: HeadlessProjectDescriptor;
|
|
1803
|
+
private readonly kernel;
|
|
1597
1804
|
private appDefinition;
|
|
1598
1805
|
private appInstance;
|
|
1599
1806
|
private readonly moduleLoader;
|
|
@@ -1602,6 +1809,9 @@ declare class HeadlessSession {
|
|
|
1602
1809
|
private readonly pages;
|
|
1603
1810
|
private readonly componentCache;
|
|
1604
1811
|
private readonly componentScopes;
|
|
1812
|
+
private readonly selectorQueryScopeSnapshots;
|
|
1813
|
+
private renderRequestPending;
|
|
1814
|
+
private readonly renderRequestCallbacks;
|
|
1605
1815
|
private readonly tabBarRoutes;
|
|
1606
1816
|
private readonly tabPages;
|
|
1607
1817
|
private readonly tabBarItems;
|
|
@@ -1615,8 +1825,13 @@ declare class HeadlessSession {
|
|
|
1615
1825
|
private readonly wxState;
|
|
1616
1826
|
private pullDownRefreshState;
|
|
1617
1827
|
constructor(options: HeadlessSessionOptions);
|
|
1828
|
+
assertActive(): void;
|
|
1829
|
+
close(): void;
|
|
1830
|
+
getDiagnostics(): RuntimeDiagnosticEntry[];
|
|
1831
|
+
get isClosed(): boolean;
|
|
1618
1832
|
getApp(): HeadlessAppInstance | null;
|
|
1619
1833
|
getCurrentPages(): HeadlessPageInstance[];
|
|
1834
|
+
callWxMethod(methodName: string, ...args: any[]): any;
|
|
1620
1835
|
getCurrentPageNavigationBarTitle(): string | null;
|
|
1621
1836
|
getCurrentPageNavigationBar(): {
|
|
1622
1837
|
animation: {
|
|
@@ -1696,6 +1911,7 @@ declare class HeadlessSession {
|
|
|
1696
1911
|
getFileText(filePath: string): string | null;
|
|
1697
1912
|
getSavedFileListSnapshot(): HeadlessWxSavedFileInfo[];
|
|
1698
1913
|
renderCurrentPage(): RuntimeRenderedPageTree;
|
|
1914
|
+
requestRender(callback?: () => void): void;
|
|
1699
1915
|
getScopeSnapshot(scopeId: string): {
|
|
1700
1916
|
data: Record<string, any>;
|
|
1701
1917
|
methods: string[];
|
|
@@ -1769,6 +1985,8 @@ declare class HeadlessSession {
|
|
|
1769
1985
|
model: string;
|
|
1770
1986
|
pixelRatio: number;
|
|
1771
1987
|
platform: string;
|
|
1988
|
+
safeArea: HeadlessWxSafeArea;
|
|
1989
|
+
safeAreaInsets: HeadlessWxSafeAreaInsets;
|
|
1772
1990
|
screenHeight: number;
|
|
1773
1991
|
screenWidth: number;
|
|
1774
1992
|
system: string;
|
|
@@ -1778,6 +1996,7 @@ declare class HeadlessSession {
|
|
|
1778
1996
|
};
|
|
1779
1997
|
getWindowInfo(): HeadlessWxWindowInfoResult;
|
|
1780
1998
|
getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
|
|
1999
|
+
getDeviceInfo(): HeadlessWxDeviceInfoResult;
|
|
1781
2000
|
getLaunchOptions(): {
|
|
1782
2001
|
query: {
|
|
1783
2002
|
[x: string]: string;
|
|
@@ -1805,6 +2024,7 @@ declare class HeadlessSession {
|
|
|
1805
2024
|
scene: number;
|
|
1806
2025
|
};
|
|
1807
2026
|
getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
|
|
2027
|
+
getLocation(): HeadlessWxGetLocationResult;
|
|
1808
2028
|
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
1809
2029
|
getLoading(): {
|
|
1810
2030
|
mask: boolean;
|
|
@@ -1911,8 +2131,8 @@ declare class HeadlessSession {
|
|
|
1911
2131
|
stopPullDownRefresh(): void;
|
|
1912
2132
|
private executeSelectorQuery;
|
|
1913
2133
|
private createFreshPage;
|
|
2134
|
+
private runInitialPageLifecycles;
|
|
1914
2135
|
private isTabBarRoute;
|
|
1915
|
-
private resolveTabBarItem;
|
|
1916
2136
|
private requireTabBarItem;
|
|
1917
2137
|
private removePageInstance;
|
|
1918
2138
|
private resolveNavigationTarget;
|
|
@@ -1938,7 +2158,10 @@ declare function createHeadlessSession(options: HeadlessSessionOptions): Headles
|
|
|
1938
2158
|
//#region src/browser/session.d.ts
|
|
1939
2159
|
interface BrowserHeadlessSessionOptions {
|
|
1940
2160
|
files: BrowserVirtualFiles;
|
|
2161
|
+
globals?: Record<string, unknown>;
|
|
2162
|
+
onRender?: () => void;
|
|
1941
2163
|
project?: HeadlessProjectDescriptor;
|
|
2164
|
+
strictHostMocks?: boolean;
|
|
1942
2165
|
}
|
|
1943
2166
|
declare class BrowserHeadlessSession {
|
|
1944
2167
|
readonly files: BrowserVirtualFiles;
|
|
@@ -1946,11 +2169,15 @@ declare class BrowserHeadlessSession {
|
|
|
1946
2169
|
private appDefinition;
|
|
1947
2170
|
private appInstance;
|
|
1948
2171
|
private readonly moduleLoader;
|
|
2172
|
+
private readonly onRender?;
|
|
1949
2173
|
private readonly registries;
|
|
1950
2174
|
private currentPageInstance;
|
|
1951
2175
|
private readonly pages;
|
|
1952
2176
|
private readonly componentCache;
|
|
1953
2177
|
private readonly componentScopes;
|
|
2178
|
+
private readonly selectorQueryScopeSnapshots;
|
|
2179
|
+
private renderRequestPending;
|
|
2180
|
+
private readonly renderRequestCallbacks;
|
|
1954
2181
|
private readonly tabBarRoutes;
|
|
1955
2182
|
private readonly tabPages;
|
|
1956
2183
|
private readonly tabBarItems;
|
|
@@ -1961,9 +2188,14 @@ declare class BrowserHeadlessSession {
|
|
|
1961
2188
|
private readonly canvasContexts;
|
|
1962
2189
|
private enterOptions;
|
|
1963
2190
|
private launchOptions;
|
|
2191
|
+
private readonly kernel;
|
|
1964
2192
|
private readonly wxState;
|
|
1965
2193
|
private pullDownRefreshState;
|
|
1966
2194
|
constructor(options: BrowserHeadlessSessionOptions);
|
|
2195
|
+
assertActive(): void;
|
|
2196
|
+
close(): void;
|
|
2197
|
+
getDiagnostics(): RuntimeDiagnosticEntry[];
|
|
2198
|
+
get isClosed(): boolean;
|
|
1967
2199
|
getApp(): HeadlessAppInstance | null;
|
|
1968
2200
|
getCurrentPages(): HeadlessPageInstance[];
|
|
1969
2201
|
getCurrentPageNavigationBarTitle(): string | null;
|
|
@@ -2090,6 +2322,8 @@ declare class BrowserHeadlessSession {
|
|
|
2090
2322
|
model: string;
|
|
2091
2323
|
pixelRatio: number;
|
|
2092
2324
|
platform: string;
|
|
2325
|
+
safeArea: HeadlessWxSafeArea;
|
|
2326
|
+
safeAreaInsets: HeadlessWxSafeAreaInsets;
|
|
2093
2327
|
screenHeight: number;
|
|
2094
2328
|
screenWidth: number;
|
|
2095
2329
|
system: string;
|
|
@@ -2099,6 +2333,7 @@ declare class BrowserHeadlessSession {
|
|
|
2099
2333
|
};
|
|
2100
2334
|
getWindowInfo(): HeadlessWxWindowInfoResult;
|
|
2101
2335
|
getAppBaseInfo(): HeadlessWxAppBaseInfoResult;
|
|
2336
|
+
getDeviceInfo(): HeadlessWxDeviceInfoResult;
|
|
2102
2337
|
getLaunchOptions(): {
|
|
2103
2338
|
query: {
|
|
2104
2339
|
[x: string]: string;
|
|
@@ -2126,6 +2361,7 @@ declare class BrowserHeadlessSession {
|
|
|
2126
2361
|
scene: number;
|
|
2127
2362
|
};
|
|
2128
2363
|
getMenuButtonBoundingClientRect(): HeadlessWxMenuButtonBoundingClientRectResult;
|
|
2364
|
+
getLocation(): HeadlessWxGetLocationResult;
|
|
2129
2365
|
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
2130
2366
|
getLoading(): {
|
|
2131
2367
|
mask: boolean;
|
|
@@ -2235,6 +2471,7 @@ declare class BrowserHeadlessSession {
|
|
|
2235
2471
|
selectOwnerComponent(scopeId: string): any;
|
|
2236
2472
|
private selectComponentsWithin;
|
|
2237
2473
|
renderCurrentPage(): BrowserRenderedPageTree;
|
|
2474
|
+
requestRender(callback?: () => void): void;
|
|
2238
2475
|
callScopeMethod(scopeId: string | null, methodName: string, event: Record<string, any>): any;
|
|
2239
2476
|
callScopeMethodDirect(scopeId: string, methodName: string, ...args: any[]): any;
|
|
2240
2477
|
callTapBinding(scopeId: string, methodName: string): any;
|
|
@@ -2272,10 +2509,10 @@ declare class BrowserHeadlessSession {
|
|
|
2272
2509
|
stopPullDownRefresh(): void;
|
|
2273
2510
|
private executeSelectorQuery;
|
|
2274
2511
|
private createFreshPage;
|
|
2512
|
+
private runInitialPageLifecycles;
|
|
2275
2513
|
private isTabBarRoute;
|
|
2276
2514
|
private removePageInstance;
|
|
2277
2515
|
private resolveNavigationTarget;
|
|
2278
|
-
private resolveTabBarItem;
|
|
2279
2516
|
private requireTabBarItem;
|
|
2280
2517
|
private unloadAllPages;
|
|
2281
2518
|
private unloadPage;
|
|
@@ -2295,6 +2532,38 @@ declare class BrowserHeadlessSession {
|
|
|
2295
2532
|
}
|
|
2296
2533
|
declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
|
|
2297
2534
|
//#endregion
|
|
2535
|
+
//#region src/testing/pageWait.d.ts
|
|
2536
|
+
interface HeadlessTestingWaitOptions {
|
|
2537
|
+
interval?: number;
|
|
2538
|
+
timeout?: number;
|
|
2539
|
+
}
|
|
2540
|
+
type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
|
|
2541
|
+
interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
|
|
2542
|
+
state?: 'attached' | 'detached';
|
|
2543
|
+
}
|
|
2544
|
+
interface HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle> {
|
|
2545
|
+
data: (path?: string) => Promise<unknown>;
|
|
2546
|
+
findOne: (selector: string) => Promise<NodeHandle | null>;
|
|
2547
|
+
selectComponent: (selector: string) => Promise<ScopeHandle | null>;
|
|
2548
|
+
selectComponents: (selector: string) => Promise<ScopeHandle[]>;
|
|
2549
|
+
waitFor: (ms?: number) => Promise<void>;
|
|
2550
|
+
wxml: () => Promise<string>;
|
|
2551
|
+
}
|
|
2552
|
+
declare function waitForPageSelector<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<NonNullable<Awaited<NodeHandle>> | null>;
|
|
2553
|
+
declare function waitForPageComponent<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, options?: HeadlessTestingWaitOptions): Promise<NonNullable<Awaited<ScopeHandle>>>;
|
|
2554
|
+
declare function waitForPageComponents<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<ScopeHandle[]>;
|
|
2555
|
+
declare function waitForPageText<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
|
|
2556
|
+
declare function waitForPageTextGone<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
|
|
2557
|
+
declare function waitForPageData<NodeHandle, ScopeHandle>(access: HeadlessTestingPageWaitAccess<NodeHandle, ScopeHandle>, path: string, matcher: HeadlessTestingDataMatcher, hasMatcher: boolean, options?: HeadlessTestingWaitOptions): Promise<{}>;
|
|
2558
|
+
//#endregion
|
|
2559
|
+
//#region src/view/eventBinding.d.ts
|
|
2560
|
+
interface MiniProgramEventBinding {
|
|
2561
|
+
method: string;
|
|
2562
|
+
stopAfter: boolean;
|
|
2563
|
+
}
|
|
2564
|
+
declare function collectMiniProgramEventBindings(attributes?: Record<string, string>): Map<string, MiniProgramEventBinding>;
|
|
2565
|
+
declare function resolveMiniProgramEventBinding(attributes: Record<string, string> | undefined, eventName: string): MiniProgramEventBinding | null;
|
|
2566
|
+
//#endregion
|
|
2298
2567
|
//#region src/view/nodeHandle.d.ts
|
|
2299
2568
|
interface DomNodeLike$3 {
|
|
2300
2569
|
attribs?: Record<string, string>;
|
|
@@ -2325,6 +2594,7 @@ interface HeadlessTestingNodeValueEventInit extends HeadlessTestingNodeEventInit
|
|
|
2325
2594
|
};
|
|
2326
2595
|
}
|
|
2327
2596
|
interface HeadlessTestingNodeInteractionHandlers {
|
|
2597
|
+
assertActive?: () => void;
|
|
2328
2598
|
callMethod: (scopeId: string | null, methodName: string, event: Record<string, any>) => unknown;
|
|
2329
2599
|
createScopeHandle: (scopeId: string | null) => {
|
|
2330
2600
|
scopeId: string;
|
|
@@ -2339,6 +2609,7 @@ declare class HeadlessTestingNodeHandle {
|
|
|
2339
2609
|
private readonly node;
|
|
2340
2610
|
private readonly interactions?;
|
|
2341
2611
|
constructor(node: DomNodeLike$3, interactions?: HeadlessTestingNodeInteractionHandlers | undefined);
|
|
2612
|
+
private assertActive;
|
|
2342
2613
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
2343
2614
|
$$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
2344
2615
|
attr(name: string): Promise<string | undefined>;
|
|
@@ -2363,6 +2634,7 @@ declare class HeadlessTestingNodeHandle {
|
|
|
2363
2634
|
snapshot: () => Promise<unknown>;
|
|
2364
2635
|
} | null>;
|
|
2365
2636
|
text(): Promise<string>;
|
|
2637
|
+
tagName(): Promise<string | undefined>;
|
|
2366
2638
|
trigger(eventName: string, event?: HeadlessTestingNodeEventInit): Promise<unknown>;
|
|
2367
2639
|
tap(event?: HeadlessTestingNodeEventInit): Promise<unknown>;
|
|
2368
2640
|
input(value: string, event?: HeadlessTestingNodeValueEventInit): Promise<unknown>;
|
|
@@ -2416,40 +2688,100 @@ interface DomNodeLike {
|
|
|
2416
2688
|
}
|
|
2417
2689
|
declare function querySelectorAll(root: DomNodeLike, selector: string): DomNodeLike[];
|
|
2418
2690
|
//#endregion
|
|
2691
|
+
//#region src/testing/rendered.d.ts
|
|
2692
|
+
interface HeadlessTestingPageQueryOptions extends HeadlessTestingWaitOptions {
|
|
2693
|
+
componentSelectors?: string[];
|
|
2694
|
+
fallback?: boolean;
|
|
2695
|
+
routeOnly?: boolean;
|
|
2696
|
+
}
|
|
2697
|
+
interface HeadlessTestingRenderedOptions extends HeadlessTestingWaitOptions {
|
|
2698
|
+
componentSelectors?: string[];
|
|
2699
|
+
dataset?: Record<string, boolean | number | string>;
|
|
2700
|
+
predicate?: (wxml: string) => boolean;
|
|
2701
|
+
selector?: string;
|
|
2702
|
+
text?: string;
|
|
2703
|
+
}
|
|
2704
|
+
interface HeadlessTestingRenderedNodeSnapshot {
|
|
2705
|
+
bottom?: number;
|
|
2706
|
+
dataset?: Record<string, unknown>;
|
|
2707
|
+
height?: number;
|
|
2708
|
+
id?: string;
|
|
2709
|
+
left?: number;
|
|
2710
|
+
right?: number;
|
|
2711
|
+
top?: number;
|
|
2712
|
+
width?: number;
|
|
2713
|
+
}
|
|
2714
|
+
type HeadlessTestingRenderedSelectorNodesSnapshot = Record<string, HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2715
|
+
interface HeadlessTestingRenderedPageAccess {
|
|
2716
|
+
assertActive: () => void;
|
|
2717
|
+
findAll: (selector: string) => Promise<HeadlessTestingNodeHandle[]>;
|
|
2718
|
+
waitFor: (ms?: number) => Promise<void>;
|
|
2719
|
+
wxml: () => Promise<string>;
|
|
2720
|
+
}
|
|
2721
|
+
declare function readRenderedNodes(access: HeadlessTestingRenderedPageAccess, selector: string, _options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2722
|
+
declare function readRenderedSelectorNodes(access: HeadlessTestingRenderedPageAccess, selectors: string[], options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedSelectorNodesSnapshot>;
|
|
2723
|
+
declare function waitForRenderedPage(access: HeadlessTestingRenderedPageAccess, options?: HeadlessTestingRenderedOptions): Promise<string>;
|
|
2724
|
+
//#endregion
|
|
2725
|
+
//#region src/testing/logicalSnapshot.d.ts
|
|
2726
|
+
interface HeadlessTestingLogicalNode {
|
|
2727
|
+
attrs: Record<string, string>;
|
|
2728
|
+
children: HeadlessTestingLogicalNode[];
|
|
2729
|
+
nodeId?: string;
|
|
2730
|
+
tag?: string;
|
|
2731
|
+
text: string;
|
|
2732
|
+
type: 'element' | 'text';
|
|
2733
|
+
}
|
|
2734
|
+
interface HeadlessTestingPageSnapshot {
|
|
2735
|
+
data: Record<string, any>;
|
|
2736
|
+
path: string;
|
|
2737
|
+
query: Record<string, string>;
|
|
2738
|
+
root: HeadlessTestingLogicalNode;
|
|
2739
|
+
wxml: string;
|
|
2740
|
+
}
|
|
2741
|
+
declare function createLogicalNode(node: any): HeadlessTestingLogicalNode;
|
|
2742
|
+
//#endregion
|
|
2419
2743
|
//#region src/testing/pageHandle.d.ts
|
|
2420
|
-
interface
|
|
2421
|
-
|
|
2744
|
+
interface HeadlessTestingPageCallMethodOptions {
|
|
2745
|
+
fallback?: boolean;
|
|
2746
|
+
routeOnly?: boolean;
|
|
2422
2747
|
timeout?: number;
|
|
2423
2748
|
}
|
|
2424
|
-
type HeadlessTestingDataMatcher = unknown | ((value: unknown) => boolean);
|
|
2425
|
-
interface HeadlessTestingWaitForSelectorOptions extends HeadlessTestingWaitOptions {
|
|
2426
|
-
state?: 'attached' | 'detached';
|
|
2427
|
-
}
|
|
2428
2749
|
declare class HeadlessTestingPageHandle {
|
|
2429
2750
|
private readonly project;
|
|
2430
2751
|
private readonly page;
|
|
2431
2752
|
private readonly session?;
|
|
2432
2753
|
constructor(project: HeadlessProjectDescriptor, page: HeadlessPageInstance, session?: HeadlessSession | undefined);
|
|
2754
|
+
get path(): string;
|
|
2755
|
+
get query(): {
|
|
2756
|
+
[x: string]: string;
|
|
2757
|
+
};
|
|
2433
2758
|
private resolveDataByPath;
|
|
2434
|
-
|
|
2759
|
+
assertActive(): void;
|
|
2435
2760
|
private createScopeHandle;
|
|
2436
2761
|
callMethod(methodName: string, ...args: any[]): Promise<any>;
|
|
2762
|
+
callMethodWithOptions(methodName: string, options?: HeadlessTestingPageCallMethodOptions, ...args: any[]): Promise<any>;
|
|
2437
2763
|
data(path?: string): Promise<any>;
|
|
2438
2764
|
selectComponent(selector: string): Promise<HeadlessTestingScopeHandle | null>;
|
|
2439
2765
|
selectAllComponents(selector: string): Promise<HeadlessTestingScopeHandle[]>;
|
|
2440
2766
|
waitFor(ms?: number): Promise<void>;
|
|
2441
2767
|
$(selector: string): Promise<HeadlessTestingNodeHandle | null>;
|
|
2442
2768
|
$$(selector: string): Promise<HeadlessTestingNodeHandle[]>;
|
|
2769
|
+
renderedNodes(selector: string, options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedNodeSnapshot[]>;
|
|
2770
|
+
renderedSelectorNodes(selectors: string[], options?: HeadlessTestingPageQueryOptions): Promise<HeadlessTestingRenderedSelectorNodesSnapshot>;
|
|
2771
|
+
waitForRendered(options?: HeadlessTestingRenderedOptions): Promise<string>;
|
|
2443
2772
|
waitForSelector(selector: string, options?: HeadlessTestingWaitForSelectorOptions): Promise<HeadlessTestingNodeHandle | null>;
|
|
2444
2773
|
waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
|
|
2445
2774
|
waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
|
|
2446
2775
|
waitForText(text: string, options?: HeadlessTestingWaitOptions): Promise<string>;
|
|
2447
2776
|
waitForTextGone(text: string, options?: HeadlessTestingWaitOptions): Promise<void>;
|
|
2448
|
-
waitForData(path: string, matcher?: HeadlessTestingDataMatcher, options?: HeadlessTestingWaitOptions): Promise<
|
|
2777
|
+
waitForData(path: string, matcher?: HeadlessTestingDataMatcher, options?: HeadlessTestingWaitOptions): Promise<{}>;
|
|
2449
2778
|
wxml(): Promise<string>;
|
|
2779
|
+
snapshot(): Promise<HeadlessTestingPageSnapshot>;
|
|
2780
|
+
private renderedAccess;
|
|
2781
|
+
private waitAccess;
|
|
2450
2782
|
}
|
|
2451
2783
|
//#endregion
|
|
2452
|
-
//#region src/testing/sessionHandle.d.ts
|
|
2784
|
+
//#region src/testing/sessionHandle/scope.d.ts
|
|
2453
2785
|
declare class HeadlessTestingScopeHandle {
|
|
2454
2786
|
readonly scopeId: string;
|
|
2455
2787
|
private readonly project;
|
|
@@ -2494,15 +2826,20 @@ declare class HeadlessTestingScopeHandle {
|
|
|
2494
2826
|
timeout?: number;
|
|
2495
2827
|
}): Promise<HeadlessTestingScopeHandle[]>;
|
|
2496
2828
|
}
|
|
2829
|
+
//#endregion
|
|
2830
|
+
//#region src/testing/sessionHandle/index.d.ts
|
|
2831
|
+
interface HeadlessTestingProtocolOptions {
|
|
2832
|
+
timeout?: number;
|
|
2833
|
+
}
|
|
2497
2834
|
declare class HeadlessTestingSessionHandle {
|
|
2498
2835
|
private readonly project;
|
|
2499
2836
|
private readonly session;
|
|
2500
2837
|
constructor(project: HeadlessProjectDescriptor, session: HeadlessSession);
|
|
2501
|
-
private waitFor;
|
|
2502
|
-
private pollUntil;
|
|
2503
2838
|
close(): Promise<void>;
|
|
2504
2839
|
currentPage(): Promise<HeadlessTestingPageHandle | null>;
|
|
2505
2840
|
getCurrentPages(): Promise<HeadlessTestingPageHandle[]>;
|
|
2841
|
+
callWxMethod<T = unknown>(methodName: string, ...args: any[]): Promise<T>;
|
|
2842
|
+
callWxMethodWithOptions<T = unknown>(methodName: string, options?: HeadlessTestingProtocolOptions, ...args: any[]): Promise<T>;
|
|
2506
2843
|
scopeSnapshot(scopeId: string): Promise<{
|
|
2507
2844
|
data: Record<string, any>;
|
|
2508
2845
|
methods: string[];
|
|
@@ -2527,12 +2864,17 @@ declare class HeadlessTestingSessionHandle {
|
|
|
2527
2864
|
waitForComponent(selector: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle>;
|
|
2528
2865
|
waitForComponents(selector: string, count?: number, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingScopeHandle[]>;
|
|
2529
2866
|
reLaunch(route: string): Promise<HeadlessTestingPageHandle>;
|
|
2867
|
+
navigateTo(route: string): Promise<HeadlessTestingPageHandle>;
|
|
2868
|
+
redirectTo(route: string): Promise<HeadlessTestingPageHandle>;
|
|
2869
|
+
navigateBack(delta?: number): Promise<HeadlessTestingPageHandle | null>;
|
|
2870
|
+
switchTab(route: string): Promise<HeadlessTestingPageHandle>;
|
|
2530
2871
|
waitForCurrentPage(route?: string, options?: HeadlessTestingWaitOptions): Promise<HeadlessTestingPageHandle>;
|
|
2531
2872
|
pageScrollTo(scrollTop: number): Promise<void>;
|
|
2532
2873
|
triggerPullDownRefresh(): Promise<void>;
|
|
2533
2874
|
triggerReachBottom(): Promise<void>;
|
|
2534
2875
|
triggerResize(options: Record<string, any>): Promise<void>;
|
|
2535
2876
|
triggerRouteDone(options?: Record<string, any>): Promise<void>;
|
|
2877
|
+
private requireCurrentPage;
|
|
2536
2878
|
}
|
|
2537
2879
|
//#endregion
|
|
2538
2880
|
//#region src/testing/launch.d.ts
|
|
@@ -2541,4 +2883,4 @@ interface HeadlessTestingLaunchOptions {
|
|
|
2541
2883
|
}
|
|
2542
2884
|
declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
|
|
2543
2885
|
//#endregion
|
|
2544
|
-
export { BrowserDirectoryFileLike, BrowserHeadlessSession, BrowserHeadlessSessionOptions, BrowserModuleLoader, BrowserRenderedPageTree, BrowserRendererContext, BrowserVirtualFiles, CreateBrowserProjectOptions, CreateComponentInstanceOptions, CreateProjectDescriptorOptions, HeadlessAppDefinition, HeadlessAppInstance, HeadlessBehaviorDefinition, HeadlessComponentDefinition, HeadlessComponentInstance, HeadlessHostLoadContext, HeadlessHostRegistries, HeadlessPageDefinition, HeadlessPageInstance, HeadlessProjectConfigFile, HeadlessProjectDescriptor, HeadlessRouteRecord, HeadlessSelectorQueryResolverOptions, HeadlessSession, HeadlessSessionOptions, HeadlessTestingDataMatcher, HeadlessTestingLaunchOptions, HeadlessTestingNodeHandle, HeadlessTestingPageHandle, HeadlessTestingScopeHandle, HeadlessTestingSessionHandle, HeadlessTestingWaitForSelectorOptions, HeadlessTestingWaitOptions, HeadlessWx, HeadlessWxAccessFileOption, HeadlessWxActionSheetLogEntry, HeadlessWxActionSheetMockDefinition, HeadlessWxAnimation, HeadlessWxAnimationAction, HeadlessWxAnimationExportResult, HeadlessWxAnimationStepOption, HeadlessWxAppBaseInfoResult, HeadlessWxAppendFileOption, HeadlessWxCallbackOption, HeadlessWxCanvasContext, HeadlessWxCanvasDrawCall, HeadlessWxCanvasSnapshot, HeadlessWxCanvasToTempFilePathOption, HeadlessWxCanvasToTempFilePathSuccessResult, HeadlessWxChooseImageOption, HeadlessWxChooseImageResult, HeadlessWxChooseImageTempFile, HeadlessWxChooseMediaOption, HeadlessWxChooseMediaResult, HeadlessWxChooseMediaTempFile, HeadlessWxChooseMessageFileOption, HeadlessWxChooseMessageFileResult, HeadlessWxChooseMessageFileTempFile, HeadlessWxChooseVideoOption, HeadlessWxChooseVideoResult, HeadlessWxClearStorageOption, HeadlessWxClipboardSnapshot, HeadlessWxCompressImageOption, HeadlessWxCompressImageResult, HeadlessWxCopyFileOption, HeadlessWxCreateIntersectionObserverOption, HeadlessWxDownloadFileLogEntry, HeadlessWxDownloadFileMockDefinition, HeadlessWxDownloadFileOption, HeadlessWxDownloadFileSuccessResult, HeadlessWxDriver, HeadlessWxFileSystemManager, HeadlessWxFileSystemResult, HeadlessWxGetAppBaseInfoOption, HeadlessWxGetClipboardDataOption, HeadlessWxGetClipboardDataResult, HeadlessWxGetFileInfoOption, HeadlessWxGetFileInfoResult, HeadlessWxGetImageInfoOption, HeadlessWxGetImageInfoResult, HeadlessWxGetNetworkTypeOption, HeadlessWxGetNetworkTypeResult, HeadlessWxGetSavedFileInfoOption, HeadlessWxGetSavedFileInfoSuccessResult, HeadlessWxGetSavedFileListOption, HeadlessWxGetSavedFileListSuccessResult, HeadlessWxGetStorageInfoOption, HeadlessWxGetStorageOption, HeadlessWxGetStorageResult, HeadlessWxGetSystemInfoOption, HeadlessWxGetVideoInfoOption, HeadlessWxGetVideoInfoResult, HeadlessWxGetWindowInfoOption, HeadlessWxHideLoadingOption, HeadlessWxHideNavigationBarLoadingOption, HeadlessWxIntersectionObserver, HeadlessWxIntersectionObserverMargins, HeadlessWxIntersectionObserverObserveAllResult, HeadlessWxLaunchOptions, HeadlessWxLoadingSnapshot, HeadlessWxMediaQueryObserver, HeadlessWxMediaQueryObserverObserveCallbackResult, HeadlessWxMenuButtonBoundingClientRectResult, HeadlessWxMkdirOption, HeadlessWxModalLogEntry, HeadlessWxModalMockDefinition, HeadlessWxNavigateBackOption, HeadlessWxNavigateOption, HeadlessWxNetworkSnapshot, HeadlessWxNetworkStatusChangeCallback, HeadlessWxNetworkStatusChangeResult, HeadlessWxNetworkType, HeadlessWxObserveDescriptor, HeadlessWxOpenDocumentOption, HeadlessWxOpenDocumentResult, HeadlessWxOpenDocumentSnapshot, HeadlessWxPageScrollToOption, HeadlessWxPreviewImageOption, HeadlessWxPreviewImageResult, HeadlessWxPreviewImageSnapshot, HeadlessWxReadDirOption, HeadlessWxReadDirSuccessResult, HeadlessWxReadFileOption, HeadlessWxReadFileSuccessResult, HeadlessWxRemoveSavedFileOption, HeadlessWxRemoveStorageOption, HeadlessWxRenameOption, HeadlessWxRequestLogEntry, HeadlessWxRequestMockDefinition, HeadlessWxRequestOption, HeadlessWxRequestSuccessResult, HeadlessWxRequestTask, HeadlessWxRmdirOption, HeadlessWxSaveFileOption, HeadlessWxSaveFileSuccessResult, HeadlessWxSaveImageToPhotosAlbumOption, HeadlessWxSaveImageToPhotosAlbumResult, HeadlessWxSaveVideoToPhotosAlbumOption, HeadlessWxSaveVideoToPhotosAlbumResult, HeadlessWxSavedFileInfo, HeadlessWxSelectorQuery, HeadlessWxSelectorQueryBoundingClientRectResult, HeadlessWxSelectorQueryFieldsOption, HeadlessWxSelectorQueryNode, HeadlessWxSelectorQueryRequest, HeadlessWxSelectorQueryScrollOffsetResult, HeadlessWxSetBackgroundColorOption, HeadlessWxSetBackgroundTextStyleOption, HeadlessWxSetClipboardDataOption, HeadlessWxSetClipboardDataResult, HeadlessWxSetNavigationBarColorOption, HeadlessWxSetNavigationBarTitleOption, HeadlessWxSetStorageOption, HeadlessWxSetTabBarBadgeOption, HeadlessWxShareMenuOption, HeadlessWxShareMenuSnapshot, HeadlessWxShowActionSheetOption, HeadlessWxShowActionSheetResult, HeadlessWxShowLoadingOption, HeadlessWxShowModalOption, HeadlessWxShowModalResult, HeadlessWxShowNavigationBarLoadingOption, HeadlessWxShowToastOption, HeadlessWxStartPullDownRefreshOption, HeadlessWxStatOption, HeadlessWxStatSuccessResult, HeadlessWxStats, HeadlessWxStorageInfoResult, HeadlessWxStorageResult, HeadlessWxSystemInfoResult, HeadlessWxTabBarItemOption, HeadlessWxTabBarOption, HeadlessWxToastSnapshot, HeadlessWxUnlinkOption, HeadlessWxUploadFileLogEntry, HeadlessWxUploadFileMockDefinition, HeadlessWxUploadFileOption, HeadlessWxUploadFileSuccessResult, HeadlessWxVideoContext, HeadlessWxWindowInfoResult, HeadlessWxWriteFileOption, RenderedPageTree, RuntimeRenderedPageTree, RuntimeRendererContext, cloneValue, coerceComponentPropertyValue, createAppInstance, createBrowserHeadlessSession, createBrowserModuleLoader, createBrowserProject, createBrowserVirtualFiles, createBrowserVirtualFilesFromDirectory, createComponentInstance, createHeadlessSession, createHeadlessWx, createHeadlessWxState, createHostRegistries, createPageInstance, createProjectDescriptor, executeSelectorQueryRequests, hasBrowserVirtualFile, launch, loadProject, normalizeBrowserFilePath, normalizeComponentPropertyValue, querySelectorAll, readBrowserVirtualFile, registerAppDefinition, registerComponentDefinition, registerPageDefinition, renderBrowserPageTree, renderPageTree, renderRuntimePageTree, resolveRoutesFromAppConfig, resolveSelectorQueryScopeRoot, resolveSelectorScrollTop, runComponentLifecycle, runComponentObservers, runComponentPageLifetime };
|
|
2886
|
+
export { ArtifactSource, BrowserDirectoryFileLike, BrowserHeadlessSession, BrowserHeadlessSessionOptions, BrowserModuleLoader, type BrowserRenderedPageTree, type BrowserRendererContext, BrowserVirtualFiles, CreateArtifactProjectOptions, CreateBrowserProjectOptions, type CreateComponentInstanceOptions, CreateProjectDescriptorOptions, HeadlessAppDefinition, HeadlessAppInstance, HeadlessBehaviorDefinition, HeadlessComponentDefinition, type HeadlessComponentInstance, HeadlessHostLoadContext, HeadlessHostRegistries, HeadlessPageDefinition, HeadlessPageInstance, HeadlessProjectConfigFile, HeadlessProjectDescriptor, HeadlessRouteRecord, HeadlessSelectorQueryResolverOptions, HeadlessSession, HeadlessSessionOptions, HeadlessTestingDataMatcher, HeadlessTestingLaunchOptions, HeadlessTestingLogicalNode, HeadlessTestingNodeHandle, HeadlessTestingPageCallMethodOptions, HeadlessTestingPageHandle, HeadlessTestingPageQueryOptions, HeadlessTestingPageSnapshot, HeadlessTestingPageWaitAccess, HeadlessTestingRenderedNodeSnapshot, HeadlessTestingRenderedOptions, HeadlessTestingRenderedPageAccess, HeadlessTestingRenderedSelectorNodesSnapshot, HeadlessTestingScopeHandle, HeadlessTestingSessionHandle, HeadlessTestingWaitForSelectorOptions, HeadlessTestingWaitOptions, HeadlessUniEventBus, HeadlessUniEventHandler, HeadlessWx, HeadlessWxAccessFileOption, HeadlessWxActionSheetLogEntry, HeadlessWxActionSheetMockDefinition, HeadlessWxAnimation, HeadlessWxAnimationAction, HeadlessWxAnimationExportResult, HeadlessWxAnimationStepOption, HeadlessWxAppBaseInfoResult, HeadlessWxAppendFileOption, HeadlessWxCallbackOption, HeadlessWxCanvasContext, HeadlessWxCanvasDrawCall, HeadlessWxCanvasSnapshot, HeadlessWxCanvasToTempFilePathOption, HeadlessWxCanvasToTempFilePathSuccessResult, HeadlessWxChooseImageOption, HeadlessWxChooseImageResult, HeadlessWxChooseImageTempFile, HeadlessWxChooseMediaOption, HeadlessWxChooseMediaResult, HeadlessWxChooseMediaTempFile, HeadlessWxChooseMessageFileOption, HeadlessWxChooseMessageFileResult, HeadlessWxChooseMessageFileTempFile, HeadlessWxChooseVideoOption, HeadlessWxChooseVideoResult, HeadlessWxClearStorageOption, HeadlessWxClipboardSnapshot, HeadlessWxCompressImageOption, HeadlessWxCompressImageResult, HeadlessWxCopyFileOption, HeadlessWxCreateIntersectionObserverOption, HeadlessWxDeviceInfoResult, HeadlessWxDownloadFileLogEntry, HeadlessWxDownloadFileMockDefinition, HeadlessWxDownloadFileOption, HeadlessWxDownloadFileSuccessResult, HeadlessWxDriver, HeadlessWxDriverCapabilities, HeadlessWxFileSystemManager, HeadlessWxFileSystemResult, HeadlessWxGetAppBaseInfoOption, HeadlessWxGetClipboardDataOption, HeadlessWxGetClipboardDataResult, HeadlessWxGetFileInfoOption, HeadlessWxGetFileInfoResult, HeadlessWxGetImageInfoOption, HeadlessWxGetImageInfoResult, HeadlessWxGetLocationOption, HeadlessWxGetLocationResult, HeadlessWxGetNetworkTypeOption, HeadlessWxGetNetworkTypeResult, HeadlessWxGetSavedFileInfoOption, HeadlessWxGetSavedFileInfoSuccessResult, HeadlessWxGetSavedFileListOption, HeadlessWxGetSavedFileListSuccessResult, HeadlessWxGetStorageInfoOption, HeadlessWxGetStorageOption, HeadlessWxGetStorageResult, HeadlessWxGetSystemInfoOption, HeadlessWxGetVideoInfoOption, HeadlessWxGetVideoInfoResult, HeadlessWxGetWindowInfoOption, HeadlessWxHideLoadingOption, HeadlessWxHideNavigationBarLoadingOption, HeadlessWxIntersectionObserver, HeadlessWxIntersectionObserverMargins, HeadlessWxIntersectionObserverObserveAllResult, HeadlessWxLaunchOptions, HeadlessWxLoadFontFaceOption, HeadlessWxLoadFontFaceResult, HeadlessWxLoadingSnapshot, HeadlessWxMediaQueryObserver, HeadlessWxMediaQueryObserverObserveCallbackResult, HeadlessWxMenuButtonBoundingClientRectResult, HeadlessWxMkdirOption, HeadlessWxModalLogEntry, HeadlessWxModalMockDefinition, HeadlessWxNavigateBackOption, HeadlessWxNavigateOption, HeadlessWxNetworkSnapshot, HeadlessWxNetworkStatusChangeCallback, HeadlessWxNetworkStatusChangeResult, HeadlessWxNetworkType, HeadlessWxObserveDescriptor, HeadlessWxOpenDocumentOption, HeadlessWxOpenDocumentResult, HeadlessWxOpenDocumentSnapshot, HeadlessWxPageScrollToOption, HeadlessWxPreviewImageOption, HeadlessWxPreviewImageResult, HeadlessWxPreviewImageSnapshot, HeadlessWxReadDirOption, HeadlessWxReadDirSuccessResult, HeadlessWxReadFileOption, HeadlessWxReadFileSuccessResult, HeadlessWxRemoveSavedFileOption, HeadlessWxRemoveStorageOption, HeadlessWxRenameOption, HeadlessWxRequestLogEntry, HeadlessWxRequestMockDefinition, HeadlessWxRequestOption, HeadlessWxRequestSuccessResult, HeadlessWxRequestTask, HeadlessWxRmdirOption, HeadlessWxSafeArea, HeadlessWxSafeAreaInsets, HeadlessWxSaveFileOption, HeadlessWxSaveFileSuccessResult, HeadlessWxSaveImageToPhotosAlbumOption, HeadlessWxSaveImageToPhotosAlbumResult, HeadlessWxSaveVideoToPhotosAlbumOption, HeadlessWxSaveVideoToPhotosAlbumResult, HeadlessWxSavedFileInfo, HeadlessWxSelectorQuery, HeadlessWxSelectorQueryBoundingClientRectResult, HeadlessWxSelectorQueryFieldsOption, HeadlessWxSelectorQueryNode, HeadlessWxSelectorQueryRequest, HeadlessWxSelectorQueryScrollOffsetResult, HeadlessWxSetBackgroundColorOption, HeadlessWxSetBackgroundTextStyleOption, HeadlessWxSetClipboardDataOption, HeadlessWxSetClipboardDataResult, HeadlessWxSetNavigationBarColorOption, HeadlessWxSetNavigationBarTitleOption, HeadlessWxSetStorageOption, HeadlessWxSetTabBarBadgeOption, HeadlessWxShareMenuOption, HeadlessWxShareMenuSnapshot, HeadlessWxShowActionSheetOption, HeadlessWxShowActionSheetResult, HeadlessWxShowLoadingOption, HeadlessWxShowModalOption, HeadlessWxShowModalResult, HeadlessWxShowNavigationBarLoadingOption, HeadlessWxShowToastOption, HeadlessWxStartPullDownRefreshOption, HeadlessWxStatOption, HeadlessWxStatSuccessResult, HeadlessWxStateOptions, HeadlessWxStats, HeadlessWxStorageInfoResult, HeadlessWxStorageResult, HeadlessWxSystemInfoResult, HeadlessWxTabBarItemOption, HeadlessWxTabBarOption, HeadlessWxToastSnapshot, HeadlessWxUnlinkOption, HeadlessWxUploadFileLogEntry, HeadlessWxUploadFileMockDefinition, HeadlessWxUploadFileOption, HeadlessWxUploadFileSuccessResult, HeadlessWxVideoContext, HeadlessWxWindowInfoResult, HeadlessWxWriteFileOption, MiniProgramEventBinding, PlatformAdapter, RenderedPageTree, RuntimeDiagnosticEntry, RuntimeDiagnosticLevel, RuntimeDiagnostics, RuntimeKernel, type RuntimeRenderedPageTree, type RuntimeRendererContext, RuntimeScheduler, cloneValue, coerceComponentPropertyValue, collectMiniProgramEventBindings, createAppInstance, createArtifactProject, createBrowserHeadlessSession, createBrowserModuleLoader, createBrowserProject, createBrowserVirtualFiles, createBrowserVirtualFilesFromDirectory, createComponentInstance, createFileSystemArtifactSource, createHeadlessSession, createHeadlessUniEventBus, createHeadlessWx, createHeadlessWxState, createHostRegistries, createLogicalNode, createMemoryArtifactSource, createOverlayArtifactSource, createPageInstance, createProjectDescriptor, executeSelectorQueryRequests, hasBrowserVirtualFile, hasComponentPropertyValueChanged, launch, loadProject, normalizeBrowserFilePath, normalizeComponentPropertyValue, querySelectorAll, readBrowserVirtualFile, readRenderedNodes, readRenderedSelectorNodes, registerAppDefinition, registerComponentDefinition, registerExportedComponentDefinition, registerPageDefinition, renderBrowserPageTree, renderPageTree, renderRuntimePageTree, resolveMiniProgramEventBinding, resolveRoutesFromAppConfig, resolveSelectorQueryScopeRoot, resolveSelectorScrollTop, runComponentLifecycle, runComponentObservers, runComponentPageLifetime, waitForPageComponent, waitForPageComponents, waitForPageData, waitForPageSelector, waitForPageText, waitForPageTextGone, waitForRenderedPage, wechat };
|