@astral/mobx-query 1.15.0 → 1.16.0

package/node/PollingService/PollingService.d.ts

@@ -0,0 +1,34 @@
+import { type AdaptableMap } from '../AdaptableMap';
+import { type KeyHash, type UnknownCachedQuery } from '../MobxQuery/types';
+/**
+ * Сущность для инкапсулирования логики работы с устареванием данных
+ */
+export declare class PollingService {
+    private readonly _queryStorage;
+    private readonly _invalidateByKeyHash;
+    private readonly _document;
+    private timers;
+    private timerDates;
+    private isVisible;
+    constructor(_queryStorage: AdaptableMap<UnknownCachedQuery>, _invalidateByKeyHash: (keyHash: KeyHash) => void, _document?: Document);
+    private updateIsVisible;
+    private init;
+    private handleVisibilityChange;
+    private restartPausedTimers;
+    private pauseTimers;
+    /**
+     * Очистка таймеров,
+     * предполагается использование либо при срабатывании таймера,
+     * либо при досрочном вызове из внешней инвалидации
+     */
+    clean: (key: KeyHash) => void;
+    /**
+     * Перезапуск имеющегося таймера, предполагается использование при срабатывании синхронизации между вкладками
+     */
+    restart: (key: KeyHash) => void;
+    private invalidate;
+    /**
+     * Установка таймера устаревания данных
+     */
+    setupTimer: (key: KeyHash, pollingTime: number) => void;
+}

package/node/PollingService/PollingService.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingService = void 0;
+/**
+ * Сущность для инкапсулирования логики работы с устареванием данных
+ */
+class PollingService {
+    constructor(_queryStorage, _invalidateByKeyHash, _document = globalThis.document) {
+        this._queryStorage = _queryStorage;
+        this._invalidateByKeyHash = _invalidateByKeyHash;
+        this._document = _document;
+        this.timers = new Map();
+        this.timerDates = new Map();
+        this.isVisible = true;
+        this.updateIsVisible = () => {
+            var _a;
+            this.isVisible = ((_a = this._document) === null || _a === void 0 ? void 0 : _a.visibilityState) === 'visible';
+        };
+        this.init = () => {
+            var _a;
+            this.updateIsVisible();
+            (_a = this._document) === null || _a === void 0 ? void 0 : _a.addEventListener('visibilitychange', this.handleVisibilityChange);
+        };
+        this.handleVisibilityChange = () => {
+            this.updateIsVisible();
+            if (this.isVisible) {
+                this.restartPausedTimers();
+            }
+            else {
+                this.pauseTimers();
+            }
+        };
+        this.restartPausedTimers = () => {
+            this.timerDates.keys().forEach((key) => {
+                const dateNow = Date.now();
+                const { pollingTime, targetDate } = this.timerDates.get(key);
+                const isAlreadyExpired = targetDate < dateNow;
+                if (isAlreadyExpired) {
+                    this.invalidate(key);
+                }
+                else {
+                    this.setupTimer(key, pollingTime);
+                }
+            });
+        };
+        this.pauseTimers = () => {
+            this.timers.keys().forEach((key) => {
+                globalThis.clearTimeout(this.timers.get(key));
+                this.timers.delete(key);
+            });
+        };
+        /**
+         * Очистка таймеров,
+         * предполагается использование либо при срабатывании таймера,
+         * либо при досрочном вызове из внешней инвалидации
+         */
+        this.clean = (key) => {
+            globalThis.clearTimeout(this.timers.get(key));
+            this.timers.delete(key);
+            this.timerDates.delete(key);
+        };
+        /**
+         * Перезапуск имеющегося таймера, предполагается использование при срабатывании синхронизации между вкладками
+         */
+        this.restart = (key) => {
+            const saved = this.timerDates.get(key);
+            if (saved) {
+                this.setupTimer(key, saved.pollingTime);
+            }
+        };
+        this.invalidate = (key) => {
+            const query = this._queryStorage.get(key);
+            if (query) {
+                this._invalidateByKeyHash(key);
+            }
+            this.clean(key);
+        };
+        /**
+         * Установка таймера устаревания данных
+         */
+        this.setupTimer = (key, pollingTime) => {
+            if (this.timers.has(key)) {
+                globalThis.clearTimeout(this.timers.get(key));
+            }
+            if (!this._queryStorage.get(key)) {
+                return;
+            }
+            this.timerDates.set(key, {
+                pollingTime,
+                targetDate: Date.now() + pollingTime,
+            });
+            if (this.isVisible) {
+                this.timers.set(key, globalThis.setTimeout(() => this.invalidate(key), pollingTime));
+            }
+        };
+        this.init();
+    }
+}
+exports.PollingService = PollingService;

