@astral/mobx-query 1.4.0 → 1.6.0

package/AdaptableMap/AdaptableMap.d.ts

@@ -0,0 +1,29 @@
+export type SimplifiedMap<TData> = Pick<Map<string, TData>, 'get' | 'delete' | 'has'> & {
+    set: (key: string, value: TData) => void;
+};
+/**
+ * Фасад для работы с Map, умеющий в конвертацию хранимого значения в "слабое" состояние и в "сильное"
+ * По умолчанию все значения хранятся как "слабые".
+ * @enum "Слабое" состояние подразумевает то, что хранимое значение сохранено через WeakRef, следовательно, если в системе не останется ссылок на хранимое значение, сборщик мусора сможет удалить это значение из памяти.
+ * @enum "Сильное" состояние подразумевает то, что значение хранится как есть, т.е. даже если в системе не останется других ссылок на хранимое значение, сборщик мусора не сможет удалить его из памяти.
+ */
+export declare class AdaptableMap<TData extends {}> implements SimplifiedMap<TData> {
+    private strong;
+    private weak;
+    get: (key: string) => TData | undefined;
+    set: (key: string, data: TData) => void;
+    delete: (key: string) => boolean;
+    has: (key: string) => boolean;
+    /**
+     * Метод перемещающий значение из одного Map в другой
+     */
+    private change;
+    /**
+     * Метод для конвертации значения из "сильного" в "слабое" состояние
+     */
+    convertToWeak: (key: string) => void;
+    /**
+     * Метод для конвертации значения из "слабого" в "сильное" состояние
+     */
+    convertToStrong: (key: string) => void;
+}

package/AdaptableMap/AdaptableMap.js

