|
1 | 1 | import EventEmitter from "node:events"; |
2 | 2 |
|
| 3 | +type GetDOMRect = (element: HTMLElement) => DOMRectReadOnly | undefined | void; |
| 4 | + |
3 | 5 | const emitter = new EventEmitter(); |
4 | | -emitter.setMaxListeners(25); |
| 6 | +emitter.setMaxListeners(100); |
| 7 | + |
| 8 | +const elementToDOMRect = new Map<HTMLElement, DOMRect>(); |
5 | 9 |
|
| 10 | +let defaultDomRect: DOMRectReadOnly = new DOMRect(0, 0, 0, 0); |
6 | 11 | let disabled: boolean = false; |
7 | | -let entrySize: DOMRectReadOnly = new DOMRect(0, 0, 0, 0); |
| 12 | +let getDOMRect: GetDOMRect | undefined = undefined; |
8 | 13 |
|
9 | 14 | export function disableResizeObserverForCurrentTest() { |
10 | 15 | disabled = true; |
11 | 16 | } |
12 | 17 |
|
13 | | -export function simulateUnsupportedEnvironmentForTest() { |
14 | | - // @ts-expect-error Simulate API being unsupported |
15 | | - window.ResizeObserver = null; |
| 18 | +export function setDefaultElementSize({ |
| 19 | + height, |
| 20 | + width |
| 21 | +}: { |
| 22 | + height: number; |
| 23 | + width: number; |
| 24 | +}) { |
| 25 | + defaultDomRect = new DOMRect(0, 0, width, height); |
| 26 | + |
| 27 | + emitter.emit("change"); |
| 28 | +} |
| 29 | + |
| 30 | +export function setElementSizeFunction(value: GetDOMRect) { |
| 31 | + getDOMRect = value; |
| 32 | + |
| 33 | + emitter.emit("change"); |
16 | 34 | } |
17 | 35 |
|
18 | | -export function updateMockResizeObserver({ |
| 36 | +export function setElementSize({ |
| 37 | + element, |
19 | 38 | height, |
20 | | - target, |
21 | 39 | width |
22 | 40 | }: { |
23 | | - height?: number; |
24 | | - target?: HTMLElement; |
25 | | - width?: number; |
26 | | -}): void { |
27 | | - entrySize = new DOMRect( |
28 | | - 0, |
29 | | - 0, |
30 | | - width ?? entrySize.width, |
31 | | - height ?? entrySize.height |
32 | | - ); |
33 | | - |
34 | | - emitter.emit("change", target); |
| 41 | + element: HTMLElement; |
| 42 | + height: number; |
| 43 | + width: number; |
| 44 | +}) { |
| 45 | + elementToDOMRect.set(element, new DOMRect(0, 0, width, height)); |
| 46 | + |
| 47 | + emitter.emit("change", element); |
| 48 | +} |
| 49 | + |
| 50 | +export function simulateUnsupportedEnvironmentForTest() { |
| 51 | + // @ts-expect-error Simulate API being unsupported |
| 52 | + window.ResizeObserver = null; |
35 | 53 | } |
36 | 54 |
|
37 | 55 | export function mockResizeObserver() { |
38 | 56 | disabled = false; |
39 | 57 |
|
40 | 58 | const originalResizeObserver = window.ResizeObserver; |
41 | 59 |
|
42 | | - window.ResizeObserver = class implements ResizeObserver { |
43 | | - readonly #callback: ResizeObserverCallback; |
44 | | - #disconnected: boolean = false; |
45 | | - #elements: Set<HTMLElement> = new Set(); |
| 60 | + window.ResizeObserver = MockResizeObserver; |
46 | 61 |
|
47 | | - constructor(callback: ResizeObserverCallback) { |
48 | | - this.#callback = callback; |
| 62 | + return function unmockResizeObserver() { |
| 63 | + window.ResizeObserver = originalResizeObserver; |
49 | 64 |
|
50 | | - emitter.addListener("change", this.#onChange); |
51 | | - } |
| 65 | + defaultDomRect = new DOMRect(0, 0, 0, 0); |
| 66 | + disabled = false; |
| 67 | + getDOMRect = undefined; |
52 | 68 |
|
53 | | - observe(element: HTMLElement) { |
54 | | - if (this.#disconnected) { |
55 | | - return; |
56 | | - } |
| 69 | + elementToDOMRect.clear(); |
| 70 | + }; |
| 71 | +} |
57 | 72 |
|
58 | | - this.#elements.add(element); |
59 | | - this.#notify(element); |
60 | | - } |
| 73 | +class MockResizeObserver implements ResizeObserver { |
| 74 | + readonly #callback: ResizeObserverCallback; |
| 75 | + #disconnected: boolean = false; |
| 76 | + #elements: Set<HTMLElement> = new Set(); |
61 | 77 |
|
62 | | - unobserve(element: HTMLElement) { |
63 | | - this.#elements.delete(element); |
| 78 | + constructor(callback: ResizeObserverCallback) { |
| 79 | + this.#callback = callback; |
| 80 | + |
| 81 | + emitter.addListener("change", this.#onChange); |
| 82 | + } |
| 83 | + |
| 84 | + observe(element: HTMLElement) { |
| 85 | + if (this.#disconnected) { |
| 86 | + return; |
64 | 87 | } |
65 | 88 |
|
66 | | - disconnect() { |
67 | | - this.#disconnected = true; |
68 | | - this.#elements.clear(); |
| 89 | + this.#elements.add(element); |
| 90 | + this.#notify([element]); |
| 91 | + } |
| 92 | + |
| 93 | + unobserve(element: HTMLElement) { |
| 94 | + this.#elements.delete(element); |
| 95 | + } |
69 | 96 |
|
70 | | - emitter.removeListener("change", this.#onChange); |
| 97 | + disconnect() { |
| 98 | + this.#disconnected = true; |
| 99 | + this.#elements.clear(); |
| 100 | + |
| 101 | + emitter.removeListener("change", this.#onChange); |
| 102 | + } |
| 103 | + |
| 104 | + #notify(elements: HTMLElement[]) { |
| 105 | + if (disabled) { |
| 106 | + return; |
71 | 107 | } |
72 | 108 |
|
73 | | - #notify(target: HTMLElement) { |
74 | | - if (disabled) { |
75 | | - return; |
| 109 | + const entries = elements.map((element) => { |
| 110 | + const computedStyle = window.getComputedStyle(element); |
| 111 | + const writingMode = computedStyle.writingMode; |
| 112 | + |
| 113 | + let contentRect: DOMRectReadOnly = |
| 114 | + elementToDOMRect.get(element) ?? defaultDomRect; |
| 115 | + |
| 116 | + if (getDOMRect) { |
| 117 | + const contentRectOverride = getDOMRect(element); |
| 118 | + if (contentRectOverride) { |
| 119 | + contentRect = contentRectOverride; |
| 120 | + } |
76 | 121 | } |
77 | 122 |
|
78 | | - this.#callback( |
79 | | - [ |
| 123 | + let blockSize = 0; |
| 124 | + let inlineSize = 0; |
| 125 | + if (writingMode.includes("vertical")) { |
| 126 | + blockSize = contentRect.width; |
| 127 | + inlineSize = contentRect.height; |
| 128 | + } else { |
| 129 | + blockSize = contentRect.height; |
| 130 | + inlineSize = contentRect.width; |
| 131 | + } |
| 132 | + |
| 133 | + return { |
| 134 | + borderBoxSize: [ |
80 | 135 | { |
81 | | - borderBoxSize: [], |
82 | | - contentBoxSize: [], |
83 | | - contentRect: entrySize, |
84 | | - devicePixelContentBoxSize: [], |
85 | | - target |
| 136 | + blockSize, |
| 137 | + inlineSize |
86 | 138 | } |
87 | 139 | ], |
88 | | - this |
89 | | - ); |
90 | | - } |
91 | | - |
92 | | - #onChange = (target?: HTMLElement) => { |
93 | | - if (target) { |
94 | | - this.#notify(target); |
95 | | - } else { |
96 | | - this.#elements.forEach((element) => this.#notify(element)); |
| 140 | + contentBoxSize: [], |
| 141 | + contentRect, |
| 142 | + devicePixelContentBoxSize: [], |
| 143 | + target: element |
| 144 | + }; |
| 145 | + }); |
| 146 | + |
| 147 | + this.#callback(entries, this); |
| 148 | + } |
| 149 | + |
| 150 | + #onChange = (target?: HTMLElement) => { |
| 151 | + if (target) { |
| 152 | + if (this.#elements.has(target)) { |
| 153 | + this.#notify([target]); |
97 | 154 | } |
98 | | - }; |
99 | | - }; |
100 | | - |
101 | | - return function unmockResizeObserver() { |
102 | | - window.ResizeObserver = originalResizeObserver; |
| 155 | + } else { |
| 156 | + this.#notify(Array.from(this.#elements)); |
| 157 | + } |
103 | 158 | }; |
104 | 159 | } |
0 commit comments