@mpcore/simulator 0.1.2 → 0.1.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.mts +544 -1
- package/dist/index.mjs +1779 -67
- package/package.json +1 -1
package/dist/index.d.mts
CHANGED
|
@@ -37,6 +37,154 @@ interface HeadlessWxPageScrollToOption extends HeadlessWxCallbackOption {
|
|
|
37
37
|
scrollTop?: number;
|
|
38
38
|
selector?: string;
|
|
39
39
|
}
|
|
40
|
+
interface HeadlessWxVideoContext {
|
|
41
|
+
exitFullScreen: () => void;
|
|
42
|
+
pause: () => void;
|
|
43
|
+
play: () => void;
|
|
44
|
+
requestFullScreen: () => void;
|
|
45
|
+
seek: (position: number) => void;
|
|
46
|
+
stop: () => void;
|
|
47
|
+
}
|
|
48
|
+
interface HeadlessWxAnimationStepOption {
|
|
49
|
+
delay?: number;
|
|
50
|
+
duration?: number;
|
|
51
|
+
timingFunction?: 'ease' | 'ease-in' | 'ease-in-out' | 'ease-out' | 'linear' | 'step-end' | 'step-start';
|
|
52
|
+
transformOrigin?: string;
|
|
53
|
+
}
|
|
54
|
+
interface HeadlessWxAnimationAction {
|
|
55
|
+
args: unknown[];
|
|
56
|
+
type: string;
|
|
57
|
+
}
|
|
58
|
+
interface HeadlessWxAnimationExportResult {
|
|
59
|
+
actions: Array<{
|
|
60
|
+
animates: HeadlessWxAnimationAction[];
|
|
61
|
+
option: Required<HeadlessWxAnimationStepOption>;
|
|
62
|
+
}>;
|
|
63
|
+
}
|
|
64
|
+
interface HeadlessWxAnimation {
|
|
65
|
+
backgroundColor: (value: string) => HeadlessWxAnimation;
|
|
66
|
+
bottom: (value: number | string) => HeadlessWxAnimation;
|
|
67
|
+
export: () => HeadlessWxAnimationExportResult;
|
|
68
|
+
height: (value: number | string) => HeadlessWxAnimation;
|
|
69
|
+
left: (value: number | string) => HeadlessWxAnimation;
|
|
70
|
+
opacity: (value: number) => HeadlessWxAnimation;
|
|
71
|
+
right: (value: number | string) => HeadlessWxAnimation;
|
|
72
|
+
rotate: (angle: number) => HeadlessWxAnimation;
|
|
73
|
+
scale: (sx: number, sy?: number) => HeadlessWxAnimation;
|
|
74
|
+
step: (option?: HeadlessWxAnimationStepOption) => HeadlessWxAnimation;
|
|
75
|
+
top: (value: number | string) => HeadlessWxAnimation;
|
|
76
|
+
translate: (tx?: number | string, ty?: number | string) => HeadlessWxAnimation;
|
|
77
|
+
translate3d: (tx?: number | string, ty?: number | string, tz?: number | string) => HeadlessWxAnimation;
|
|
78
|
+
translateX: (translation: number) => HeadlessWxAnimation;
|
|
79
|
+
translateY: (translation: number) => HeadlessWxAnimation;
|
|
80
|
+
translateZ: (translation: number) => HeadlessWxAnimation;
|
|
81
|
+
width: (value: number | string) => HeadlessWxAnimation;
|
|
82
|
+
}
|
|
83
|
+
interface HeadlessWxCanvasDrawCall {
|
|
84
|
+
args: unknown[];
|
|
85
|
+
type: string;
|
|
86
|
+
}
|
|
87
|
+
interface HeadlessWxCanvasSnapshot {
|
|
88
|
+
canvasId: string;
|
|
89
|
+
drawCalls: HeadlessWxCanvasDrawCall[];
|
|
90
|
+
fillStyle: string;
|
|
91
|
+
fontSize: number;
|
|
92
|
+
globalAlpha: number;
|
|
93
|
+
lineCap: string;
|
|
94
|
+
lineDash: number[];
|
|
95
|
+
lineDashOffset: number;
|
|
96
|
+
lineJoin: string;
|
|
97
|
+
miterLimit: number;
|
|
98
|
+
lineWidth: number;
|
|
99
|
+
reserve: boolean;
|
|
100
|
+
shadowBlur: number;
|
|
101
|
+
shadowColor: string;
|
|
102
|
+
shadowOffsetX: number;
|
|
103
|
+
shadowOffsetY: number;
|
|
104
|
+
strokeStyle: string;
|
|
105
|
+
textAlign: string;
|
|
106
|
+
textBaseline: string;
|
|
107
|
+
}
|
|
108
|
+
interface HeadlessWxCanvasContext {
|
|
109
|
+
__getSnapshot: () => HeadlessWxCanvasSnapshot;
|
|
110
|
+
arc: (x: number, y: number, r: number, sAngle: number, eAngle: number, counterclockwise?: boolean) => void;
|
|
111
|
+
arcTo: (x1: number, y1: number, x2: number, y2: number, radius: number) => void;
|
|
112
|
+
bezierCurveTo: (cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number) => void;
|
|
113
|
+
beginPath: () => void;
|
|
114
|
+
clearRect: (x: number, y: number, width: number, height: number) => void;
|
|
115
|
+
clip: (fillRule?: string) => void;
|
|
116
|
+
closePath: () => void;
|
|
117
|
+
draw: (reserve?: boolean, callback?: () => void) => void;
|
|
118
|
+
drawImage: (image: string, ...args: number[]) => void;
|
|
119
|
+
fill: (fillRule?: string) => void;
|
|
120
|
+
fillRect: (x: number, y: number, width: number, height: number) => void;
|
|
121
|
+
fillText: (text: string, x: number, y: number, maxWidth?: number) => void;
|
|
122
|
+
lineTo: (x: number, y: number) => void;
|
|
123
|
+
measureText: (text: string) => {
|
|
124
|
+
width: number;
|
|
125
|
+
};
|
|
126
|
+
moveTo: (x: number, y: number) => void;
|
|
127
|
+
quadraticCurveTo: (cpx: number, cpy: number, x: number, y: number) => void;
|
|
128
|
+
rect: (x: number, y: number, width: number, height: number) => void;
|
|
129
|
+
restore: () => void;
|
|
130
|
+
rotate: (rotate: number) => void;
|
|
131
|
+
save: () => void;
|
|
132
|
+
scale: (scaleWidth: number, scaleHeight: number) => void;
|
|
133
|
+
setFillStyle: (value: string) => void;
|
|
134
|
+
setFontSize: (fontSize: number) => void;
|
|
135
|
+
setGlobalAlpha: (value: number) => void;
|
|
136
|
+
setLineCap: (value: string) => void;
|
|
137
|
+
setLineDash: (pattern: number[], offset?: number) => void;
|
|
138
|
+
setLineJoin: (value: string) => void;
|
|
139
|
+
setMiterLimit: (value: number) => void;
|
|
140
|
+
setLineWidth: (value: number) => void;
|
|
141
|
+
setShadow: (offsetX: number, offsetY: number, blur: number, color: string) => void;
|
|
142
|
+
setStrokeStyle: (value: string) => void;
|
|
143
|
+
setTextAlign: (value: string) => void;
|
|
144
|
+
setTextBaseline: (value: string) => void;
|
|
145
|
+
stroke: () => void;
|
|
146
|
+
strokeRect: (x: number, y: number, width: number, height: number) => void;
|
|
147
|
+
strokeText: (text: string, x: number, y: number, maxWidth?: number) => void;
|
|
148
|
+
translate: (x: number, y: number) => void;
|
|
149
|
+
}
|
|
150
|
+
interface HeadlessWxIntersectionObserverMargins {
|
|
151
|
+
bottom?: number;
|
|
152
|
+
left?: number;
|
|
153
|
+
right?: number;
|
|
154
|
+
top?: number;
|
|
155
|
+
}
|
|
156
|
+
interface HeadlessWxIntersectionObserverObserveAllResult {
|
|
157
|
+
boundingClientRect: HeadlessWxSelectorQueryBoundingClientRectResult;
|
|
158
|
+
id: string;
|
|
159
|
+
intersectionRatio: number;
|
|
160
|
+
intersectionRect: HeadlessWxSelectorQueryBoundingClientRectResult;
|
|
161
|
+
relativeRect: HeadlessWxSelectorQueryBoundingClientRectResult;
|
|
162
|
+
}
|
|
163
|
+
interface HeadlessWxIntersectionObserver {
|
|
164
|
+
disconnect: () => void;
|
|
165
|
+
observe: (selector: string, callback: (result: HeadlessWxIntersectionObserverObserveAllResult) => void) => void;
|
|
166
|
+
relativeTo: (selector: string, margins?: HeadlessWxIntersectionObserverMargins) => HeadlessWxIntersectionObserver;
|
|
167
|
+
relativeToViewport: (margins?: HeadlessWxIntersectionObserverMargins) => HeadlessWxIntersectionObserver;
|
|
168
|
+
}
|
|
169
|
+
interface HeadlessWxCreateIntersectionObserverOption {
|
|
170
|
+
thresholds?: number[];
|
|
171
|
+
}
|
|
172
|
+
interface HeadlessWxObserveDescriptor {
|
|
173
|
+
height?: number;
|
|
174
|
+
maxHeight?: number;
|
|
175
|
+
maxWidth?: number;
|
|
176
|
+
minHeight?: number;
|
|
177
|
+
minWidth?: number;
|
|
178
|
+
orientation?: string;
|
|
179
|
+
width?: number;
|
|
180
|
+
}
|
|
181
|
+
interface HeadlessWxMediaQueryObserverObserveCallbackResult {
|
|
182
|
+
matches: boolean;
|
|
183
|
+
}
|
|
184
|
+
interface HeadlessWxMediaQueryObserver {
|
|
185
|
+
disconnect: () => void;
|
|
186
|
+
observe: (descriptor: HeadlessWxObserveDescriptor, callback: (result: HeadlessWxMediaQueryObserverObserveCallbackResult) => void) => void;
|
|
187
|
+
}
|
|
40
188
|
interface HeadlessWxSelectorQueryBoundingClientRectResult {
|
|
41
189
|
bottom: number;
|
|
42
190
|
height: number;
|
|
@@ -153,6 +301,17 @@ interface HeadlessWxSetStorageOption extends HeadlessWxCallbackOption<HeadlessWx
|
|
|
153
301
|
data: unknown;
|
|
154
302
|
key: string;
|
|
155
303
|
}
|
|
304
|
+
interface HeadlessWxSetClipboardDataResult {
|
|
305
|
+
errMsg: string;
|
|
306
|
+
}
|
|
307
|
+
interface HeadlessWxSetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxSetClipboardDataResult> {
|
|
308
|
+
data: string;
|
|
309
|
+
}
|
|
310
|
+
interface HeadlessWxGetClipboardDataResult {
|
|
311
|
+
data: string;
|
|
312
|
+
errMsg: string;
|
|
313
|
+
}
|
|
314
|
+
interface HeadlessWxGetClipboardDataOption extends HeadlessWxCallbackOption<HeadlessWxGetClipboardDataResult> {}
|
|
156
315
|
interface HeadlessWxGetStorageOption extends HeadlessWxCallbackOption<HeadlessWxGetStorageResult> {
|
|
157
316
|
key: string;
|
|
158
317
|
}
|
|
@@ -161,6 +320,48 @@ interface HeadlessWxGetNetworkTypeOption extends HeadlessWxCallbackOption<Headle
|
|
|
161
320
|
interface HeadlessWxGetSystemInfoOption extends HeadlessWxCallbackOption<HeadlessWxSystemInfoResult> {}
|
|
162
321
|
interface HeadlessWxGetWindowInfoOption extends HeadlessWxCallbackOption<HeadlessWxWindowInfoResult> {}
|
|
163
322
|
interface HeadlessWxGetAppBaseInfoOption extends HeadlessWxCallbackOption<HeadlessWxAppBaseInfoResult> {}
|
|
323
|
+
interface HeadlessWxGetImageInfoResult {
|
|
324
|
+
errMsg: string;
|
|
325
|
+
height: number;
|
|
326
|
+
orientation: 'up';
|
|
327
|
+
path: string;
|
|
328
|
+
type: string;
|
|
329
|
+
width: number;
|
|
330
|
+
}
|
|
331
|
+
interface HeadlessWxGetImageInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetImageInfoResult> {
|
|
332
|
+
src: string;
|
|
333
|
+
}
|
|
334
|
+
interface HeadlessWxGetFileInfoResult {
|
|
335
|
+
digest: string;
|
|
336
|
+
errMsg: string;
|
|
337
|
+
size: number;
|
|
338
|
+
}
|
|
339
|
+
interface HeadlessWxGetFileInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetFileInfoResult> {
|
|
340
|
+
digestAlgorithm?: 'md5' | 'sha1';
|
|
341
|
+
filePath: string;
|
|
342
|
+
}
|
|
343
|
+
interface HeadlessWxOpenDocumentResult {
|
|
344
|
+
errMsg: string;
|
|
345
|
+
}
|
|
346
|
+
interface HeadlessWxOpenDocumentOption extends HeadlessWxCallbackOption<HeadlessWxOpenDocumentResult> {
|
|
347
|
+
filePath: string;
|
|
348
|
+
fileType?: string;
|
|
349
|
+
showMenu?: boolean;
|
|
350
|
+
}
|
|
351
|
+
interface HeadlessWxGetVideoInfoResult {
|
|
352
|
+
bitrate: number;
|
|
353
|
+
duration: number;
|
|
354
|
+
errMsg: string;
|
|
355
|
+
fps: number;
|
|
356
|
+
height: number;
|
|
357
|
+
orientation: 'up';
|
|
358
|
+
size: number;
|
|
359
|
+
type: string;
|
|
360
|
+
width: number;
|
|
361
|
+
}
|
|
362
|
+
interface HeadlessWxGetVideoInfoOption extends HeadlessWxCallbackOption<HeadlessWxGetVideoInfoResult> {
|
|
363
|
+
src: string;
|
|
364
|
+
}
|
|
164
365
|
interface HeadlessWxRemoveStorageOption extends HeadlessWxCallbackOption<HeadlessWxStorageResult> {
|
|
165
366
|
key: string;
|
|
166
367
|
}
|
|
@@ -168,6 +369,9 @@ interface HeadlessWxClearStorageOption extends HeadlessWxCallbackOption<Headless
|
|
|
168
369
|
interface HeadlessWxHideLoadingOption extends HeadlessWxCallbackOption<{
|
|
169
370
|
errMsg: string;
|
|
170
371
|
}> {}
|
|
372
|
+
interface HeadlessWxStartPullDownRefreshOption extends HeadlessWxCallbackOption<{
|
|
373
|
+
errMsg: string;
|
|
374
|
+
}> {}
|
|
171
375
|
interface HeadlessWxSetBackgroundTextStyleOption extends HeadlessWxCallbackOption<{
|
|
172
376
|
errMsg: string;
|
|
173
377
|
}> {
|
|
@@ -301,6 +505,117 @@ interface HeadlessWxSaveFileOption extends HeadlessWxCallbackOption<HeadlessWxSa
|
|
|
301
505
|
filePath?: string;
|
|
302
506
|
tempFilePath: string;
|
|
303
507
|
}
|
|
508
|
+
interface HeadlessWxCanvasToTempFilePathSuccessResult {
|
|
509
|
+
errMsg: string;
|
|
510
|
+
tempFilePath: string;
|
|
511
|
+
}
|
|
512
|
+
interface HeadlessWxCanvasToTempFilePathOption extends HeadlessWxCallbackOption<HeadlessWxCanvasToTempFilePathSuccessResult> {
|
|
513
|
+
canvasId: string;
|
|
514
|
+
component?: Record<string, any>;
|
|
515
|
+
destHeight?: number;
|
|
516
|
+
destWidth?: number;
|
|
517
|
+
fileType?: string;
|
|
518
|
+
height?: number;
|
|
519
|
+
quality?: number;
|
|
520
|
+
width?: number;
|
|
521
|
+
x?: number;
|
|
522
|
+
y?: number;
|
|
523
|
+
}
|
|
524
|
+
interface HeadlessWxSaveImageToPhotosAlbumResult {
|
|
525
|
+
errMsg: string;
|
|
526
|
+
}
|
|
527
|
+
interface HeadlessWxSaveImageToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveImageToPhotosAlbumResult> {
|
|
528
|
+
filePath: string;
|
|
529
|
+
}
|
|
530
|
+
interface HeadlessWxSaveVideoToPhotosAlbumResult {
|
|
531
|
+
errMsg: string;
|
|
532
|
+
}
|
|
533
|
+
interface HeadlessWxSaveVideoToPhotosAlbumOption extends HeadlessWxCallbackOption<HeadlessWxSaveVideoToPhotosAlbumResult> {
|
|
534
|
+
filePath: string;
|
|
535
|
+
}
|
|
536
|
+
interface HeadlessWxPreviewImageResult {
|
|
537
|
+
errMsg: string;
|
|
538
|
+
}
|
|
539
|
+
interface HeadlessWxPreviewImageOption extends HeadlessWxCallbackOption<HeadlessWxPreviewImageResult> {
|
|
540
|
+
current?: string;
|
|
541
|
+
urls: string[];
|
|
542
|
+
}
|
|
543
|
+
interface HeadlessWxChooseImageTempFile {
|
|
544
|
+
path: string;
|
|
545
|
+
size: number;
|
|
546
|
+
}
|
|
547
|
+
interface HeadlessWxChooseImageResult {
|
|
548
|
+
errMsg: string;
|
|
549
|
+
tempFilePaths: string[];
|
|
550
|
+
tempFiles: HeadlessWxChooseImageTempFile[];
|
|
551
|
+
}
|
|
552
|
+
interface HeadlessWxChooseImageOption extends HeadlessWxCallbackOption<HeadlessWxChooseImageResult> {
|
|
553
|
+
count?: number;
|
|
554
|
+
sizeType?: string[];
|
|
555
|
+
sourceType?: string[];
|
|
556
|
+
}
|
|
557
|
+
interface HeadlessWxChooseMessageFileTempFile {
|
|
558
|
+
name: string;
|
|
559
|
+
path: string;
|
|
560
|
+
size: number;
|
|
561
|
+
time: number;
|
|
562
|
+
type: string;
|
|
563
|
+
}
|
|
564
|
+
interface HeadlessWxChooseMessageFileResult {
|
|
565
|
+
errMsg: string;
|
|
566
|
+
tempFiles: HeadlessWxChooseMessageFileTempFile[];
|
|
567
|
+
}
|
|
568
|
+
interface HeadlessWxChooseMessageFileOption extends HeadlessWxCallbackOption<HeadlessWxChooseMessageFileResult> {
|
|
569
|
+
count?: number;
|
|
570
|
+
extension?: string[];
|
|
571
|
+
type?: 'all' | 'file' | 'image' | 'video';
|
|
572
|
+
}
|
|
573
|
+
interface HeadlessWxCompressImageResult {
|
|
574
|
+
errMsg: string;
|
|
575
|
+
tempFilePath: string;
|
|
576
|
+
}
|
|
577
|
+
interface HeadlessWxCompressImageOption extends HeadlessWxCallbackOption<HeadlessWxCompressImageResult> {
|
|
578
|
+
compressedHeight?: number;
|
|
579
|
+
compressedWidth?: number;
|
|
580
|
+
quality?: number;
|
|
581
|
+
src: string;
|
|
582
|
+
}
|
|
583
|
+
interface HeadlessWxChooseVideoResult {
|
|
584
|
+
duration: number;
|
|
585
|
+
errMsg: string;
|
|
586
|
+
height: number;
|
|
587
|
+
size: number;
|
|
588
|
+
tempFilePath: string;
|
|
589
|
+
width: number;
|
|
590
|
+
}
|
|
591
|
+
interface HeadlessWxChooseVideoOption extends HeadlessWxCallbackOption<HeadlessWxChooseVideoResult> {
|
|
592
|
+
camera?: string[];
|
|
593
|
+
compressed?: boolean;
|
|
594
|
+
maxDuration?: number;
|
|
595
|
+
sourceType?: string[];
|
|
596
|
+
}
|
|
597
|
+
interface HeadlessWxChooseMediaTempFile {
|
|
598
|
+
duration?: number;
|
|
599
|
+
fileType: 'image' | 'video';
|
|
600
|
+
height: number;
|
|
601
|
+
size: number;
|
|
602
|
+
tempFilePath: string;
|
|
603
|
+
thumbTempFilePath?: string;
|
|
604
|
+
width: number;
|
|
605
|
+
}
|
|
606
|
+
interface HeadlessWxChooseMediaResult {
|
|
607
|
+
errMsg: string;
|
|
608
|
+
tempFiles: HeadlessWxChooseMediaTempFile[];
|
|
609
|
+
type: 'image' | 'mix' | 'video';
|
|
610
|
+
}
|
|
611
|
+
interface HeadlessWxChooseMediaOption extends HeadlessWxCallbackOption<HeadlessWxChooseMediaResult> {
|
|
612
|
+
camera?: string[];
|
|
613
|
+
count?: number;
|
|
614
|
+
maxDuration?: number;
|
|
615
|
+
mediaType?: Array<'image' | 'video'>;
|
|
616
|
+
sizeType?: string[];
|
|
617
|
+
sourceType?: string[];
|
|
618
|
+
}
|
|
304
619
|
interface HeadlessWxSavedFileInfo {
|
|
305
620
|
createTime: number;
|
|
306
621
|
filePath: string;
|
|
@@ -411,8 +726,21 @@ interface HeadlessWxFileSystemManager {
|
|
|
411
726
|
writeFileSync: (filePath: string, data: string, encoding?: string) => void;
|
|
412
727
|
}
|
|
413
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;
|
|
734
|
+
createAnimation: (option?: HeadlessWxAnimationStepOption) => HeadlessWxAnimation;
|
|
735
|
+
createCanvasContext: (canvasId: string, scope?: Record<string, any>) => HeadlessWxCanvasContext;
|
|
736
|
+
canvasToTempFilePath: (option: HeadlessWxCanvasToTempFilePathOption) => HeadlessWxCanvasToTempFilePathSuccessResult;
|
|
737
|
+
createIntersectionObserver: (scope: Record<string, any> | undefined, options?: HeadlessWxCreateIntersectionObserverOption) => HeadlessWxIntersectionObserver;
|
|
738
|
+
createVideoContext: (videoId: string, scope?: Record<string, any>) => HeadlessWxVideoContext;
|
|
414
739
|
executeSelectorQuery: (requests: HeadlessWxSelectorQueryRequest[], scope?: Record<string, any>) => unknown[];
|
|
415
740
|
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
741
|
+
getFileInfo: (option: HeadlessWxGetFileInfoOption) => HeadlessWxGetFileInfoResult;
|
|
742
|
+
getImageInfo: (option: HeadlessWxGetImageInfoOption) => HeadlessWxGetImageInfoResult;
|
|
743
|
+
getVideoInfo: (option: HeadlessWxGetVideoInfoOption) => HeadlessWxGetVideoInfoResult;
|
|
416
744
|
getFileSystemManager: () => HeadlessWxFileSystemManager;
|
|
417
745
|
getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult;
|
|
418
746
|
getSavedFileList: (option?: HeadlessWxGetSavedFileListOption) => HeadlessWxGetSavedFileListSuccessResult;
|
|
@@ -420,6 +748,7 @@ interface HeadlessWxDriver {
|
|
|
420
748
|
getEnterOptionsSync: () => HeadlessWxLaunchOptions;
|
|
421
749
|
getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
|
|
422
750
|
getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
|
|
751
|
+
getClipboardData: () => HeadlessWxGetClipboardDataResult;
|
|
423
752
|
getNetworkType: () => HeadlessWxGetNetworkTypeResult;
|
|
424
753
|
getStorageInfoSync: () => HeadlessWxStorageInfoResult;
|
|
425
754
|
getStorageSync: (key: string) => unknown;
|
|
@@ -437,14 +766,18 @@ interface HeadlessWxDriver {
|
|
|
437
766
|
nextTick: (callback?: () => void) => void;
|
|
438
767
|
offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
439
768
|
onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
769
|
+
openDocument: (option: HeadlessWxOpenDocumentOption) => HeadlessWxOpenDocumentResult;
|
|
440
770
|
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
441
771
|
reLaunch: (option: HeadlessWxNavigateOption) => unknown;
|
|
442
772
|
redirectTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
443
773
|
removeStorageSync: (key: string) => void;
|
|
444
774
|
request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
|
|
775
|
+
previewImage: (option: HeadlessWxPreviewImageOption) => HeadlessWxPreviewImageResult;
|
|
445
776
|
removeSavedFile: (option: HeadlessWxRemoveSavedFileOption) => {
|
|
446
777
|
errMsg: string;
|
|
447
778
|
};
|
|
779
|
+
saveImageToPhotosAlbum: (option: HeadlessWxSaveImageToPhotosAlbumOption) => HeadlessWxSaveImageToPhotosAlbumResult;
|
|
780
|
+
saveVideoToPhotosAlbum: (option: HeadlessWxSaveVideoToPhotosAlbumOption) => HeadlessWxSaveVideoToPhotosAlbumResult;
|
|
448
781
|
saveFile: (option: HeadlessWxSaveFileOption) => HeadlessWxSaveFileSuccessResult;
|
|
449
782
|
setBackgroundColor: (option: HeadlessWxSetBackgroundColorOption) => {
|
|
450
783
|
errMsg: string;
|
|
@@ -452,6 +785,7 @@ interface HeadlessWxDriver {
|
|
|
452
785
|
setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
|
|
453
786
|
errMsg: string;
|
|
454
787
|
};
|
|
788
|
+
setClipboardData: (option: HeadlessWxSetClipboardDataOption) => HeadlessWxSetClipboardDataResult;
|
|
455
789
|
setStorageSync: (key: string, value: unknown) => void;
|
|
456
790
|
setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
|
|
457
791
|
errMsg: string;
|
|
@@ -491,6 +825,9 @@ interface HeadlessWxDriver {
|
|
|
491
825
|
showToast: (option: HeadlessWxShowToastOption) => {
|
|
492
826
|
errMsg: string;
|
|
493
827
|
};
|
|
828
|
+
startPullDownRefresh: () => {
|
|
829
|
+
errMsg: string;
|
|
830
|
+
};
|
|
494
831
|
stopPullDownRefresh: () => void;
|
|
495
832
|
switchTab: (option: HeadlessWxNavigateOption) => unknown;
|
|
496
833
|
uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
|
|
@@ -506,9 +843,22 @@ interface HeadlessWxDriver {
|
|
|
506
843
|
}
|
|
507
844
|
interface HeadlessWx {
|
|
508
845
|
canIUse: (schema: string) => boolean;
|
|
846
|
+
chooseImage: (option?: HeadlessWxChooseImageOption) => HeadlessWxChooseImageResult | undefined;
|
|
847
|
+
chooseMessageFile: (option?: HeadlessWxChooseMessageFileOption) => HeadlessWxChooseMessageFileResult | undefined;
|
|
848
|
+
chooseMedia: (option?: HeadlessWxChooseMediaOption) => HeadlessWxChooseMediaResult | undefined;
|
|
849
|
+
chooseVideo: (option?: HeadlessWxChooseVideoOption) => HeadlessWxChooseVideoResult | undefined;
|
|
850
|
+
compressImage: (option: HeadlessWxCompressImageOption) => HeadlessWxCompressImageResult | undefined;
|
|
509
851
|
clearStorage: (option?: HeadlessWxClearStorageOption) => HeadlessWxStorageResult | undefined;
|
|
510
852
|
clearStorageSync: () => void;
|
|
853
|
+
canvasToTempFilePath: (option: HeadlessWxCanvasToTempFilePathOption) => HeadlessWxCanvasToTempFilePathSuccessResult | undefined;
|
|
854
|
+
createAnimation: (option?: HeadlessWxAnimationStepOption) => HeadlessWxAnimation;
|
|
855
|
+
createCanvasContext: (canvasId: string, component?: Record<string, any>) => HeadlessWxCanvasContext;
|
|
856
|
+
createIntersectionObserver: (component?: Record<string, any>, options?: HeadlessWxCreateIntersectionObserverOption) => HeadlessWxIntersectionObserver;
|
|
857
|
+
createVideoContext: (videoId: string, component?: Record<string, any>) => HeadlessWxVideoContext;
|
|
511
858
|
createSelectorQuery: () => HeadlessWxSelectorQuery;
|
|
859
|
+
getFileInfo: (option: HeadlessWxGetFileInfoOption) => HeadlessWxGetFileInfoResult | undefined;
|
|
860
|
+
getImageInfo: (option: HeadlessWxGetImageInfoOption) => HeadlessWxGetImageInfoResult | undefined;
|
|
861
|
+
getVideoInfo: (option: HeadlessWxGetVideoInfoOption) => HeadlessWxGetVideoInfoResult | undefined;
|
|
512
862
|
getFileSystemManager: () => HeadlessWxFileSystemManager;
|
|
513
863
|
getSavedFileInfo: (option: HeadlessWxGetSavedFileInfoOption) => HeadlessWxGetSavedFileInfoSuccessResult | undefined;
|
|
514
864
|
getSavedFileList: (option?: HeadlessWxGetSavedFileListOption) => HeadlessWxGetSavedFileListSuccessResult | undefined;
|
|
@@ -517,6 +867,7 @@ interface HeadlessWx {
|
|
|
517
867
|
getAppBaseInfoSync: () => HeadlessWxAppBaseInfoResult;
|
|
518
868
|
getLaunchOptionsSync: () => HeadlessWxLaunchOptions;
|
|
519
869
|
getMenuButtonBoundingClientRect: () => HeadlessWxMenuButtonBoundingClientRectResult;
|
|
870
|
+
getClipboardData: (option?: HeadlessWxGetClipboardDataOption) => HeadlessWxGetClipboardDataResult | undefined;
|
|
520
871
|
getNetworkType: (option?: HeadlessWxGetNetworkTypeOption) => HeadlessWxGetNetworkTypeResult | undefined;
|
|
521
872
|
getStorageInfo: (option?: HeadlessWxGetStorageInfoOption) => HeadlessWxStorageInfoResult | undefined;
|
|
522
873
|
getStorageInfoSync: () => HeadlessWxStorageInfoResult;
|
|
@@ -538,12 +889,16 @@ interface HeadlessWx {
|
|
|
538
889
|
nextTick: (callback?: () => void) => void;
|
|
539
890
|
offNetworkStatusChange: (callback?: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
540
891
|
onNetworkStatusChange: (callback: HeadlessWxNetworkStatusChangeCallback) => void;
|
|
892
|
+
openDocument: (option: HeadlessWxOpenDocumentOption) => HeadlessWxOpenDocumentResult | undefined;
|
|
541
893
|
pageScrollTo: (option: HeadlessWxPageScrollToOption) => unknown;
|
|
894
|
+
previewImage: (option: HeadlessWxPreviewImageOption) => HeadlessWxPreviewImageResult | undefined;
|
|
542
895
|
reLaunch: (option: HeadlessWxNavigateOption) => unknown;
|
|
543
896
|
redirectTo: (option: HeadlessWxNavigateOption) => unknown;
|
|
544
897
|
removeSavedFile: (option: HeadlessWxRemoveSavedFileOption) => {
|
|
545
898
|
errMsg: string;
|
|
546
899
|
} | undefined;
|
|
900
|
+
saveImageToPhotosAlbum: (option: HeadlessWxSaveImageToPhotosAlbumOption) => HeadlessWxSaveImageToPhotosAlbumResult | undefined;
|
|
901
|
+
saveVideoToPhotosAlbum: (option: HeadlessWxSaveVideoToPhotosAlbumOption) => HeadlessWxSaveVideoToPhotosAlbumResult | undefined;
|
|
547
902
|
removeStorage: (option: HeadlessWxRemoveStorageOption) => HeadlessWxStorageResult | undefined;
|
|
548
903
|
removeStorageSync: (key: string) => void;
|
|
549
904
|
request: (option: HeadlessWxRequestOption) => HeadlessWxRequestTask;
|
|
@@ -554,6 +909,7 @@ interface HeadlessWx {
|
|
|
554
909
|
setBackgroundTextStyle: (option: HeadlessWxSetBackgroundTextStyleOption) => {
|
|
555
910
|
errMsg: string;
|
|
556
911
|
} | undefined;
|
|
912
|
+
setClipboardData: (option: HeadlessWxSetClipboardDataOption) => HeadlessWxSetClipboardDataResult | undefined;
|
|
557
913
|
setStorage: (option: HeadlessWxSetStorageOption) => HeadlessWxStorageResult | undefined;
|
|
558
914
|
setStorageSync: (key: string, value: unknown) => void;
|
|
559
915
|
setNavigationBarColor: (option: HeadlessWxSetNavigationBarColorOption) => {
|
|
@@ -596,6 +952,9 @@ interface HeadlessWx {
|
|
|
596
952
|
showToast: (option: HeadlessWxShowToastOption) => {
|
|
597
953
|
errMsg: string;
|
|
598
954
|
} | undefined;
|
|
955
|
+
startPullDownRefresh: (option?: HeadlessWxStartPullDownRefreshOption) => {
|
|
956
|
+
errMsg: string;
|
|
957
|
+
} | undefined;
|
|
599
958
|
stopPullDownRefresh: () => void;
|
|
600
959
|
switchTab: (option: HeadlessWxNavigateOption) => unknown;
|
|
601
960
|
uploadFile: (option: HeadlessWxUploadFileOption) => HeadlessWxRequestTask;
|
|
@@ -680,6 +1039,8 @@ interface HeadlessComponentInstance extends Record<string, any> {
|
|
|
680
1039
|
__lastInteractionEvent__?: Record<string, any>;
|
|
681
1040
|
__propertySnapshots__?: Record<string, any>;
|
|
682
1041
|
__ready__?: boolean;
|
|
1042
|
+
createIntersectionObserver?: (options?: Record<string, any>) => any;
|
|
1043
|
+
createMediaQueryObserver?: () => HeadlessWxMediaQueryObserver;
|
|
683
1044
|
data: Record<string, any>;
|
|
684
1045
|
properties: Record<string, any>;
|
|
685
1046
|
selectAllComponents?: (selector: string) => any[];
|
|
@@ -732,6 +1093,8 @@ interface HeadlessPageInstance extends Record<string, any> {
|
|
|
732
1093
|
data: Record<string, any>;
|
|
733
1094
|
options: Record<string, string>;
|
|
734
1095
|
route: string;
|
|
1096
|
+
createIntersectionObserver?: (options?: Record<string, any>) => any;
|
|
1097
|
+
createMediaQueryObserver?: () => HeadlessWxMediaQueryObserver;
|
|
735
1098
|
selectAllComponents?: (selector: string) => any[];
|
|
736
1099
|
selectComponent?: (selector: string) => any;
|
|
737
1100
|
setData: (patch: Record<string, any>, callback?: () => void) => void;
|
|
@@ -779,6 +1142,8 @@ interface BrowserRendererContext {
|
|
|
779
1142
|
moduleLoader: BrowserModuleLoader;
|
|
780
1143
|
project: HeadlessProjectDescriptor;
|
|
781
1144
|
session: {
|
|
1145
|
+
createIntersectionObserver: (scope: any, options?: Record<string, any>) => any;
|
|
1146
|
+
createMediaQueryObserver: (scope: any) => any;
|
|
782
1147
|
selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
|
|
783
1148
|
selectComponentWithin: (scopeId: string, selector: string) => any;
|
|
784
1149
|
selectOwnerComponent: (scopeId: string) => any;
|
|
@@ -838,6 +1203,8 @@ interface RuntimeRendererContext {
|
|
|
838
1203
|
moduleLoader: HeadlessModuleLoader;
|
|
839
1204
|
project: HeadlessProjectDescriptor;
|
|
840
1205
|
session: {
|
|
1206
|
+
createIntersectionObserver: (scope: any, options?: Record<string, any>) => any;
|
|
1207
|
+
createMediaQueryObserver: (scope: any) => any;
|
|
841
1208
|
selectAllComponentsWithin: (scopeId: string, selector: string) => any[];
|
|
842
1209
|
selectComponentWithin: (scopeId: string, selector: string) => any;
|
|
843
1210
|
selectOwnerComponent: (scopeId: string) => any;
|
|
@@ -856,6 +1223,17 @@ interface HeadlessWxToastSnapshot {
|
|
|
856
1223
|
mask: boolean;
|
|
857
1224
|
title: string;
|
|
858
1225
|
}
|
|
1226
|
+
interface HeadlessWxPreviewImageSnapshot {
|
|
1227
|
+
current: string;
|
|
1228
|
+
urls: string[];
|
|
1229
|
+
visible: boolean;
|
|
1230
|
+
}
|
|
1231
|
+
interface HeadlessWxOpenDocumentSnapshot {
|
|
1232
|
+
filePath: string;
|
|
1233
|
+
fileType: string;
|
|
1234
|
+
showMenu: boolean;
|
|
1235
|
+
visible: boolean;
|
|
1236
|
+
}
|
|
859
1237
|
interface HeadlessWxNetworkSnapshot extends HeadlessWxNetworkStatusChangeResult {}
|
|
860
1238
|
interface HeadlessWxShareMenuSnapshot {
|
|
861
1239
|
isUpdatableMessage: boolean;
|
|
@@ -863,6 +1241,9 @@ interface HeadlessWxShareMenuSnapshot {
|
|
|
863
1241
|
visible: boolean;
|
|
864
1242
|
withShareTicket: boolean;
|
|
865
1243
|
}
|
|
1244
|
+
interface HeadlessWxClipboardSnapshot {
|
|
1245
|
+
data: string;
|
|
1246
|
+
}
|
|
866
1247
|
interface HeadlessWxActionSheetMockDefinition {
|
|
867
1248
|
cancel?: boolean;
|
|
868
1249
|
tapIndex?: number;
|
|
@@ -965,9 +1346,86 @@ declare function createHeadlessWxState(): {
|
|
|
965
1346
|
getDirectorySnapshot(): string[];
|
|
966
1347
|
getFileSystemManager(): HeadlessWxFileSystemManager;
|
|
967
1348
|
getSavedFileInfo(option: HeadlessWxGetSavedFileInfoOption): HeadlessWxGetSavedFileInfoSuccessResult;
|
|
1349
|
+
getFileInfo(option: HeadlessWxGetFileInfoOption): HeadlessWxGetFileInfoResult;
|
|
968
1350
|
getSavedFileList(): HeadlessWxGetSavedFileListSuccessResult;
|
|
969
1351
|
getFileText(filePath: string): string | null;
|
|
1352
|
+
createTempFile(fileContent: string, preferredPath?: string): string;
|
|
1353
|
+
chooseImage(option: {
|
|
1354
|
+
count?: number;
|
|
1355
|
+
sizeType?: string[];
|
|
1356
|
+
sourceType?: string[];
|
|
1357
|
+
}): {
|
|
1358
|
+
errMsg: string;
|
|
1359
|
+
tempFilePaths: string[];
|
|
1360
|
+
tempFiles: {
|
|
1361
|
+
path: string;
|
|
1362
|
+
size: number;
|
|
1363
|
+
}[];
|
|
1364
|
+
};
|
|
1365
|
+
chooseMessageFile(option: HeadlessWxChooseMessageFileOption): HeadlessWxChooseMessageFileResult;
|
|
1366
|
+
chooseMedia(option: {
|
|
1367
|
+
count?: number;
|
|
1368
|
+
maxDuration?: number;
|
|
1369
|
+
mediaType?: Array<"image" | "video">;
|
|
1370
|
+
sizeType?: string[];
|
|
1371
|
+
sourceType?: string[];
|
|
1372
|
+
}): {
|
|
1373
|
+
errMsg: string;
|
|
1374
|
+
tempFiles: ({
|
|
1375
|
+
duration: number;
|
|
1376
|
+
fileType: "video";
|
|
1377
|
+
height: number;
|
|
1378
|
+
size: number;
|
|
1379
|
+
tempFilePath: string;
|
|
1380
|
+
thumbTempFilePath: string;
|
|
1381
|
+
width: number;
|
|
1382
|
+
} | {
|
|
1383
|
+
fileType: "image";
|
|
1384
|
+
height: number;
|
|
1385
|
+
size: number;
|
|
1386
|
+
tempFilePath: string;
|
|
1387
|
+
width: number;
|
|
1388
|
+
duration?: undefined;
|
|
1389
|
+
thumbTempFilePath?: undefined;
|
|
1390
|
+
})[];
|
|
1391
|
+
type: "image" | "video" | "mix";
|
|
1392
|
+
};
|
|
1393
|
+
chooseVideo(option: {
|
|
1394
|
+
compressed?: boolean;
|
|
1395
|
+
maxDuration?: number;
|
|
1396
|
+
sourceType?: string[];
|
|
1397
|
+
}): {
|
|
1398
|
+
duration: number;
|
|
1399
|
+
errMsg: string;
|
|
1400
|
+
height: number;
|
|
1401
|
+
size: number;
|
|
1402
|
+
tempFilePath: string;
|
|
1403
|
+
width: number;
|
|
1404
|
+
};
|
|
1405
|
+
compressImage(option: {
|
|
1406
|
+
compressedHeight?: number;
|
|
1407
|
+
compressedWidth?: number;
|
|
1408
|
+
quality?: number;
|
|
1409
|
+
src: string;
|
|
1410
|
+
}): {
|
|
1411
|
+
errMsg: string;
|
|
1412
|
+
tempFilePath: string;
|
|
1413
|
+
};
|
|
970
1414
|
getNetworkType(): HeadlessWxGetNetworkTypeResult;
|
|
1415
|
+
getImageInfo(option: HeadlessWxGetImageInfoOption): HeadlessWxGetImageInfoResult;
|
|
1416
|
+
getVideoInfo(option: {
|
|
1417
|
+
src: string;
|
|
1418
|
+
}): {
|
|
1419
|
+
bitrate: number;
|
|
1420
|
+
duration: number;
|
|
1421
|
+
errMsg: string;
|
|
1422
|
+
fps: number;
|
|
1423
|
+
height: number;
|
|
1424
|
+
orientation: "up";
|
|
1425
|
+
size: number;
|
|
1426
|
+
type: string;
|
|
1427
|
+
width: number;
|
|
1428
|
+
};
|
|
971
1429
|
getModalLogs(): {
|
|
972
1430
|
result: {
|
|
973
1431
|
cancel: boolean;
|
|
@@ -1009,6 +1467,13 @@ declare function createHeadlessWxState(): {
|
|
|
1009
1467
|
getStorageSnapshot(): {
|
|
1010
1468
|
[k: string]: unknown;
|
|
1011
1469
|
};
|
|
1470
|
+
getClipboardData(): {
|
|
1471
|
+
data: string;
|
|
1472
|
+
errMsg: string;
|
|
1473
|
+
};
|
|
1474
|
+
getClipboardSnapshot(): {
|
|
1475
|
+
data: string;
|
|
1476
|
+
};
|
|
1012
1477
|
getStorageSync(key: string): unknown;
|
|
1013
1478
|
getShareMenu(): {
|
|
1014
1479
|
isUpdatableMessage: boolean;
|
|
@@ -1020,6 +1485,17 @@ declare function createHeadlessWxState(): {
|
|
|
1020
1485
|
mask: boolean;
|
|
1021
1486
|
title: string;
|
|
1022
1487
|
} | null;
|
|
1488
|
+
getPreviewImage(): {
|
|
1489
|
+
current: string;
|
|
1490
|
+
urls: string[];
|
|
1491
|
+
visible: boolean;
|
|
1492
|
+
} | null;
|
|
1493
|
+
getOpenedDocument(): {
|
|
1494
|
+
filePath: string;
|
|
1495
|
+
fileType: string;
|
|
1496
|
+
showMenu: boolean;
|
|
1497
|
+
visible: boolean;
|
|
1498
|
+
} | null;
|
|
1023
1499
|
hideShareMenu(): {
|
|
1024
1500
|
errMsg: string;
|
|
1025
1501
|
};
|
|
@@ -1059,13 +1535,37 @@ declare function createHeadlessWxState(): {
|
|
|
1059
1535
|
mockUploadFile(definition: HeadlessWxUploadFileMockDefinition): void;
|
|
1060
1536
|
mockActionSheet(definition?: HeadlessWxActionSheetMockDefinition): void;
|
|
1061
1537
|
onNetworkStatusChange(callback: HeadlessWxNetworkStatusChangeCallback): void;
|
|
1538
|
+
openDocument(option: HeadlessWxOpenDocumentOption): {
|
|
1539
|
+
errMsg: string;
|
|
1540
|
+
};
|
|
1541
|
+
previewImage(option: {
|
|
1542
|
+
current?: string;
|
|
1543
|
+
urls: string[];
|
|
1544
|
+
}): {
|
|
1545
|
+
errMsg: string;
|
|
1546
|
+
};
|
|
1062
1547
|
removeStorageSync(key: string): void;
|
|
1063
1548
|
request(option: HeadlessWxRequestOption): HeadlessWxRequestTask;
|
|
1064
1549
|
removeSavedFile(option: HeadlessWxRemoveSavedFileOption): {
|
|
1065
1550
|
errMsg: string;
|
|
1066
1551
|
};
|
|
1552
|
+
saveImageToPhotosAlbum(option: {
|
|
1553
|
+
filePath: string;
|
|
1554
|
+
}): {
|
|
1555
|
+
errMsg: string;
|
|
1556
|
+
};
|
|
1557
|
+
saveVideoToPhotosAlbum(option: {
|
|
1558
|
+
filePath: string;
|
|
1559
|
+
}): {
|
|
1560
|
+
errMsg: string;
|
|
1561
|
+
};
|
|
1067
1562
|
saveFile(option: HeadlessWxSaveFileOption): HeadlessWxSaveFileSuccessResult;
|
|
1068
1563
|
setStorageSync(key: string, value: unknown): void;
|
|
1564
|
+
setClipboardData(option: {
|
|
1565
|
+
data: string;
|
|
1566
|
+
}): {
|
|
1567
|
+
errMsg: string;
|
|
1568
|
+
};
|
|
1069
1569
|
setFile(filePath: string, fileContent: string): void;
|
|
1070
1570
|
setNetworkType(nextNetworkType: HeadlessWxNetworkType): {
|
|
1071
1571
|
errMsg: string;
|
|
@@ -1108,6 +1608,8 @@ declare class HeadlessSession {
|
|
|
1108
1608
|
private readonly tabBarState;
|
|
1109
1609
|
private tabBarVisible;
|
|
1110
1610
|
private readonly systemInfo;
|
|
1611
|
+
private readonly mediaQueryObservers;
|
|
1612
|
+
private readonly canvasContexts;
|
|
1111
1613
|
private enterOptions;
|
|
1112
1614
|
private launchOptions;
|
|
1113
1615
|
private readonly wxState;
|
|
@@ -1249,6 +1751,13 @@ declare class HeadlessSession {
|
|
|
1249
1751
|
keys: string[];
|
|
1250
1752
|
limitSize: number;
|
|
1251
1753
|
};
|
|
1754
|
+
getClipboardData(): HeadlessWxClipboardSnapshot;
|
|
1755
|
+
getPreviewImage(): {
|
|
1756
|
+
current: string;
|
|
1757
|
+
urls: string[];
|
|
1758
|
+
visible: boolean;
|
|
1759
|
+
} | null;
|
|
1760
|
+
getOpenedDocument(): HeadlessWxOpenDocumentSnapshot | null;
|
|
1252
1761
|
getPullDownRefreshState(): {
|
|
1253
1762
|
active: boolean;
|
|
1254
1763
|
stopCalls: number;
|
|
@@ -1393,6 +1902,9 @@ declare class HeadlessSession {
|
|
|
1393
1902
|
complete?: () => void;
|
|
1394
1903
|
}): void;
|
|
1395
1904
|
triggerPullDownRefresh(): HeadlessPageInstance;
|
|
1905
|
+
startPullDownRefresh(): {
|
|
1906
|
+
errMsg: string;
|
|
1907
|
+
};
|
|
1396
1908
|
triggerReachBottom(): HeadlessPageInstance;
|
|
1397
1909
|
triggerResize(options: Record<string, any>): HeadlessPageInstance;
|
|
1398
1910
|
triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
|
|
@@ -1409,8 +1921,17 @@ declare class HeadlessSession {
|
|
|
1409
1921
|
private requireCurrentPage;
|
|
1410
1922
|
private selectComponentsWithin;
|
|
1411
1923
|
private detachPageComponents;
|
|
1924
|
+
private notifyMediaQueryObservers;
|
|
1925
|
+
private clearMediaQueryObservers;
|
|
1412
1926
|
private runPageComponentLifetime;
|
|
1413
1927
|
private getComponentScopeId;
|
|
1928
|
+
private createVideoContext;
|
|
1929
|
+
private createAnimation;
|
|
1930
|
+
private resolveCanvasScopeKey;
|
|
1931
|
+
private createCanvasContext;
|
|
1932
|
+
private canvasToTempFilePath;
|
|
1933
|
+
private createIntersectionObserver;
|
|
1934
|
+
private createMediaQueryObserver;
|
|
1414
1935
|
}
|
|
1415
1936
|
declare function createHeadlessSession(options: HeadlessSessionOptions): HeadlessSession;
|
|
1416
1937
|
//#endregion
|
|
@@ -1436,6 +1957,8 @@ declare class BrowserHeadlessSession {
|
|
|
1436
1957
|
private readonly tabBarState;
|
|
1437
1958
|
private tabBarVisible;
|
|
1438
1959
|
private readonly systemInfo;
|
|
1960
|
+
private readonly mediaQueryObservers;
|
|
1961
|
+
private readonly canvasContexts;
|
|
1439
1962
|
private enterOptions;
|
|
1440
1963
|
private launchOptions;
|
|
1441
1964
|
private readonly wxState;
|
|
@@ -1549,6 +2072,13 @@ declare class BrowserHeadlessSession {
|
|
|
1549
2072
|
keys: string[];
|
|
1550
2073
|
limitSize: number;
|
|
1551
2074
|
};
|
|
2075
|
+
getClipboardData(): HeadlessWxClipboardSnapshot;
|
|
2076
|
+
getPreviewImage(): {
|
|
2077
|
+
current: string;
|
|
2078
|
+
urls: string[];
|
|
2079
|
+
visible: boolean;
|
|
2080
|
+
} | null;
|
|
2081
|
+
getOpenedDocument(): HeadlessWxOpenDocumentSnapshot | null;
|
|
1552
2082
|
getPullDownRefreshState(): {
|
|
1553
2083
|
active: boolean;
|
|
1554
2084
|
stopCalls: number;
|
|
@@ -1733,6 +2263,9 @@ declare class BrowserHeadlessSession {
|
|
|
1733
2263
|
scrollTop?: number;
|
|
1734
2264
|
}): void;
|
|
1735
2265
|
triggerPullDownRefresh(): HeadlessPageInstance;
|
|
2266
|
+
startPullDownRefresh(): {
|
|
2267
|
+
errMsg: string;
|
|
2268
|
+
};
|
|
1736
2269
|
triggerReachBottom(): HeadlessPageInstance;
|
|
1737
2270
|
triggerResize(options: Record<string, any>): HeadlessPageInstance;
|
|
1738
2271
|
triggerRouteDone(options?: Record<string, any>): HeadlessPageInstance;
|
|
@@ -1748,8 +2281,17 @@ declare class BrowserHeadlessSession {
|
|
|
1748
2281
|
private unloadPage;
|
|
1749
2282
|
private requireCurrentPage;
|
|
1750
2283
|
private detachPageComponents;
|
|
2284
|
+
private notifyMediaQueryObservers;
|
|
2285
|
+
private clearMediaQueryObservers;
|
|
1751
2286
|
private runPageComponentLifetime;
|
|
1752
2287
|
private getComponentScopeId;
|
|
2288
|
+
private createVideoContext;
|
|
2289
|
+
private createAnimation;
|
|
2290
|
+
private resolveCanvasScopeKey;
|
|
2291
|
+
private createCanvasContext;
|
|
2292
|
+
private canvasToTempFilePath;
|
|
2293
|
+
private createIntersectionObserver;
|
|
2294
|
+
private createMediaQueryObserver;
|
|
1753
2295
|
}
|
|
1754
2296
|
declare function createBrowserHeadlessSession(options: BrowserHeadlessSessionOptions): BrowserHeadlessSession;
|
|
1755
2297
|
//#endregion
|
|
@@ -1855,6 +2397,7 @@ interface DomNodeLike$1 {
|
|
|
1855
2397
|
}
|
|
1856
2398
|
interface HeadlessSelectorQueryResolverOptions {
|
|
1857
2399
|
page: HeadlessPageInstance;
|
|
2400
|
+
resolveContext?: (node: DomNodeLike$1) => unknown;
|
|
1858
2401
|
root: DomNodeLike$1;
|
|
1859
2402
|
windowInfo: HeadlessWxWindowInfoResult;
|
|
1860
2403
|
}
|
|
@@ -1998,4 +2541,4 @@ interface HeadlessTestingLaunchOptions {
|
|
|
1998
2541
|
}
|
|
1999
2542
|
declare function launch(options: HeadlessTestingLaunchOptions): Promise<HeadlessTestingSessionHandle>;
|
|
2000
2543
|
//#endregion
|
|
2001
|
-
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, HeadlessWxAppBaseInfoResult, HeadlessWxAppendFileOption, HeadlessWxCallbackOption, HeadlessWxClearStorageOption, HeadlessWxCopyFileOption, HeadlessWxDownloadFileLogEntry, HeadlessWxDownloadFileMockDefinition, HeadlessWxDownloadFileOption, HeadlessWxDownloadFileSuccessResult, HeadlessWxDriver, HeadlessWxFileSystemManager, HeadlessWxFileSystemResult, HeadlessWxGetAppBaseInfoOption, HeadlessWxGetNetworkTypeOption, HeadlessWxGetNetworkTypeResult, HeadlessWxGetSavedFileInfoOption, HeadlessWxGetSavedFileInfoSuccessResult, HeadlessWxGetSavedFileListOption, HeadlessWxGetSavedFileListSuccessResult, HeadlessWxGetStorageInfoOption, HeadlessWxGetStorageOption, HeadlessWxGetStorageResult, HeadlessWxGetSystemInfoOption, HeadlessWxGetWindowInfoOption, HeadlessWxHideLoadingOption, HeadlessWxHideNavigationBarLoadingOption, HeadlessWxLaunchOptions, HeadlessWxLoadingSnapshot, HeadlessWxMenuButtonBoundingClientRectResult, HeadlessWxMkdirOption, HeadlessWxModalLogEntry, HeadlessWxModalMockDefinition, HeadlessWxNavigateBackOption, HeadlessWxNavigateOption, HeadlessWxNetworkSnapshot, HeadlessWxNetworkStatusChangeCallback, HeadlessWxNetworkStatusChangeResult, HeadlessWxNetworkType, HeadlessWxPageScrollToOption, HeadlessWxReadDirOption, HeadlessWxReadDirSuccessResult, HeadlessWxReadFileOption, HeadlessWxReadFileSuccessResult, HeadlessWxRemoveSavedFileOption, HeadlessWxRemoveStorageOption, HeadlessWxRenameOption, HeadlessWxRequestLogEntry, HeadlessWxRequestMockDefinition, HeadlessWxRequestOption, HeadlessWxRequestSuccessResult, HeadlessWxRequestTask, HeadlessWxRmdirOption, HeadlessWxSaveFileOption, HeadlessWxSaveFileSuccessResult, HeadlessWxSavedFileInfo, HeadlessWxSelectorQuery, HeadlessWxSelectorQueryBoundingClientRectResult, HeadlessWxSelectorQueryFieldsOption, HeadlessWxSelectorQueryNode, HeadlessWxSelectorQueryRequest, HeadlessWxSelectorQueryScrollOffsetResult, HeadlessWxSetBackgroundColorOption, HeadlessWxSetBackgroundTextStyleOption, HeadlessWxSetNavigationBarColorOption, HeadlessWxSetNavigationBarTitleOption, HeadlessWxSetStorageOption, HeadlessWxSetTabBarBadgeOption, HeadlessWxShareMenuOption, HeadlessWxShareMenuSnapshot, HeadlessWxShowActionSheetOption, HeadlessWxShowActionSheetResult, HeadlessWxShowLoadingOption, HeadlessWxShowModalOption, HeadlessWxShowModalResult, HeadlessWxShowNavigationBarLoadingOption, HeadlessWxShowToastOption, HeadlessWxStatOption, HeadlessWxStatSuccessResult, HeadlessWxStats, HeadlessWxStorageInfoResult, HeadlessWxStorageResult, HeadlessWxSystemInfoResult, HeadlessWxTabBarItemOption, HeadlessWxTabBarOption, HeadlessWxToastSnapshot, HeadlessWxUnlinkOption, HeadlessWxUploadFileLogEntry, HeadlessWxUploadFileMockDefinition, HeadlessWxUploadFileOption, HeadlessWxUploadFileSuccessResult, 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 };
|
|
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 };
|