@@ -0,0 +1,77 @@
+/**
+ * Фасад для работы с Map, хранящим значения как WeakRef
+ */
+class WeakRefMap {
+    constructor() {
+        this.map = new Map();
+        this.get = (key) => {
+            var _a, _b;
+            // Проверка на старые браузеры, не умеющие в WeakRef
+            if (!globalThis.WeakRef) {
+                return this.map.get(key);
+            }
+            return (_b = (_a = this.map.get(key)) === null || _a === void 0 ? void 0 : _a.deref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        };
+        this.set = (key, value) => {
+            // Проверка на старые браузеры, не умеющие в WeakRef
+            if (!globalThis.WeakRef) {
+                this.map.set(key, value);
+            }
+            else {
+                this.map.set(key, new globalThis.WeakRef(value));
+            }
+        };
+        this.delete = (key) => this.map.delete(key);
+        this.has = (key) => this.map.has(key);
+    }
+}
+/**
+ * Фасад для работы с Map, умеющий в конвертацию хранимого значения в "слабое" состояние и в "сильное"
+ * По умолчанию все значения хранятся как "слабые".
+ * @enum "Слабое" состояние подразумевает то, что хранимое значение сохранено через WeakRef, следовательно, если в системе не останется ссылок на хранимое значение, сборщик мусора сможет удалить это значение из памяти.
+ * @enum "Сильное" состояние подразумевает то, что значение хранится как есть, т.е. даже если в системе не останется других ссылок на хранимое значение, сборщик мусора не сможет удалить его из памяти.
+ */
+export class AdaptableMap {
+    constructor() {
+        this.strong = new Map();
+        this.weak = new WeakRefMap();
+        this.get = (key) => {
+            if (this.strong.has(key)) {
+                return this.strong.get(key);
+            }
+            return this.weak.get(key);
+        };
+        this.set = (key, data) => {
+            this.weak.set(key, data);
+        };
+        this.delete = (key) => {
+            // если успешно удалилось в "слабом" хранилище, тогда в "сильном" уже не имеет смысла удалять.
+            return this.weak.delete(key) || this.strong.delete(key);
+        };
+        this.has = (key) => {
+            return Boolean(this.weak.get(key)) || this.strong.has(key);
+        };
+        /**
+         * Метод перемещающий значение из одного Map в другой
+         */
+        this.change = (key, from, to) => {
+            const query = this.get(key);
+            if (query) {
+                from.delete(key);
+                to.set(key, query);
+            }
+        };
+        /**
+         * Метод для конвертации значения из "сильного" в "слабое" состояние
+         */
+        this.convertToWeak = (key) => {
+            this.change(key, this.strong, this.weak);
+        };
+        /**
+         * Метод для конвертации значения из "слабого" в "сильное" состояние
+         */
+        this.convertToStrong = (key) => {
+            this.change(key, this.weak, this.strong);
+        };
+    }
+}

package/AdaptableMap/index.d.ts

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

package/AdaptableMap/index.js

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

package/AuxiliaryQuery/AuxiliaryQuery.d.ts

@@ -1,56 +1,55 @@
+import { type StatusStorage } from '../StatusStorage';
 /**
- * @description испольнитель запроса
+ * Испольнитель запроса
  */
 type Executor<TResult> = () => Promise<TResult>;
 /**
- * @description вспомогательное хранилище данных, для композиции в Query сторах,
+ * Вспомогательное хранилище данных, для композиции в Query сторах,
  * содержащее флаги загрузки и ошибки,
  * колбэки на успешный запрос и на ошибку,
  * данные последней ошибки,
  * а так же, управляющее синглтон промисом.
  */
 export declare class AuxiliaryQuery<TResult, TError = void> {
+    private readonly statusStorage;
+    private readonly backgroundStatusStorage;
     /**
-     * @description флаг обозначающий загрузку данных
+     * Флаг, обозначающий простаивание, т.е. запроса еще не было
      */
-    isLoading: boolean;
-    /**
-     * @description флаг обозначающий, что последний запрос был зафейлен
-     */
-    isError: boolean;
-    /**
-     * @description данные о последней ошибке
-     */
-    error?: TError;
-    /**
-     * @description флаг, обозначающий успешность завершения последнего запроса
-     */
-    isSuccess: boolean;
+    isIdle: boolean;
     /**
-     * флаг, обозначающий простаивание, т.е. запроса еще не было
+     * Единый промис, для устранения гонки запросов
      */
-    isIdle: boolean;
+    private unifiedPromise?;
     /**
-     * @description единый промис, для устранения гонки запросов
+     * Флаг, по которому реактивно определяется необходимость запуска инвалидации
      */
-    unifiedPromise?: Promise<TResult>;
-    constructor();
+    isInvalid: boolean;
+    constructor(statusStorage: StatusStorage<TError>, backgroundStatusStorage: StatusStorage<TError> | null);
     /**
-     * @description метод ответственный за создание единого промиса,
+     * Метод ответственный за создание единого промиса,
      * для устранения гонки запросов
      */
     getUnifiedPromise: (executor: Executor<TResult>) => Promise<TResult>;
+    private setSuccess;
+    private checkBackgroundAndSet;
     /**
-     * @description обработчик успешного ответа
+     * Обработчик успешного ответа
      */
     submitSuccess: () => void;
+    private setError;
     /**
-     * @description обработчик ошибки
+     * Обработчик ошибки
      */
-    submitError: (e: TError) => void;
+    submitError: (error: TError) => void;
+    private setLoading;
     /**
-     * @description метод, вызываемый в самом начале запроса, чтобы сбросить флаги в соответствующее значение
+     * Метод, вызываемый в самом начале запроса, чтобы сбросить флаги в соответствующее значение
      */
     startLoading: () => void;
+    /**
+     * Метод для инвалидации данных
+     */
+    invalidate: () => void;
 }
 export {};

package/AuxiliaryQuery/AuxiliaryQuery.js

@@ -1,35 +1,25 @@
-import { makeAutoObservable, runInAction } from 'mobx';
+import { action, makeObservable, observable, runInAction } from 'mobx';
 /**
- * @description вспомогательное хранилище данных, для композиции в Query сторах,
+ * Вспомогательное хранилище данных, для композиции в Query сторах,
  * содержащее флаги загрузки и ошибки,
  * колбэки на успешный запрос и на ошибку,
  * данные последней ошибки,
  * а так же, управляющее синглтон промисом.
  */
 export class AuxiliaryQuery {
-    constructor() {
+    constructor(statusStorage, backgroundStatusStorage) {
+        this.statusStorage = statusStorage;
+        this.backgroundStatusStorage = backgroundStatusStorage;
         /**
-         * @description флаг обозначающий загрузку данных
+         * Флаг, обозначающий простаивание, т.е. запроса еще не было
          */
-        this.isLoading = false;
-        /**
-         * @description флаг обозначающий, что последний запрос был зафейлен
-         */
-        this.isError = false;
-        /**
-         * @description данные о последней ошибке
-         */
-        this.error = undefined;
-        /**
-         * @description флаг, обозначающий успешность завершения последнего запроса
-         */
-        this.isSuccess = false;
+        this.isIdle = true;
         /**
-         * флаг, обозначающий простаивание, т.е. запроса еще не было
+         * Флаг, по которому реактивно определяется необходимость запуска инвалидации
          */
-        this.isIdle = true;
+        this.isInvalid = false;
         /**
-         * @description метод ответственный за создание единого промиса,
+         * Метод ответственный за создание единого промиса,
          * для устранения гонки запросов
          */
         this.getUnifiedPromise = (executor) => {
@@ -50,36 +40,71 @@ export class AuxiliaryQuery {
                     .finally(() => {
                     this.unifiedPromise = undefined;
                     runInAction(() => {
-                        this.isLoading = false;
+                        this.statusStorage.isLoading = false;
                     });
                 });
             }
             return this.unifiedPromise;
         };
+        this.setSuccess = (storage) => {
+            storage.isError = false;
+            storage.isSuccess = true;
+        };
+        this.checkBackgroundAndSet = (setStorage) => {
+            if (this.backgroundStatusStorage && this.statusStorage.isSuccess) {
+                setStorage(this.backgroundStatusStorage);
+            }
+            else {
+                setStorage(this.statusStorage);
+            }
+        };
         /**
-         * @description обработчик успешного ответа
+         * Обработчик успешного ответа
          */
         this.submitSuccess = () => {
-            this.isError = false;
-            this.isSuccess = true;
+            this.checkBackgroundAndSet(this.setSuccess);
+            this.isInvalid = false;
+        };
+        this.setError = (storage, error) => {
+            storage.isSuccess = false;
+            storage.isError = true;
+            storage.error = error;
         };
         /**
-         * @description обработчик ошибки
+         * Обработчик ошибки
          */
-        this.submitError = (e) => {
-            this.isSuccess = false;
-            this.isError = true;
-            this.error = e;
+        this.submitError = (error) => {
+            this.checkBackgroundAndSet((storage) => this.setError(storage, error));
+        };
+        this.setLoading = (storage) => {
+            storage.isLoading = true;
+            storage.isError = false;
+            storage.isSuccess = false;
         };
         /**
-         * @description метод, вызываемый в самом начале запроса, чтобы сбросить флаги в соответствующее значение
+         * Метод, вызываемый в самом начале запроса, чтобы сбросить флаги в соответствующее значение
          */
         this.startLoading = () => {
             this.isIdle = false;
-            this.isLoading = true;
-            this.isError = false;
-            this.isSuccess = false;
+            this.checkBackgroundAndSet(this.setLoading);
+        };
+        /**
+         * Метод для инвалидации данных
+         */
+        this.invalidate = () => {
+            this.isInvalid = true;
         };
-        makeAutoObservable(this, { unifiedPromise: false });
+        makeObservable(this, {
+            getUnifiedPromise: action,
+            isIdle: observable,
+            isInvalid: observable,
+            submitSuccess: action,
+            setSuccess: action,
+            setError: action,
+            setLoading: action,
+            submitError: action,
+            startLoading: action,
+            invalidate: action,
+        });
     }
 }

package/DataStorage/DataStorage.d.ts

@@ -1,36 +1,33 @@
-import type { CacheKey } from '../types';
+import { StorageFactory } from '../StorageFactory';
 /**
- * @description хранилище данных, предназначено для обеспечения единого интерфейса при работе с данными
+ * Хранилище данных, предназначено для обеспечения единого интерфейса при работе с данными
  */
 export declare class DataStorage<TData> {
     /**
-     * @description поле, отвечающее за непосредственное хранение данных
+     * Поле, отвечающее за непосредственное хранение данных
      */
     private internalData?;
     constructor();
     /**
-     * @description флаг, отображающий наличие данных
+     * Флаг, отображающий наличие данных
      */
     get hasData(): boolean;
     /**
-     * @description метод для установки данных
+     * Метод для установки данных
      */
     setData: (value: TData) => void;
     /**
-     * @description геттер данных
+     * Геттер данных
      */
     get data(): TData | undefined;
 }
 /**
- * @description фабрика ответственная за создание и хранение экземляров хранилищ
+ * Фабрика ответственная за создание и хранение экземляров хранилищ
  */
-export declare class DataStorageFactory {
-    /**
-     * @description Map хранящий инстансы хранилищ по хэшу ключа
-     */
-    private storageMap;
+export declare class DataStorageFactory extends StorageFactory<DataStorage<unknown>> {
+    constructor();
     /**
-     * @description фабричный метод получения/создания инстанса хранилища по ключу
+     * Фабричный метод получения/создания инстанса хранилища по ключу
      */
-    getStorage: <TData>(key: CacheKey[]) => DataStorage<TData>;
+    getStorage: <TData>(keyHash: string) => DataStorage<TData>;
 }

package/DataStorage/DataStorage.js

@@ -1,15 +1,16 @@
 import { makeAutoObservable } from 'mobx';
+import { StorageFactory } from '../StorageFactory';
 /**
- * @description хранилище данных, предназначено для обеспечения единого интерфейса при работе с данными
+ * Хранилище данных, предназначено для обеспечения единого интерфейса при работе с данными
  */
 export class DataStorage {
     constructor() {
         /**
-         * @description поле, отвечающее за непосредственное хранение данных
+         * Поле, отвечающее за непосредственное хранение данных
          */
         this.internalData = undefined;
         /**
-         * @description метод для установки данных
+         * Метод для установки данных
          */
         this.setData = (value) => {
             this.internalData = value;
@@ -17,36 +18,29 @@ export class DataStorage {
         makeAutoObservable(this);
     }
     /**
-     * @description флаг, отображающий наличие данных
+     * Флаг, отображающий наличие данных
      */
     get hasData() {
         return Boolean(this.internalData);
     }
     /**
-     * @description геттер данных
+     * Геттер данных
      */
     get data() {
         return this.internalData;
     }
 }
 /**
- * @description фабрика ответственная за создание и хранение экземляров хранилищ
+ * Фабрика ответственная за создание и хранение экземляров хранилищ
  */
-export class DataStorageFactory {
+export class DataStorageFactory extends StorageFactory {
     constructor() {
+        super(() => new DataStorage());
         /**
-         * @description Map хранящий инстансы хранилищ по хэшу ключа
+         * Фабричный метод получения/создания инстанса хранилища по ключу
          */
-        this.storageMap = new Map();
-        /**
-         * @description фабричный метод получения/создания инстанса хранилища по ключу
-         */
-        this.getStorage = (key) => {
-            const keyHash = JSON.stringify(key);
-            if (!this.storageMap.has(keyHash)) {
-                this.storageMap.set(keyHash, new DataStorage());
-            }
-            return this.storageMap.get(keyHash);
+        this.getStorage = (keyHash) => {
+            return this.getInternalStorage(keyHash);
         };
     }
 }

package/InfiniteQuery/InfiniteQuery.d.ts

@@ -1,140 +1,135 @@
 import type { FetchPolicy, QueryBaseActions, Sync, SyncParams } from '../types';
+import { AuxiliaryQuery } from '../AuxiliaryQuery';
 import type { DataStorage } from '../DataStorage';
+import { QueryContainer } from '../QueryContainer';
+import { type StatusStorage } from '../StatusStorage';
 export declare const DEFAULT_INFINITE_ITEMS_COUNT = 30;
 export type InfiniteParams = {
     offset: number;
     count: number;
 };
 /**
- * @description исполнитель запроса, ожидается,
+ * Исполнитель запроса, ожидается,
  * что будет использоваться что-то возвращающее массив данных
  */
 export type InfiniteExecutor<TResult> = (params: InfiniteParams) => Promise<Array<TResult>>;
-export type InfiniteQueryParams<TResult, TError> = {
+export type InfiniteQueryParams<TResult, TError, TIsBackground extends boolean = false> = {
     /**
-     * @description количество запрашиваемых элементов
+     * Количество запрашиваемых элементов
      * @default 30
      */
     incrementCount?: number;
     /**
-     * @description обработчик ошибки, вызываемый по умолчанию
+     * Обработчик ошибки, вызываемый по умолчанию
      */
     onError?: SyncParams<TResult, TError>['onError'];
     /**
-     * @description флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data
      */
     enabledAutoFetch?: boolean;
+    /**
+     * Инстанс хранилища основных статусов
+     */
+    statusStorage: StatusStorage<TError>;
+    /**
+     * Политика получения данных.
+     * @enum cache-first - данные сначала берутся из кеша, если их нет, тогда идет обращение к сети, ответ записывается в кэш
+     * @enum network-only - данные всегда берутся из сети, при этом ответ записывается в кэш
+     */
     fetchPolicy?: FetchPolicy;
     /**
-     * @description инстанс хранилища данных
+     * Инстанс хранилища данных
      */
     dataStorage: DataStorage<TResult[]>;
+    /**
+     * Инстанс хранилища фоновых статусов
+     */
+    backgroundStatusStorage?: TIsBackground extends true ? StatusStorage<TError> : null | undefined;
+    /**
+     * Колбэк, вызываемый при успешном завершении запроса, подразумевается использование, для подтверждения валидности данных, чтобы квери не был удален из памяти
+     */
+    submitValidity?: () => void;
 };
 /**
- * @description стор для работы с инфинити запросами,
+ * Квери для работы с инфинити запросами,
  * которые должны быть закешированы,
  */
-export declare class InfiniteQuery<TResult, TError = void> implements QueryBaseActions<Array<TResult>, TError> {
-    /**
-     * @description инстанс вспомогательного стора
-     */
-    private auxiliary;
+export declare class InfiniteQuery<TResult, TError = void, TIsBackground extends boolean = false> extends QueryContainer<TError, AuxiliaryQuery<Array<TResult>, TError>, TIsBackground> implements QueryBaseActions<Array<TResult>, TError> {
+    private readonly executor;
     /**
-     * @description счетчик отступа для инфинити запроса
+     * Счетчик отступа для инфинити запроса
      */
     private offset;
     /**
-     * @description количество запрашиваемых элементов
+     * Количество запрашиваемых элементов
      */
     private readonly incrementCount;
     /**
-     * @description исполнитель запроса, ожидается,
-     * что будет использоваться что-то из слоя sources, возвращающее массив данных
-     */
-    private executor;
-    /**
-     * @description хранилище данных, для обеспечения возможности синхронизации данных между разными инстансами
+     * Хранилище данных, для обеспечения возможности синхронизации данных между разными инстансами
      */
     private storage;
     /**
-     * @description флаг того, что мы достигли предела запрашиваемых элементов
+     * Флаг того, что мы достигли предела запрашиваемых элементов
      */
     isEndReached: boolean;
     /**
-     * @description флаг необходимости выполнить обновления данных
-     */
-    private isInvalid;
-    /**
-     * @description обработчик ошибки, вызываемый по умолчанию
+     * Обработчик ошибки, вызываемый по умолчанию
      */
     private defaultOnError?;
     /**
-     * @description флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data
      */
     private enabledAutoFetch?;
     /**
-     * @description стандартное поведение политики кеширования
+     * Стандартное поведение политики кеширования
      */
     private readonly defaultFetchPolicy?;
-    constructor(executor: InfiniteExecutor<TResult>, { incrementCount, onError, enabledAutoFetch, fetchPolicy, dataStorage, }: InfiniteQueryParams<TResult, TError>);
+    /**
+     * Колбэк, вызываемый при успешном завершении запроса, подразумевается использование, для подтверждения валидности данных, чтобы квери не был удален из памяти
+     */
+    private readonly submitValidity?;
+    constructor(executor: InfiniteExecutor<TResult>, { incrementCount, onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage, submitValidity, }: InfiniteQueryParams<TResult, TError, TIsBackground>);
     private get isNetworkOnly();
     /**
-     * @description обработчик успешного запроса, проверяет что мы достигли предела
+     * Обработчик успешного запроса, проверяет что мы достигли предела
      */
     private submitSuccess;
     /**
-     * @description форс метод для установки данных
+     * Форс метод для установки данных
      */
     forceUpdate: (data: TResult[]) => void;
     /**
-     * @description метод для обогащения параметров текущими значениями для инфинити
+     * Метод для обогащения параметров текущими значениями для инфинити
      */
     private get infiniteExecutor();
     /**
-     * @description метод для инвалидации данных
+     * Метод для инвалидации данных
      */
     invalidate: () => void;
     /**
-     * @description метод для запроса следующего набора данных
+     * Метод для запроса следующего набора данных
      */
     fetchMore: () => void;
     /**
-     * @description синхронный метод получения данных
+     * Синхронный метод получения данных
      */
     sync: Sync<Array<TResult>, TError>;
     /**
-     * @description метод для переиспользования синхронной логики запроса
+     * Метод для переиспользования синхронной логики запроса
      */
     private proceedSync;
     /**
-     * @description aсинхронный метод получения данных,
+     * Асинхронный метод получения данных,
      * подходит для изменения параметров запроса(фильтров),
      * при котором будет сброшен offset,
      * предполагается, что нужно будет самостоятельно обрабатывать ошибку
      */
     async: () => Promise<TResult[]>;
     /**
-     * @description вычисляемое свойство, содержащее реактивные данные,
+     * Вычисляемое свойство, содержащее реактивные данные,
      * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
      * следовательно, стриггерится условие невалидности,
      * и начнется запрос, в результате которого, данные обновятся
      */
     get data(): TResult[] | undefined;
-    /**
-     * @description флаг загрузки данных
-     */
-    get isLoading(): boolean;
-    /**
-     * @description флаг обозначающий, что последний запрос был зафейлен
-     */
-    get isError(): boolean;
-    /**
-     * @description данные о последней ошибке
-     */
-    get error(): TError | undefined;
-    /**
-     * @description флаг обозначающий, что последний запрос был успешно завершен
-     */
-    get isSuccess(): boolean;
-    get isIdle(): boolean;
 }