@astral/mobx-query 1.15.0 → 1.16.0

package/__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;
+};

package/__test/documentMock/documentMock.js

@@ -0,0 +1,18 @@
+// biome-ignore lint/correctness/noUndeclaredDependencies: требуется для тестов
+import { mock } from 'vitest-mock-extended';
+export const createDocumentMock = () => {
+    let isVisible = true;
+    const listeners = [];
+    const documentMock = mock({
+        addEventListener: (_, listener) => listeners.push(listener),
+        get visibilityState() {
+            return isVisible ? 'visible' : 'hidden';
+        },
+        set visibilityState(_) { },
+    });
+    const triggerVisibilityChange = () => {
+        isVisible = !isVisible;
+        listeners.forEach((listener) => listener());
+    };
+    return { documentMock, triggerVisibilityChange };
+};

package/__test/documentMock/index.d.ts

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

package/__test/documentMock/index.js

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

package/__test/index.d.ts

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

package/__test/index.js

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

package/node/MobxQuery/MobxQuery.d.ts

@@ -3,6 +3,7 @@ import { Mutation, type MutationExecutor, type MutationParams } from '../Mutatio
 import { Query, type QueryExecutor, type QueryParams } from '../Query';
 import { InfiniteQuerySet, type InfiniteQuerySetConfig, type InfiniteQuerySetConfigurator, MutationSet, QuerySet, type QuerySetConfig, type QuerySetConfigurator } from '../Sets';
 import type { CacheKey, FetchPolicy } from '../types';
+import type { UnknownCachedQuery } from './types';
 /**
  * Стандартный обработчик ошибки запроса,
  * будет вызван, если при вызове sync не был передан отдельный onError параметр
@@ -15,6 +16,12 @@ type WithSynchronization = {
      */
     enabledSynchronization?: boolean;
 };
+type WithPollingTime = {
+    /**
+     * Время в мс, раз в которое необходимо инвалидировать query
+     */
+    pollingTime?: number;
+};
 type MobxQueryParams = {
     /**
      * Политика получения данных по умолчанию.
@@ -43,19 +50,15 @@ export type CreateQueryParams<TResult, TError, TIsBackground extends boolean> =
      * @default false
      */
     isBackground?: TIsBackground;
-} & WithSynchronization;
+} & WithSynchronization & WithPollingTime;
 export type CreateInfiniteQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<InfiniteQueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
     /**
      * Режим фонового обновления
      * @default false
      */
     isBackground?: TIsBackground;
-} & WithSynchronization;
+} & WithSynchronization & WithPollingTime;
 export type CreateMutationParams<TResult, TError> = MutationParams<TResult, TError>;
-/**
- * Внутриний тип кешируемого стора
- */
-type CachedQuery<TResult, TError, TIsBackground extends boolean> = Query<TResult, TError, TIsBackground> | InfiniteQuery<TResult, TError, TIsBackground>;
 /**
  * Стратегия инвалидации кэша
  * @property 'partial-match' - Проверяет наличие хотя бы одной части ключа в кэше
@@ -97,11 +100,12 @@ export declare class MobxQuery<TDefaultError = void> {
     private readonly defaultEnabledAutoFetch;
     private readonly defauleEnabledSynchronization;
     private readonly synchronizationService;
+    private readonly pollingService;
     private serialize;
     constructor({ onError, fetchPolicy, enabledAutoFetch, enabledSynchronization, }?: MobxQueryParams, _BroadcastChannel?: {
         new (name: string): BroadcastChannel;
         prototype: BroadcastChannel;
-    });
+    }, _document?: Document);
     /**
      * Проверяет пересечение ключей в зависимости от стратегии
      * @param invalidatedKeys - Ключи для инвалидации
@@ -123,6 +127,7 @@ export declare class MobxQuery<TDefaultError = void> {
      * mobxQuery.invalidate(['users', '1'], 'chain-match'); // Инвалидирует только query с точным набором ключей ['users', '1']
      */
     invalidate: (invalidatedKeys: CacheKey[], strategy?: InvalidateStrategy) => void;