package/node/PollingService/index.d.ts

@@ -0,0 +1 @@
+export * from './PollingService';

package/node/PollingService/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PollingService"), exports);

package/node/SynchronizationService/SynchronizationService.d.ts

@@ -1,16 +1,16 @@
 import { type DataStorageFactory } from '../DataStorage';
+import { type Keys } from '../MobxQuery/types';
+import { type PollingService } from '../PollingService';
 import { type StatusStorageFactory } from '../StatusStorage';
 export declare class SynchronizationService {
     private readonly _statusStorageFactory;
     private readonly _dataStorageFactory;
+    private readonly _pollingService;
     private readonly broadcastChannel?;
-    constructor(_statusStorageFactory: StatusStorageFactory, _dataStorageFactory: DataStorageFactory, _BroadcastChannel?: {
+    constructor(_statusStorageFactory: StatusStorageFactory, _dataStorageFactory: DataStorageFactory, _pollingService: PollingService, _BroadcastChannel?: {
         new (name: string): BroadcastChannel;
         prototype: BroadcastChannel;
     });
     private init;
-    emit: (keys: {
-        dataKeyHash: string;
-        statusKeyHash: string;
-    }) => void;
+    emit: (keys: Keys) => void;
 }

package/node/SynchronizationService/SynchronizationService.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SynchronizationService = void 0;
 class SynchronizationService {
-    constructor(_statusStorageFactory, _dataStorageFactory, _BroadcastChannel = globalThis.BroadcastChannel) {
+    constructor(_statusStorageFactory, _dataStorageFactory, _pollingService, _BroadcastChannel = globalThis.BroadcastChannel) {
         this._statusStorageFactory = _statusStorageFactory;
         this._dataStorageFactory = _dataStorageFactory;
+        this._pollingService = _pollingService;
         this.init = () => {
             var _a;
             (_a = this.broadcastChannel) === null || _a === void 0 ? void 0 : _a.addEventListener('message', (event) => {
@@ -13,16 +14,12 @@ class SynchronizationService {
                     .getStorage(event.data.dataKeyHash)) === null || _a === void 0 ? void 0 : _a.setData(event.data.data);
                 (_b = this._statusStorageFactory
                     .getStorage(event.data.statusKeyHash)) === null || _b === void 0 ? void 0 : _b.setStatues(event.data.statuses);
+                this._pollingService.restart(event.data.queryKeyHash);
             });
         };
         this.emit = (keys) => {
             var _a, _b, _c;
-            (_a = this.broadcastChannel) === null || _a === void 0 ? void 0 : _a.postMessage({
-                dataKeyHash: keys.dataKeyHash,
-                statusKeyHash: keys.statusKeyHash,
-                data: (_b = this._dataStorageFactory.getStorage(keys.dataKeyHash)) === null || _b === void 0 ? void 0 : _b.data,
-                statuses: (_c = this._statusStorageFactory.getStorage(keys.statusKeyHash)) === null || _c === void 0 ? void 0 : _c.statuses,
-            });
+            (_a = this.broadcastChannel) === null || _a === void 0 ? void 0 : _a.postMessage(Object.assign(Object.assign({}, keys), { data: (_b = this._dataStorageFactory.getStorage(keys.dataKeyHash)) === null || _b === void 0 ? void 0 : _b.data, statuses: (_c = this._statusStorageFactory.getStorage(keys.statusKeyHash)) === null || _c === void 0 ? void 0 : _c.statuses }));
         };
         if (_BroadcastChannel) {
             this.broadcastChannel = new _BroadcastChannel('@astral/mobx-query');

package/node/__test/BroadcastChannel/BroadcastChannel.d.ts

@@ -0,0 +1 @@
+export declare const createBroadcastChannelMock: () => typeof globalThis.BroadcastChannel;

package/node/__test/BroadcastChannel/BroadcastChannel.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBroadcastChannelMock = void 0;
+// Мок не предусматривает полного повторения функционала оригинального BroadcastChannelMock
+// поэтому он будет вызывать даже подписчиков вкладки инициатора,
+// но благодаря общему подходу, ожидается, что это не вызовет проблем
+const createBroadcastChannelMock = () => {
+    const listeners = [];
+    class BroadcastChannelMock {
+        constructor() {
+            this.addEventListener = (_, listener) => listeners.push(listener);
+            this.postMessage = (data) => listeners.forEach((listener) => listener({ data }));
+        }
+    }
+    return BroadcastChannelMock;
+};
+exports.createBroadcastChannelMock = createBroadcastChannelMock;

package/node/__test/BroadcastChannel/index.d.ts

@@ -0,0 +1 @@
+export * from './BroadcastChannel';

package/node/__test/BroadcastChannel/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BroadcastChannel"), exports);

package/node/__test/documentMock/documentMock.d.ts

@@ -0,0 +1,380 @@
+export declare const createDocumentMock: () => {
+    documentMock: {
+        readonly URL: string;
+        alinkColor: string;
+        readonly all: HTMLAllCollection;
+        readonly anchors: HTMLCollectionOf<HTMLAnchorElement>;
+        readonly applets: HTMLCollection;
+        bgColor: string;
+        body: HTMLElement;
+        readonly characterSet: string;
+        readonly charset: string;
+        readonly compatMode: string;
+        readonly contentType: string;
+        cookie: string;
+        readonly currentScript: HTMLOrSVGScriptElement | null;
+        readonly defaultView: (WindowProxy & typeof globalThis) | null;
+        designMode: string;
+        dir: string;
+        readonly doctype: DocumentType | null;
+        readonly documentElement: HTMLElement;
+        readonly documentURI: string;
+        domain: string;
+        readonly embeds: HTMLCollectionOf<HTMLEmbedElement>;
+        fgColor: string;
+        readonly forms: HTMLCollectionOf<HTMLFormElement>;
+        readonly fragmentDirective: FragmentDirective;
+        readonly fullscreen: boolean;
+        readonly fullscreenEnabled: boolean;
+        readonly head: HTMLHeadElement;
+        readonly hidden: boolean;
+        readonly images: HTMLCollectionOf<HTMLImageElement>;
+        readonly implementation: DOMImplementation;
+        readonly inputEncoding: string;
+        readonly lastModified: string;
+        linkColor: string;
+        readonly links: HTMLCollectionOf<HTMLAnchorElement | HTMLAreaElement>;
+        location: Location;
+        onfullscreenchange: ((this: Document, ev: Event) => any) | null;
+        onfullscreenerror: ((this: Document, ev: Event) => any) | null;
+        onpointerlockchange: ((this: Document, ev: Event) => any) | null;
+        onpointerlockerror: ((this: Document, ev: Event) => any) | null;
+        onreadystatechange: ((this: Document, ev: Event) => any) | null;
+        onvisibilitychange: ((this: Document, ev: Event) => any) | null;
+        readonly ownerDocument: null;
+        readonly pictureInPictureEnabled: boolean;
+        readonly plugins: HTMLCollectionOf<HTMLEmbedElement>;
+        readonly readyState: DocumentReadyState;
+        readonly referrer: string;
+        readonly rootElement: SVGSVGElement | null;
+        readonly scripts: HTMLCollectionOf<HTMLScriptElement>;
+        readonly scrollingElement: Element | null;
+        readonly timeline: DocumentTimeline;
+        title: string;
+        readonly visibilityState: DocumentVisibilityState;
+        vlinkColor: string;
+        adoptNode: (<T extends Node>(node: T) => T) & import("vitest-mock-extended").CalledWithMock<Node, [node: Node]>;
+        captureEvents: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        caretPositionFromPoint: ((x: number, y: number, options?: CaretPositionFromPointOptions) => CaretPosition | null) & import("vitest-mock-extended").CalledWithMock<CaretPosition | null, [x: number, y: number, options?: CaretPositionFromPointOptions | undefined]>;
+        caretRangeFromPoint: ((x: number, y: number) => Range | null) & import("vitest-mock-extended").CalledWithMock<Range | null, [x: number, y: number]>;
+        clear: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        close: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        createAttribute: ((localName: string) => Attr) & import("vitest-mock-extended").CalledWithMock<Attr, [localName: string]>;
+        createAttributeNS: ((namespace: string | null, qualifiedName: string) => Attr) & import("vitest-mock-extended").CalledWithMock<Attr, [namespace: string | null, qualifiedName: string]>;
+        createCDATASection: ((data: string) => CDATASection) & import("vitest-mock-extended").CalledWithMock<CDATASection, [data: string]>;
+        createComment: ((data: string) => Comment) & import("vitest-mock-extended").CalledWithMock<Comment, [data: string]>;
+        createDocumentFragment: (() => DocumentFragment) & import("vitest-mock-extended").CalledWithMock<DocumentFragment, []>;
+        createElement: {
+            <K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
+            <K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
+            (tagName: string, options?: ElementCreationOptions): HTMLElement;
+        } & import("vitest-mock-extended").CalledWithMock<HTMLElement, [tagName: string, options?: ElementCreationOptions | undefined]>;
+        createElementNS: {
+            (namespaceURI: "http://www.w3.org/1999/xhtml", qualifiedName: string): HTMLElement;
+            <K extends keyof SVGElementTagNameMap>(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: K): SVGElementTagNameMap[K];
+            (namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: string): SVGElement;
+            <K extends keyof MathMLElementTagNameMap>(namespaceURI: "http://www.w3.org/1998/Math/MathML", qualifiedName: K): MathMLElementTagNameMap[K];
+            (namespaceURI: "http://www.w3.org/1998/Math/MathML", qualifiedName: string): MathMLElement;
+            (namespaceURI: string | null, qualifiedName: string, options?: ElementCreationOptions): Element;
+            (namespace: string | null, qualifiedName: string, options?: string | ElementCreationOptions): Element;
+        } & import("vitest-mock-extended").CalledWithMock<Element, [namespace: string | null, qualifiedName: string, options?: string | ElementCreationOptions | undefined]>;
+        createEvent: {
+            (eventInterface: "AnimationEvent"): AnimationEvent;
+            (eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
+            (eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
+            (eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
+            (eventInterface: "BlobEvent"): BlobEvent;
+            (eventInterface: "ClipboardEvent"): ClipboardEvent;
+            (eventInterface: "CloseEvent"): CloseEvent;
+            (eventInterface: "CompositionEvent"): CompositionEvent;
+            (eventInterface: "ContentVisibilityAutoStateChangeEvent"): ContentVisibilityAutoStateChangeEvent;
+            (eventInterface: "CustomEvent"): CustomEvent;
+            (eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
+            (eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
+            (eventInterface: "DragEvent"): DragEvent;
+            (eventInterface: "ErrorEvent"): ErrorEvent;
+            (eventInterface: "Event"): Event;
+            (eventInterface: "Events"): Event;
+            (eventInterface: "FocusEvent"): FocusEvent;
+            (eventInterface: "FontFaceSetLoadEvent"): FontFaceSetLoadEvent;
+            (eventInterface: "FormDataEvent"): FormDataEvent;
+            (eventInterface: "GamepadEvent"): GamepadEvent;
+            (eventInterface: "HashChangeEvent"): HashChangeEvent;
+            (eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
+            (eventInterface: "InputEvent"): InputEvent;
+            (eventInterface: "KeyboardEvent"): KeyboardEvent;
+            (eventInterface: "MIDIConnectionEvent"): MIDIConnectionEvent;
+            (eventInterface: "MIDIMessageEvent"): MIDIMessageEvent;
+            (eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
+            (eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
+            (eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
+            (eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
+            (eventInterface: "MessageEvent"): MessageEvent;
+            (eventInterface: "MouseEvent"): MouseEvent;
+            (eventInterface: "MouseEvents"): MouseEvent;
+            (eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
+            (eventInterface: "PageRevealEvent"): PageRevealEvent;
+            (eventInterface: "PageSwapEvent"): PageSwapEvent;
+            (eventInterface: "PageTransitionEvent"): PageTransitionEvent;
+            (eventInterface: "PaymentMethodChangeEvent"): PaymentMethodChangeEvent;
+            (eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
+            (eventInterface: "PictureInPictureEvent"): PictureInPictureEvent;
+            (eventInterface: "PointerEvent"): PointerEvent;
+            (eventInterface: "PopStateEvent"): PopStateEvent;
+            (eventInterface: "ProgressEvent"): ProgressEvent;
+            (eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
+            (eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
+            (eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
+            (eventInterface: "RTCErrorEvent"): RTCErrorEvent;
+            (eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
+            (eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
+            (eventInterface: "RTCTrackEvent"): RTCTrackEvent;
+            (eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
+            (eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
+            (eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
+            (eventInterface: "StorageEvent"): StorageEvent;
+            (eventInterface: "SubmitEvent"): SubmitEvent;
+            (eventInterface: "TextEvent"): TextEvent;
+            (eventInterface: "ToggleEvent"): ToggleEvent;
+            (eventInterface: "TouchEvent"): TouchEvent;
+            (eventInterface: "TrackEvent"): TrackEvent;
+            (eventInterface: "TransitionEvent"): TransitionEvent;
+            (eventInterface: "UIEvent"): UIEvent;
+            (eventInterface: "UIEvents"): UIEvent;
+            (eventInterface: "WebGLContextEvent"): WebGLContextEvent;
+            (eventInterface: "WheelEvent"): WheelEvent;
+            (eventInterface: string): Event;
+        } & import("vitest-mock-extended").CalledWithMock<Event, [eventInterface: string]>;
+        createNodeIterator: ((root: Node, whatToShow?: number, filter?: NodeFilter | null) => NodeIterator) & import("vitest-mock-extended").CalledWithMock<NodeIterator, [root: Node, whatToShow?: number | undefined, filter?: NodeFilter | null | undefined]>;
+        createProcessingInstruction: ((target: string, data: string) => ProcessingInstruction) & import("vitest-mock-extended").CalledWithMock<ProcessingInstruction, [target: string, data: string]>;
+        createRange: (() => Range) & import("vitest-mock-extended").CalledWithMock<Range, []>;
+        createTextNode: ((data: string) => Text) & import("vitest-mock-extended").CalledWithMock<Text, [data: string]>;
+        createTreeWalker: ((root: Node, whatToShow?: number, filter?: NodeFilter | null) => TreeWalker) & import("vitest-mock-extended").CalledWithMock<TreeWalker, [root: Node, whatToShow?: number | undefined, filter?: NodeFilter | null | undefined]>;
+        execCommand: ((commandId: string, showUI?: boolean, value?: string) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [commandId: string, showUI?: boolean | undefined, value?: string | undefined]>;
+        exitFullscreen: (() => Promise<void>) & import("vitest-mock-extended").CalledWithMock<Promise<void>, []>;
+        exitPictureInPicture: (() => Promise<void>) & import("vitest-mock-extended").CalledWithMock<Promise<void>, []>;
+        exitPointerLock: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        getElementById: ((elementId: string) => HTMLElement | null) & import("vitest-mock-extended").CalledWithMock<HTMLElement | null, [elementId: string]>;
+        getElementsByClassName: ((classNames: string) => HTMLCollectionOf<Element>) & import("vitest-mock-extended").CalledWithMock<HTMLCollectionOf<Element>, [classNames: string]>;
+        getElementsByName: ((elementName: string) => NodeListOf<HTMLElement>) & import("vitest-mock-extended").CalledWithMock<NodeListOf<HTMLElement>, [elementName: string]>;
+        getElementsByTagName: {
+            <K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
+            <K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
+            <K extends keyof MathMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<MathMLElementTagNameMap[K]>;
+            <K extends keyof HTMLElementDeprecatedTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementDeprecatedTagNameMap[K]>;
+            (qualifiedName: string): HTMLCollectionOf<Element>;
+        } & import("vitest-mock-extended").CalledWithMock<HTMLCollectionOf<Element>, [qualifiedName: string]>;
+        getElementsByTagNameNS: {
+            (namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+            (namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
+            (namespaceURI: "http://www.w3.org/1998/Math/MathML", localName: string): HTMLCollectionOf<MathMLElement>;
+            (namespace: string | null, localName: string): HTMLCollectionOf<Element>;
+        } & import("vitest-mock-extended").CalledWithMock<HTMLCollectionOf<Element>, [namespace: string | null, localName: string]>;
+        getSelection: (() => Selection | null) & import("vitest-mock-extended").CalledWithMock<Selection | null, []>;
+        hasFocus: (() => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, []>;
+        hasStorageAccess: (() => Promise<boolean>) & import("vitest-mock-extended").CalledWithMock<Promise<boolean>, []>;
+        importNode: (<T extends Node>(node: T, subtree?: boolean) => T) & import("vitest-mock-extended").CalledWithMock<Node, [node: Node, subtree?: boolean | undefined]>;
+        open: {
+            (unused1?: string, unused2?: string): Document;
+            (url: string | URL, name: string, features: string): WindowProxy | null;
+        } & import("vitest-mock-extended").CalledWithMock<Window | null, [url: string | URL, name: string, features: string]>;
+        queryCommandEnabled: ((commandId: string) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [commandId: string]>;
+        queryCommandIndeterm: ((commandId: string) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [commandId: string]>;
+        queryCommandState: ((commandId: string) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [commandId: string]>;
+        queryCommandSupported: ((commandId: string) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [commandId: string]>;
+        queryCommandValue: ((commandId: string) => string) & import("vitest-mock-extended").CalledWithMock<string, [commandId: string]>;
+        releaseEvents: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        requestStorageAccess: (() => Promise<void>) & import("vitest-mock-extended").CalledWithMock<Promise<void>, []>;
+        startViewTransition: ((callbackOptions?: ViewTransitionUpdateCallback) => ViewTransition) & import("vitest-mock-extended").CalledWithMock<ViewTransition, [callbackOptions?: ViewTransitionUpdateCallback | undefined]>;
+        write: ((...text: string[]) => void) & import("vitest-mock-extended").CalledWithMock<void, string[]>;
+        writeln: ((...text: string[]) => void) & import("vitest-mock-extended").CalledWithMock<void, string[]>;
+        addEventListener: {
+            <K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        } & import("vitest-mock-extended").CalledWithMock<void, [type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined]>;
+        removeEventListener: {
+            <K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        } & import("vitest-mock-extended").CalledWithMock<void, [type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined]>;
+        readonly baseURI: string;
+        readonly childNodes: NodeListOf<ChildNode>;
+        readonly firstChild: ChildNode | null;
+        readonly isConnected: boolean;
+        readonly lastChild: ChildNode | null;
+        readonly nextSibling: ChildNode | null;
+        readonly nodeName: string;
+        readonly nodeType: number;
+        nodeValue: string | null;
+        readonly parentElement: HTMLElement | null;
+        readonly parentNode: ParentNode | null;
+        readonly previousSibling: ChildNode | null;
+        textContent: string | null;
+        appendChild: (<T extends Node>(node: T) => T) & import("vitest-mock-extended").CalledWithMock<Node, [node: Node]>;
+        cloneNode: ((subtree?: boolean) => Node) & import("vitest-mock-extended").CalledWithMock<Node, [subtree?: boolean | undefined]>;
+        compareDocumentPosition: ((other: Node) => number) & import("vitest-mock-extended").CalledWithMock<number, [other: Node]>;
+        contains: ((other: Node | null) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [other: Node | null]>;
+        getRootNode: ((options?: GetRootNodeOptions) => Node) & import("vitest-mock-extended").CalledWithMock<Node, [options?: GetRootNodeOptions | undefined]>;
+        hasChildNodes: (() => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, []>;
+        insertBefore: (<T extends Node>(node: T, child: Node | null) => T) & import("vitest-mock-extended").CalledWithMock<Node, [node: Node, child: Node | null]>;
+        isDefaultNamespace: ((namespace: string | null) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [namespace: string | null]>;
+        isEqualNode: ((otherNode: Node | null) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [otherNode: Node | null]>;
+        isSameNode: ((otherNode: Node | null) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [otherNode: Node | null]>;
+        lookupNamespaceURI: ((prefix: string | null) => string | null) & import("vitest-mock-extended").CalledWithMock<string | null, [prefix: string | null]>;
+        lookupPrefix: ((namespace: string | null) => string | null) & import("vitest-mock-extended").CalledWithMock<string | null, [namespace: string | null]>;
+        normalize: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        removeChild: (<T extends Node>(child: T) => T) & import("vitest-mock-extended").CalledWithMock<Node, [child: Node]>;
+        replaceChild: (<T extends Node>(node: Node, child: T) => T) & import("vitest-mock-extended").CalledWithMock<Node, [node: Node, child: Node]>;
+        readonly ELEMENT_NODE: 1;
+        readonly ATTRIBUTE_NODE: 2;
+        readonly TEXT_NODE: 3;
+        readonly CDATA_SECTION_NODE: 4;
+        readonly ENTITY_REFERENCE_NODE: 5;
+        readonly ENTITY_NODE: 6;
+        readonly PROCESSING_INSTRUCTION_NODE: 7;
+        readonly COMMENT_NODE: 8;
+        readonly DOCUMENT_NODE: 9;
+        readonly DOCUMENT_TYPE_NODE: 10;
+        readonly DOCUMENT_FRAGMENT_NODE: 11;
+        readonly NOTATION_NODE: 12;
+        readonly DOCUMENT_POSITION_DISCONNECTED: 1;
+        readonly DOCUMENT_POSITION_PRECEDING: 2;
+        readonly DOCUMENT_POSITION_FOLLOWING: 4;
+        readonly DOCUMENT_POSITION_CONTAINS: 8;
+        readonly DOCUMENT_POSITION_CONTAINED_BY: 16;
+        readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32;
+        dispatchEvent: ((event: Event) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [event: Event]>;
+        readonly activeElement: Element | null;
+        adoptedStyleSheets: CSSStyleSheet[];
+        readonly fullscreenElement: Element | null;
+        readonly pictureInPictureElement: Element | null;
+        readonly pointerLockElement: Element | null;
+        readonly styleSheets: StyleSheetList;
+        elementFromPoint: ((x: number, y: number) => Element | null) & import("vitest-mock-extended").CalledWithMock<Element | null, [x: number, y: number]>;
+        elementsFromPoint: ((x: number, y: number) => Element[]) & import("vitest-mock-extended").CalledWithMock<Element[], [x: number, y: number]>;
+        getAnimations: (() => Animation[]) & import("vitest-mock-extended").CalledWithMock<Animation[], []>;
+        readonly fonts: FontFaceSet;
+        onabort: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+        onanimationcancel: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onanimationend: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onauxclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onbeforeinput: ((this: GlobalEventHandlers, ev: InputEvent) => any) | null;
+        onbeforetoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+        oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncontextlost: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncontextmenu: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        oncontextrestored: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncopy: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+        oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncut: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+        ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onerror: OnErrorEventHandler;
+        onfocus: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+        onformdata: ((this: GlobalEventHandlers, ev: FormDataEvent) => any) | null;
+        ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        oninput: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+        onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+        onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+        onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onpaste: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+        onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
+        onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+        onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onscrollend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
+        onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onslotchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onsubmit: ((this: GlobalEventHandlers, ev: SubmitEvent) => any) | null;
+        onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        ontoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+        ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+        ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+        ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+        ontransitioncancel: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        ontransitionend: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        ontransitionrun: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        ontransitionstart: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkitanimationend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkitanimationiteration: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkitanimationstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkittransitionend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwheel: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
+        readonly childElementCount: number;
+        readonly children: HTMLCollection;
+        readonly firstElementChild: Element | null;
+        readonly lastElementChild: Element | null;
+        append: ((...nodes: (Node | string)[]) => void) & import("vitest-mock-extended").CalledWithMock<void, (string | Node)[]>;
+        prepend: ((...nodes: (Node | string)[]) => void) & import("vitest-mock-extended").CalledWithMock<void, (string | Node)[]>;
+        querySelector: {
+            <K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
+            <K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
+            <K extends keyof MathMLElementTagNameMap>(selectors: K): MathMLElementTagNameMap[K] | null;
+            <K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): HTMLElementDeprecatedTagNameMap[K] | null;
+            <E extends Element = Element>(selectors: string): E | null;
+        } & import("vitest-mock-extended").CalledWithMock<Element | null, [selectors: string]>;
+        querySelectorAll: {
+            <K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
+            <K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
+            <K extends keyof MathMLElementTagNameMap>(selectors: K): NodeListOf<MathMLElementTagNameMap[K]>;
+            <K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): NodeListOf<HTMLElementDeprecatedTagNameMap[K]>;
+            <E extends Element = Element>(selectors: string): NodeListOf<E>;
+        } & import("vitest-mock-extended").CalledWithMock<NodeListOf<Element>, [selectors: string]>;
+        replaceChildren: ((...nodes: (Node | string)[]) => void) & import("vitest-mock-extended").CalledWithMock<void, (string | Node)[]>;
+        createExpression: ((expression: string, resolver?: XPathNSResolver | null) => XPathExpression) & import("vitest-mock-extended").CalledWithMock<XPathExpression, [expression: string, resolver?: XPathNSResolver | null | undefined]>;
+        createNSResolver: ((nodeResolver: Node) => Node) & import("vitest-mock-extended").CalledWithMock<Node, [nodeResolver: Node]>;
+        evaluate: ((expression: string, contextNode: Node, resolver?: XPathNSResolver | null, type?: number, result?: XPathResult | null) => XPathResult) & import("vitest-mock-extended").CalledWithMock<XPathResult, [expression: string, contextNode: Node, resolver?: XPathNSResolver | null | undefined, type?: number | undefined, result?: XPathResult | null | undefined]>;
+    } & Document;
+    triggerVisibilityChange: () => void;
+};