@silkui/core 0.1.8 → 0.1.9
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 +3 -1
- package/package.json +1 -1
- package/src/index.d.ts +383 -8
- package/src/index.js +2017 -120
package/README.md
CHANGED
|
@@ -59,7 +59,9 @@ mount(createBox({ position: "absolute", inset: 0, display: "flex", alignItems: "
|
|
|
59
59
|
| --- | --- |
|
|
60
60
|
| `createBox(style?, ...children)` | A box with `style` as its base look. Strings among the children become text nodes |
|
|
61
61
|
| `createText(data?)` | A text node. It takes its look from its parent |
|
|
62
|
-
| `createInput(style?)` | An editable text field. `value`, `selectionStart`, `selectionEnd` and `
|
|
62
|
+
| `createInput(style?)` | An editable text field. `value`, `selectionStart`, `selectionEnd`, `selectionDirection`, `setSelectionRange`, `select` and `setRangeText` work as on an `<input>`, in UTF-16 string indices |
|
|
63
|
+
| `createRange()`, `new Range()`, `new StaticRange(init)` | DOM Standard ranges over the app's nodes. Live ranges follow insertions, removals and text edits (`insertData`, `splitText`, `normalize` and the rest of Text's methods) |
|
|
64
|
+
| `createDocumentFragment()` | Nodes held outside the tree, as `DocumentFragment`; `cloneContents` and `extractContents` return one |
|
|
63
65
|
| `createRichInput(style?)` | A text field with marks and inline atoms (see below) |
|
|
64
66
|
| `createImage(src, style?)` | An image, as an `<img>`: `src` is a `data:` URL, a file or an `http(s):` address. An SVG file draws as an inline `<svg>` |
|
|
65
67
|
| `createSvgElement(tag)` | `document.createElementNS` for SVG: an `Svg` root for `"svg"`, else an `SvgElement` (`path`, `g`, ...) to append inside one |
|
package/package.json
CHANGED
package/src/index.d.ts
CHANGED
|
@@ -37,7 +37,12 @@ export interface Look {
|
|
|
37
37
|
}
|
|
38
38
|
|
|
39
39
|
export type Listener<E extends Event = Event> = ((this: Node, event: E) => void) | { handleEvent(event: E): void };
|
|
40
|
-
|
|
40
|
+
/** What `signal` needs from an `AbortSignal`. */
|
|
41
|
+
export interface ListenerSignal {
|
|
42
|
+
readonly aborted: boolean;
|
|
43
|
+
addEventListener(type: "abort", listener: () => void, options?: { once?: boolean }): void;
|
|
44
|
+
}
|
|
45
|
+
export type ListenerOptions = boolean | { capture?: boolean; once?: boolean; signal?: ListenerSignal };
|
|
41
46
|
|
|
42
47
|
/** Live tokens in a node's class attribute. */
|
|
43
48
|
export class ClassList implements Iterable<string> {
|
|
@@ -74,8 +79,17 @@ export class Node {
|
|
|
74
79
|
readonly lastChild: Node | null;
|
|
75
80
|
readonly nextSibling: Node | null;
|
|
76
81
|
readonly previousSibling: Node | null;
|
|
82
|
+
/** 1 for an element, 3 for text, 11 for a document fragment, as in the DOM. */
|
|
83
|
+
readonly nodeType: 1 | 3 | 11;
|
|
84
|
+
hasChildNodes(): boolean;
|
|
85
|
+
/** A copy with the same looks and attributes, and with `deep` copies of the children. */
|
|
86
|
+
cloneNode(deep?: boolean): this;
|
|
87
|
+
/** Joins adjacent text children and drops empty ones, in the whole subtree. */
|
|
88
|
+
normalize(): void;
|
|
77
89
|
/** Whether `other` is this node or inside it. */
|
|
78
90
|
contains(other: Node | null): boolean;
|
|
91
|
+
/** Puts `node` where `child` is and detaches `child`. */
|
|
92
|
+
replaceChild<T extends Node>(node: Node, child: T): T;
|
|
79
93
|
/** Inserts `child` before `before`, or last without it. A child already in the tree moves. */
|
|
80
94
|
insertBefore<T extends Node>(child: T, before?: Node | null): T;
|
|
81
95
|
appendChild<T extends Node>(child: T): T;
|
|
@@ -104,8 +118,44 @@ export class Node {
|
|
|
104
118
|
set tabIndex(value: number);
|
|
105
119
|
set disabled(value: boolean);
|
|
106
120
|
focus(): void;
|
|
121
|
+
/** As DOM `setPointerCapture`: throws `NotFoundError` for a pointer that is not down. */
|
|
122
|
+
setPointerCapture(pointerId: number): void;
|
|
123
|
+
releasePointerCapture(pointerId: number): void;
|
|
124
|
+
hasPointerCapture(pointerId: number): boolean;
|
|
107
125
|
scrollTo(x: number, y: number): void;
|
|
126
|
+
scrollTo(options: ScrollToOptions): void;
|
|
108
127
|
scroll(x: number, y: number): void;
|
|
128
|
+
scroll(options: ScrollToOptions): void;
|
|
129
|
+
scrollBy(x: number, y: number): void;
|
|
130
|
+
scrollBy(options: ScrollToOptions): void;
|
|
131
|
+
/** `true` or nothing aligns to the start, `false` to the end. */
|
|
132
|
+
scrollIntoView(options?: boolean | ScrollIntoViewOptions): void;
|
|
133
|
+
scrollIntoViewIfNeeded(center?: boolean): void;
|
|
134
|
+
/** Layout reads: each lays out first when something changed, as a browser does. */
|
|
135
|
+
getBoundingClientRect(): DOMRect;
|
|
136
|
+
getClientRects(): DOMRect[] & { item(index: number): DOMRect | null };
|
|
137
|
+
readonly clientLeft: number;
|
|
138
|
+
readonly clientTop: number;
|
|
139
|
+
readonly clientWidth: number;
|
|
140
|
+
readonly clientHeight: number;
|
|
141
|
+
readonly scrollWidth: number;
|
|
142
|
+
readonly scrollHeight: number;
|
|
143
|
+
scrollLeft: number;
|
|
144
|
+
scrollTop: number;
|
|
145
|
+
readonly offsetParent: Node | null;
|
|
146
|
+
readonly offsetLeft: number;
|
|
147
|
+
readonly offsetTop: number;
|
|
148
|
+
readonly offsetWidth: number;
|
|
149
|
+
readonly offsetHeight: number;
|
|
150
|
+
/** Whether this node matches CSS `selector`, by the stylesheet matcher. Throws a SyntaxError for an invalid selector. */
|
|
151
|
+
matches(selector: string): boolean;
|
|
152
|
+
webkitMatchesSelector(selector: string): boolean;
|
|
153
|
+
/** This node or its nearest ancestor that matches `selector`. */
|
|
154
|
+
closest(selector: string): Node | null;
|
|
155
|
+
/** The first descendant, in tree order, that matches `selector`. */
|
|
156
|
+
querySelector(selector: string): Node | null;
|
|
157
|
+
/** Every descendant that matches `selector`, in tree order (a static list). */
|
|
158
|
+
querySelectorAll(selector: string): Node[];
|
|
109
159
|
addEventListener<K extends keyof EventMap>(type: K, listener: Listener<EventMap[K]>, options?: ListenerOptions): void;
|
|
110
160
|
/** The app's own event types, sent with `dispatchEvent`. */
|
|
111
161
|
addEventListener(type: string, listener: (event: globalThis.Event) => void, options?: ListenerOptions): void;
|
|
@@ -119,17 +169,149 @@ export class Node {
|
|
|
119
169
|
export class Text extends Node {
|
|
120
170
|
constructor(data?: string);
|
|
121
171
|
data: string;
|
|
172
|
+
nodeValue: string;
|
|
122
173
|
textContent: string;
|
|
174
|
+
/** In UTF-16 code units. */
|
|
175
|
+
readonly length: number;
|
|
176
|
+
substringData(offset: number, count: number): string;
|
|
177
|
+
appendData(data: string): void;
|
|
178
|
+
insertData(offset: number, data: string): void;
|
|
179
|
+
deleteData(offset: number, count: number): void;
|
|
180
|
+
replaceData(offset: number, count: number, data: string): void;
|
|
181
|
+
/** Splits at `offset`: this keeps the text before it, and a new next sibling the rest. */
|
|
182
|
+
splitText(offset: number): Text;
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
/** Nodes held together outside the tree. Inserting it inserts its children and empties it. */
|
|
186
|
+
export class DocumentFragment extends Node {
|
|
187
|
+
constructor();
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
export function createDocumentFragment(): DocumentFragment;
|
|
191
|
+
|
|
192
|
+
/** Two boundary points: a node and an offset (a child index, or UTF-16 units in text). */
|
|
193
|
+
export abstract class AbstractRange {
|
|
194
|
+
readonly startContainer: Node;
|
|
195
|
+
readonly startOffset: number;
|
|
196
|
+
readonly endContainer: Node;
|
|
197
|
+
readonly endOffset: number;
|
|
198
|
+
readonly collapsed: boolean;
|
|
199
|
+
}
|
|
200
|
+
|
|
201
|
+
export interface StaticRangeInit {
|
|
202
|
+
startContainer: Node;
|
|
203
|
+
startOffset: number;
|
|
204
|
+
endContainer: Node;
|
|
205
|
+
endOffset: number;
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
/** A range that does not follow changes to the tree. */
|
|
209
|
+
export class StaticRange extends AbstractRange {
|
|
210
|
+
constructor(init: StaticRangeInit);
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
/** A live range over the app's nodes, as the DOM Standard defines it. */
|
|
214
|
+
export class Range extends AbstractRange {
|
|
215
|
+
static readonly START_TO_START: 0;
|
|
216
|
+
static readonly START_TO_END: 1;
|
|
217
|
+
static readonly END_TO_END: 2;
|
|
218
|
+
static readonly END_TO_START: 3;
|
|
219
|
+
readonly START_TO_START: 0;
|
|
220
|
+
readonly START_TO_END: 1;
|
|
221
|
+
readonly END_TO_END: 2;
|
|
222
|
+
readonly END_TO_START: 3;
|
|
223
|
+
/** Collapsed at the start of the mounted root. */
|
|
224
|
+
constructor();
|
|
225
|
+
readonly commonAncestorContainer: Node;
|
|
226
|
+
setStart(node: Node, offset: number): void;
|
|
227
|
+
setEnd(node: Node, offset: number): void;
|
|
228
|
+
setStartBefore(node: Node): void;
|
|
229
|
+
setStartAfter(node: Node): void;
|
|
230
|
+
setEndBefore(node: Node): void;
|
|
231
|
+
setEndAfter(node: Node): void;
|
|
232
|
+
collapse(toStart?: boolean): void;
|
|
233
|
+
selectNode(node: Node): void;
|
|
234
|
+
selectNodeContents(node: Node): void;
|
|
235
|
+
compareBoundaryPoints(how: 0 | 1 | 2 | 3, sourceRange: Range): -1 | 0 | 1;
|
|
236
|
+
comparePoint(node: Node, offset: number): -1 | 0 | 1;
|
|
237
|
+
isPointInRange(node: Node, offset: number): boolean;
|
|
238
|
+
intersectsNode(node: Node): boolean;
|
|
239
|
+
cloneRange(): Range;
|
|
240
|
+
detach(): void;
|
|
241
|
+
deleteContents(): void;
|
|
242
|
+
extractContents(): DocumentFragment;
|
|
243
|
+
cloneContents(): DocumentFragment;
|
|
244
|
+
insertNode(node: Node): void;
|
|
245
|
+
surroundContents(newParent: Node): void;
|
|
246
|
+
toString(): string;
|
|
247
|
+
getClientRects(): DOMRect[];
|
|
248
|
+
getBoundingClientRect(): DOMRect;
|
|
123
249
|
}
|
|
124
250
|
|
|
125
|
-
/**
|
|
251
|
+
/** A new live range, collapsed at the start of the root. */
|
|
252
|
+
export function createRange(): Range;
|
|
253
|
+
|
|
254
|
+
/**
|
|
255
|
+
* The document's selection, which the tree keeps (presses, drags, keys) and scripts can read
|
|
256
|
+
* and change. Its ranges are live, in tree order: one, or one per piece seen when the
|
|
257
|
+
* selection crosses children that layout reorders.
|
|
258
|
+
*/
|
|
259
|
+
export class Selection {
|
|
260
|
+
private constructor();
|
|
261
|
+
readonly anchorNode: Node | null;
|
|
262
|
+
readonly anchorOffset: number;
|
|
263
|
+
readonly focusNode: Node | null;
|
|
264
|
+
readonly focusOffset: number;
|
|
265
|
+
readonly isCollapsed: boolean;
|
|
266
|
+
readonly rangeCount: number;
|
|
267
|
+
readonly type: "None" | "Caret" | "Range";
|
|
268
|
+
readonly direction: "forward" | "backward" | "none";
|
|
269
|
+
getRangeAt(index: number): Range;
|
|
270
|
+
addRange(range: Range): void;
|
|
271
|
+
removeRange(range: Range): void;
|
|
272
|
+
removeAllRanges(): void;
|
|
273
|
+
empty(): void;
|
|
274
|
+
collapse(node: Node | null, offset?: number): void;
|
|
275
|
+
setPosition(node: Node | null, offset?: number): void;
|
|
276
|
+
collapseToStart(): void;
|
|
277
|
+
collapseToEnd(): void;
|
|
278
|
+
extend(node: Node, offset?: number): void;
|
|
279
|
+
setBaseAndExtent(anchorNode: Node, anchorOffset: number, focusNode: Node, focusOffset: number): void;
|
|
280
|
+
selectAllChildren(node: Node): void;
|
|
281
|
+
deleteFromDocument(): void;
|
|
282
|
+
containsNode(node: Node, allowPartialContainment?: boolean): boolean;
|
|
283
|
+
getComposedRanges(): StaticRange[];
|
|
284
|
+
/** The selected text as copying gives it. */
|
|
285
|
+
toString(): string;
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
/** The document's selection. Also installed as `globalThis.getSelection`. */
|
|
289
|
+
export function getSelection(): Selection;
|
|
290
|
+
|
|
291
|
+
/**
|
|
292
|
+
* An editable text field. `value` follows what the user types. Selection offsets are UTF-16
|
|
293
|
+
* string indices, as on the web.
|
|
294
|
+
*/
|
|
126
295
|
export class Input extends Node {
|
|
127
296
|
constructor();
|
|
297
|
+
/** Setting a different value puts the caret at its end. */
|
|
128
298
|
value: string;
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
299
|
+
selectionStart: number;
|
|
300
|
+
selectionEnd: number;
|
|
301
|
+
selectionDirection: "forward" | "backward" | "none";
|
|
302
|
+
/** Selects `start` to `end`; with `direction` "backward" the caret sits at `start`. */
|
|
303
|
+
setSelectionRange(start: number, end: number, direction?: "forward" | "backward" | "none"): void;
|
|
304
|
+
/** Selects the whole value. */
|
|
305
|
+
select(): void;
|
|
306
|
+
/** Replaces the selection with `replacement`. */
|
|
307
|
+
setRangeText(replacement: string): void;
|
|
308
|
+
/** Replaces `start` to `end` with `replacement` and places the selection by `selectionMode`. */
|
|
309
|
+
setRangeText(
|
|
310
|
+
replacement: string,
|
|
311
|
+
start: number,
|
|
312
|
+
end: number,
|
|
313
|
+
selectionMode?: "select" | "start" | "end" | "preserve",
|
|
314
|
+
): void;
|
|
133
315
|
}
|
|
134
316
|
|
|
135
317
|
/** An inline atom of a rich input: a mention or a chip. */
|
|
@@ -175,8 +357,6 @@ export class RichInput extends Input {
|
|
|
175
357
|
toggleMark(name: string): void;
|
|
176
358
|
/** Replaces the text from `start` to `end` with `atom`. */
|
|
177
359
|
insertAtom(start: number, end: number, atom: RichAtom): void;
|
|
178
|
-
/** Selects from `anchor` to `focus`, as string indices. */
|
|
179
|
-
setSelectionRange(anchor: number, focus: number): void;
|
|
180
360
|
}
|
|
181
361
|
|
|
182
362
|
/**
|
|
@@ -262,6 +442,26 @@ export interface PointerEvent extends ModifierEvent {
|
|
|
262
442
|
readonly clientY: number;
|
|
263
443
|
readonly x: number;
|
|
264
444
|
readonly y: number;
|
|
445
|
+
/** 1 for the mouse, 2 and up for touches. */
|
|
446
|
+
readonly pointerId: number;
|
|
447
|
+
readonly pointerType: "mouse" | "pen" | "touch";
|
|
448
|
+
readonly isPrimary: boolean;
|
|
449
|
+
/** -1 for `pointermove`, as on the web. */
|
|
450
|
+
readonly button: number;
|
|
451
|
+
readonly buttons: number;
|
|
452
|
+
/** 0.5 while a button is down, 0 otherwise: no host reports pressure yet. */
|
|
453
|
+
readonly pressure: number;
|
|
454
|
+
readonly tangentialPressure: number;
|
|
455
|
+
readonly tiltX: number;
|
|
456
|
+
readonly tiltY: number;
|
|
457
|
+
readonly twist: number;
|
|
458
|
+
readonly altitudeAngle: number;
|
|
459
|
+
readonly azimuthAngle: number;
|
|
460
|
+
readonly width: number;
|
|
461
|
+
readonly height: number;
|
|
462
|
+
/** The event itself for `pointermove` (each host move is its own event), empty otherwise. */
|
|
463
|
+
getCoalescedEvents(): PointerEvent[];
|
|
464
|
+
getPredictedEvents(): PointerEvent[];
|
|
265
465
|
}
|
|
266
466
|
|
|
267
467
|
/** `pointerdown`, `pointerup` and `click`. */
|
|
@@ -271,6 +471,48 @@ export interface PointerButtonEvent extends PointerEvent {
|
|
|
271
471
|
readonly detail: number;
|
|
272
472
|
}
|
|
273
473
|
|
|
474
|
+
/** A compatibility mouse event, after the pointer event of a mouse, or before a tap's click. */
|
|
475
|
+
export interface MouseEvent extends ModifierEvent {
|
|
476
|
+
readonly clientX: number;
|
|
477
|
+
readonly clientY: number;
|
|
478
|
+
readonly x: number;
|
|
479
|
+
readonly y: number;
|
|
480
|
+
readonly button: number;
|
|
481
|
+
readonly buttons: number;
|
|
482
|
+
readonly detail: number;
|
|
483
|
+
}
|
|
484
|
+
|
|
485
|
+
/** One finger, as DOM `Touch`. No host reports contact size or force yet. */
|
|
486
|
+
export interface Touch {
|
|
487
|
+
readonly identifier: number;
|
|
488
|
+
/** The node the finger went down on, for as long as it stays down. */
|
|
489
|
+
readonly target: Node;
|
|
490
|
+
readonly clientX: number;
|
|
491
|
+
readonly clientY: number;
|
|
492
|
+
readonly pageX: number;
|
|
493
|
+
readonly pageY: number;
|
|
494
|
+
readonly screenX: number;
|
|
495
|
+
readonly screenY: number;
|
|
496
|
+
readonly radiusX: number;
|
|
497
|
+
readonly radiusY: number;
|
|
498
|
+
readonly rotationAngle: number;
|
|
499
|
+
readonly force: number;
|
|
500
|
+
}
|
|
501
|
+
|
|
502
|
+
export interface TouchList extends ReadonlyArray<Touch> {
|
|
503
|
+
item(index: number): Touch | null;
|
|
504
|
+
}
|
|
505
|
+
|
|
506
|
+
/**
|
|
507
|
+
* As DOM `TouchEvent`, after the finger's pointer event. Preventing `touchstart` or a
|
|
508
|
+
* `touchmove` before the tree pans keeps the gesture: no pan and no click.
|
|
509
|
+
*/
|
|
510
|
+
export interface TouchEvent extends ModifierEvent {
|
|
511
|
+
readonly touches: TouchList;
|
|
512
|
+
readonly targetTouches: TouchList;
|
|
513
|
+
readonly changedTouches: TouchList;
|
|
514
|
+
}
|
|
515
|
+
|
|
274
516
|
export interface WheelEvent extends PointerEvent {
|
|
275
517
|
readonly deltaX: number;
|
|
276
518
|
readonly deltaY: number;
|
|
@@ -330,6 +572,19 @@ export interface EventMap {
|
|
|
330
572
|
pointerenter: PointerEvent;
|
|
331
573
|
pointerleave: PointerEvent;
|
|
332
574
|
pointercancel: PointerEvent;
|
|
575
|
+
pointerover: PointerEvent;
|
|
576
|
+
pointerout: PointerEvent;
|
|
577
|
+
touchstart: TouchEvent;
|
|
578
|
+
touchmove: TouchEvent;
|
|
579
|
+
touchend: TouchEvent;
|
|
580
|
+
touchcancel: TouchEvent;
|
|
581
|
+
mousedown: MouseEvent;
|
|
582
|
+
mouseup: MouseEvent;
|
|
583
|
+
mousemove: MouseEvent;
|
|
584
|
+
mouseover: MouseEvent;
|
|
585
|
+
mouseout: MouseEvent;
|
|
586
|
+
mouseenter: MouseEvent;
|
|
587
|
+
mouseleave: MouseEvent;
|
|
333
588
|
wheel: WheelEvent;
|
|
334
589
|
keydown: KeyboardEvent;
|
|
335
590
|
keyup: KeyboardEvent;
|
|
@@ -508,6 +763,30 @@ export interface MemoryUsage {
|
|
|
508
763
|
*/
|
|
509
764
|
export function memoryUsage(): MemoryUsage | null;
|
|
510
765
|
|
|
766
|
+
/**
|
|
767
|
+
* The values the tree resolved for `node`, read one property at a time: typed and animated
|
|
768
|
+
* properties as they are now, box sizes, margins, padding and border widths as laid out, the
|
|
769
|
+
* rest as cascaded with lengths in pixels. Shorthands, custom properties and pseudo-elements
|
|
770
|
+
* read "". Also installed as `globalThis.getComputedStyle`.
|
|
771
|
+
*/
|
|
772
|
+
export function getComputedStyle(node: Node | { node: Node }, pseudo?: string | null): ComputedStyle;
|
|
773
|
+
|
|
774
|
+
/**
|
|
775
|
+
* `CSS.supports`, answered as the tree's `@supports` answers. Also installed as
|
|
776
|
+
* `globalThis.CSS.supports`.
|
|
777
|
+
*/
|
|
778
|
+
export function supports(property: string, value: string): boolean;
|
|
779
|
+
export function supports(conditionText: string): boolean;
|
|
780
|
+
|
|
781
|
+
/** What `getComputedStyle` returns: read-only, live, a value per camelCase property name. */
|
|
782
|
+
export type ComputedStyle = {
|
|
783
|
+
getPropertyValue(name: string): string;
|
|
784
|
+
getPropertyPriority(name: string): string;
|
|
785
|
+
item(index: number): string;
|
|
786
|
+
readonly cssText: string;
|
|
787
|
+
readonly length: number;
|
|
788
|
+
} & { readonly [property: string]: string };
|
|
789
|
+
|
|
511
790
|
/** What the window put on screen over a stretch of time; see `frameStats`. */
|
|
512
791
|
export interface FrameStats {
|
|
513
792
|
/** Frames presented. */
|
|
@@ -529,3 +808,99 @@ export interface FrameStats {
|
|
|
529
808
|
* `null` in a browser build.
|
|
530
809
|
*/
|
|
531
810
|
export function frameStats(): FrameStats | null;
|
|
811
|
+
|
|
812
|
+
export type ScrollBehavior = "auto" | "instant" | "smooth";
|
|
813
|
+
export type ScrollLogicalPosition = "start" | "center" | "end" | "nearest";
|
|
814
|
+
|
|
815
|
+
export interface ScrollToOptions {
|
|
816
|
+
left?: number;
|
|
817
|
+
top?: number;
|
|
818
|
+
/** `auto` follows the node's `scroll-behavior`. */
|
|
819
|
+
behavior?: ScrollBehavior;
|
|
820
|
+
}
|
|
821
|
+
|
|
822
|
+
export interface ScrollIntoViewOptions {
|
|
823
|
+
block?: ScrollLogicalPosition;
|
|
824
|
+
inline?: ScrollLogicalPosition;
|
|
825
|
+
behavior?: ScrollBehavior;
|
|
826
|
+
}
|
|
827
|
+
|
|
828
|
+
/** As `DOMRect` on the web. Also installed as `globalThis.DOMRect` when there is none. */
|
|
829
|
+
export class DOMRect {
|
|
830
|
+
constructor(x?: number, y?: number, width?: number, height?: number);
|
|
831
|
+
x: number;
|
|
832
|
+
y: number;
|
|
833
|
+
width: number;
|
|
834
|
+
height: number;
|
|
835
|
+
readonly left: number;
|
|
836
|
+
readonly top: number;
|
|
837
|
+
readonly right: number;
|
|
838
|
+
readonly bottom: number;
|
|
839
|
+
toJSON(): { x: number; y: number; width: number; height: number; top: number; right: number; bottom: number; left: number };
|
|
840
|
+
}
|
|
841
|
+
|
|
842
|
+
/** The topmost node at window point `x`, `y`. */
|
|
843
|
+
export function elementFromPoint(x: number, y: number): Node | null;
|
|
844
|
+
/** Every node at window point `x`, `y`, topmost first. */
|
|
845
|
+
export function elementsFromPoint(x: number, y: number): Node[];
|
|
846
|
+
/** The text position at window point `x`, `y`, the offset in UTF-16 units. */
|
|
847
|
+
export function caretPositionFromPoint(x: number, y: number): { offsetNode: Node | null; offset: number; getClientRect(): DOMRect } | null;
|
|
848
|
+
/** `Range.getClientRects` for the text from (`startNode`, `startOffset`) to (`endNode`, `endOffset`), offsets in UTF-16 units. */
|
|
849
|
+
export function rangeClientRects(startNode: Node, startOffset: number, endNode: Node, endOffset: number): DOMRect[];
|
|
850
|
+
/** `Range.getBoundingClientRect` for the same range. */
|
|
851
|
+
export function rangeBoundingClientRect(startNode: Node, startOffset: number, endNode: Node, endOffset: number): DOMRect;
|
|
852
|
+
|
|
853
|
+
type Observable = Node | { node: Node };
|
|
854
|
+
|
|
855
|
+
export interface IntersectionObserverInit {
|
|
856
|
+
/** A node, or null for the window. */
|
|
857
|
+
root?: Observable | null;
|
|
858
|
+
rootMargin?: string;
|
|
859
|
+
scrollMargin?: string;
|
|
860
|
+
threshold?: number | number[];
|
|
861
|
+
}
|
|
862
|
+
|
|
863
|
+
export class IntersectionObserverEntry {
|
|
864
|
+
readonly time: number;
|
|
865
|
+
readonly target: Observable;
|
|
866
|
+
readonly isIntersecting: boolean;
|
|
867
|
+
readonly isVisible: boolean;
|
|
868
|
+
readonly intersectionRatio: number;
|
|
869
|
+
readonly boundingClientRect: DOMRect;
|
|
870
|
+
readonly intersectionRect: DOMRect;
|
|
871
|
+
readonly rootBounds: DOMRect | null;
|
|
872
|
+
}
|
|
873
|
+
|
|
874
|
+
/** As on the web. Entries come after a layout or scroll in which a target crossed a threshold. Also installed as `globalThis.IntersectionObserver`. */
|
|
875
|
+
export class IntersectionObserver {
|
|
876
|
+
constructor(callback: (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => void, options?: IntersectionObserverInit);
|
|
877
|
+
readonly root: Observable | null;
|
|
878
|
+
readonly rootMargin: string;
|
|
879
|
+
readonly scrollMargin: string;
|
|
880
|
+
readonly thresholds: readonly number[];
|
|
881
|
+
observe(target: Observable): void;
|
|
882
|
+
unobserve(target: Observable): void;
|
|
883
|
+
disconnect(): void;
|
|
884
|
+
takeRecords(): IntersectionObserverEntry[];
|
|
885
|
+
}
|
|
886
|
+
|
|
887
|
+
export interface ResizeObserverSize {
|
|
888
|
+
readonly inlineSize: number;
|
|
889
|
+
readonly blockSize: number;
|
|
890
|
+
}
|
|
891
|
+
|
|
892
|
+
export class ResizeObserverEntry {
|
|
893
|
+
readonly target: Observable;
|
|
894
|
+
readonly contentRect: DOMRect;
|
|
895
|
+
readonly borderBoxSize: readonly ResizeObserverSize[];
|
|
896
|
+
readonly contentBoxSize: readonly ResizeObserverSize[];
|
|
897
|
+
readonly devicePixelContentBoxSize: readonly ResizeObserverSize[];
|
|
898
|
+
}
|
|
899
|
+
|
|
900
|
+
/** As on the web. Entries come after a layout that changed an observed box. Also installed as `globalThis.ResizeObserver`. */
|
|
901
|
+
export class ResizeObserver {
|
|
902
|
+
constructor(callback: (entries: ResizeObserverEntry[], observer: ResizeObserver) => void);
|
|
903
|
+
observe(target: Observable, options?: { box?: "content-box" | "border-box" | "device-pixel-content-box" }): void;
|
|
904
|
+
unobserve(target: Observable): void;
|
|
905
|
+
disconnect(): void;
|
|
906
|
+
}
|