+    private invalidateByKeyHash;
     /**
      * Метод для получения массива хешей ключей на основании ключей и стратегии
      */
@@ -130,7 +135,7 @@ export declare class MobxQuery<TDefaultError = void> {
     /**
      * метод для получения массива существующий квери на основании ключей и стратегии
      */
-    getExistsQueries: <TQuery = CachedQuery<unknown, unknown, false>>(keys: CacheKey[], strategy?: InvalidateStrategy) => TQuery[];
+    getExistsQueries: <TQuery = UnknownCachedQuery>(keys: CacheKey[], strategy?: InvalidateStrategy) => TQuery[];
     private submitValidity;
     /**
      * Метод инвалидации всех query

package/node/MobxQuery/MobxQuery.js

@@ -5,6 +5,7 @@ const AdaptableMap_1 = require("../AdaptableMap");
 const DataStorage_1 = require("../DataStorage");
 const InfiniteQuery_1 = require("../InfiniteQuery");
 const Mutation_1 = require("../Mutation");
+const PollingService_1 = require("../PollingService");
 const Query_1 = require("../Query");
 const Sets_1 = require("../Sets");
 const StatusStorage_1 = require("../StatusStorage");
@@ -13,7 +14,7 @@ const SynchronizationService_1 = require("../SynchronizationService");
  * Сервис, позволяющий кэшировать данные.
  */
 class MobxQuery {
-    constructor({ onError, fetchPolicy = 'cache-first', enabledAutoFetch = false, enabledSynchronization = false, } = {}, _BroadcastChannel = globalThis.BroadcastChannel) {
+    constructor({ onError, fetchPolicy = 'cache-first', enabledAutoFetch = false, enabledSynchronization = false, } = {}, _BroadcastChannel = globalThis.BroadcastChannel, _document = globalThis.document) {
         /**
          * Объект соответствия хешей ключей и их значений
          */
@@ -58,13 +59,15 @@ class MobxQuery {
          * mobxQuery.invalidate(['users', '1'], 'chain-match'); // Инвалидирует только query с точным набором ключей ['users', '1']
          */
         this.invalidate = (invalidatedKeys, strategy = 'partial-match') => {
-            this.getExistsKeyHashes(invalidatedKeys, strategy).forEach(({ keyHash }) => {
-                var _a;
-                (_a = this.queriesMap.get(keyHash)) === null || _a === void 0 ? void 0 : _a.invalidate();
-                // Конвертируем инвалидированный квери в слабый,
-                // чтобы сборщик мусора мог удалить неиспользуемые квери
-                this.queriesMap.convertToWeak(keyHash);
-            });
+            this.getExistsKeyHashes(invalidatedKeys, strategy).forEach(({ keyHash }) => this.invalidateByKeyHash(keyHash));
+        };
+        this.invalidateByKeyHash = (keyHash) => {
+            var _a;
+            (_a = this.queriesMap.get(keyHash)) === null || _a === void 0 ? void 0 : _a.invalidate();
+            // Конвертируем инвалидированный квери в слабый,
+            // чтобы сборщик мусора мог удалить неиспользуемые квери
+            this.queriesMap.convertToWeak(keyHash);
+            this.pollingService.clean(keyHash);
         };
         /**
          * Метод для получения массива хешей ключей на основании ключей и стратегии
@@ -81,10 +84,13 @@ class MobxQuery {
          */
         this.getExistsQueries = (keys, strategy = 'partial-match') => this.getExistsKeyHashes(keys, strategy).map(({ keyHash }) => this.queriesMap.get(keyHash));
         // Метод для подтверждения того, что квери успешно получил валидные данные
-        this.submitValidity = (keys, isNetworkOnly, enabledSynchronization) => {
+        this.submitValidity = (keys, isNetworkOnly, enabledSynchronization, pollingTime) => {
             if (enabledSynchronization) {
                 this.synchronizationService.emit(keys);
             }
+            if (pollingTime) {
+                this.pollingService.setupTimer(keys.queryKeyHash, pollingTime);
+            }
             // 'network-only' квери не будут конвертироваться,
             // следовательно, они всегда будут храниться как "слабые",
             // что позволит сборщику мусора удалять их из памяти при отсутствии ссылок
@@ -98,13 +104,7 @@ class MobxQuery {
         /**
          * Метод инвалидации всех query
          */
-        this.invalidateQueries = () => {
-            [...this.keys.keys()].forEach((keyHash) => {
-                var _a;
-                (_a = this.queriesMap.get(keyHash)) === null || _a === void 0 ? void 0 : _a.invalidate();
-                this.queriesMap.convertToWeak(keyHash);
-            });
-        };
+        this.invalidateQueries = () => [...this.keys.keys()].forEach(this.invalidateByKeyHash);
         /**
          * Метод, который занимается проверкой наличия квери по ключу,
          * и если нет, создает новый, добавляет его к себе в память, и возвращает его пользователю
@@ -127,7 +127,7 @@ class MobxQuery {
                 backgroundStatusStorage: this.getBackgroundStatusStorage(keys.backgroundStatusKeyHash, Boolean(createParams === null || createParams === void 0 ? void 0 : createParams.isBackground)),
                 submitValidity: () => {
                     var _a;
-                    return this.submitValidity(keys, fetchPolicy !== 'network-only', (_a = createParams === null || createParams === void 0 ? void 0 : createParams.enabledSynchronization) !== null && _a !== void 0 ? _a : this.defauleEnabledSynchronization);
+                    return this.submitValidity(keys, fetchPolicy !== 'network-only', (_a = createParams === null || createParams === void 0 ? void 0 : createParams.enabledSynchronization) !== null && _a !== void 0 ? _a : this.defauleEnabledSynchronization, createParams === null || createParams === void 0 ? void 0 : createParams.pollingTime);
                 },
             });
             this.queriesMap.set(keys.queryKeyHash, query);
@@ -231,7 +231,8 @@ class MobxQuery {
         this.defaultFetchPolicy = fetchPolicy;
         this.defaultEnabledAutoFetch = enabledAutoFetch;
         this.defauleEnabledSynchronization = enabledSynchronization;
-        this.synchronizationService = new SynchronizationService_1.SynchronizationService(this.statusStorageFactory, this.queryDataStorageFactory, _BroadcastChannel);
+        this.pollingService = new PollingService_1.PollingService(this.queriesMap, this.invalidateByKeyHash, _document);
+        this.synchronizationService = new SynchronizationService_1.SynchronizationService(this.statusStorageFactory, this.queryDataStorageFactory, this.pollingService, _BroadcastChannel);
     }
 }
 exports.MobxQuery = MobxQuery;

package/node/MobxQuery/types.d.ts

@@ -0,0 +1,22 @@
+import { type InfiniteQuery } from '../InfiniteQuery';
+import { type Query } from '../Query';
+import { type CacheKey } from '../types';
+/**
+ * Внутриний тип кешируемого стора
+ */
+export type CachedQuery<TResult, TError, TIsBackground extends boolean> = Query<TResult, TError, TIsBackground> | InfiniteQuery<TResult, TError, TIsBackground>;
+export type UnknownCachedQuery = CachedQuery<unknown, unknown, false>;
+/**
+ * Хэш ключа
+ */
+export type KeyHash = string;
+/**
+ * Набор ключей
+ */
+export type Keys = {
+    queryKey: CacheKey[];
+    dataKeyHash: KeyHash;
+    statusKeyHash: KeyHash;
+    queryKeyHash: KeyHash;
+    backgroundStatusKeyHash: KeyHash;
+};

package/node/MobxQuery/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });