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

package/AuxiliaryQuery/AuxiliaryQuery.js

@@ -1,6 +1,6 @@
 import { action, makeObservable, observable, runInAction } from 'mobx';
 /**
- * вспомогательное хранилище данных, для композиции в Query сторах,
+ * Вспомогательное хранилище данных, для композиции в Query сторах,
  * содержащее флаги загрузки и ошибки,
  * колбэки на успешный запрос и на ошибку,
  * данные последней ошибки,
@@ -11,15 +11,15 @@ export class AuxiliaryQuery {
         this.statusStorage = statusStorage;
         this.backgroundStatusStorage = backgroundStatusStorage;
         /**
-         * флаг, обозначающий простаивание, т.е. запроса еще не было
+         * Флаг, обозначающий простаивание, т.е. запроса еще не было
          */
         this.isIdle = true;
         /**
-         * флаг, по которому реактивно определяется необходимость запуска инвалидации
+         * Флаг, по которому реактивно определяется необходимость запуска инвалидации
          */
         this.isInvalid = false;
         /**
-         * метод ответственный за создание единого промиса,
+         * Метод ответственный за создание единого промиса,
          * для устранения гонки запросов
          */
         this.getUnifiedPromise = (executor) => {
@@ -59,7 +59,7 @@ export class AuxiliaryQuery {
             }
         };
         /**
-         * обработчик успешного ответа
+         * Обработчик успешного ответа
          */
         this.submitSuccess = () => {
             this.checkBackgroundAndSet(this.setSuccess);
@@ -71,7 +71,7 @@ export class AuxiliaryQuery {
             storage.error = error;
         };
         /**
-         * обработчик ошибки
+         * Обработчик ошибки
          */
         this.submitError = (error) => {
             this.checkBackgroundAndSet((storage) => this.setError(storage, error));
@@ -82,14 +82,14 @@ export class AuxiliaryQuery {
             storage.isSuccess = false;
         };
         /**
-         * метод, вызываемый в самом начале запроса, чтобы сбросить флаги в соответствующее значение
+         * Метод, вызываемый в самом начале запроса, чтобы сбросить флаги в соответствующее значение
          */
         this.startLoading = () => {
             this.isIdle = false;
             this.checkBackgroundAndSet(this.setLoading);
         };
         /**
-         * метод для инвалидации данных
+         * Метод для инвалидации данных
          */
         this.invalidate = () => {
             this.isInvalid = true;

package/DataStorage/DataStorage.d.ts

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

package/DataStorage/DataStorage.js

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

package/InfiniteQuery/InfiniteQuery.d.ts

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

package/InfiniteQuery/InfiniteQuery.js

@@ -3,31 +3,33 @@ import { AuxiliaryQuery } from '../AuxiliaryQuery';
 import { QueryContainer } from '../QueryContainer';
 export const DEFAULT_INFINITE_ITEMS_COUNT = 30;
 /**
- * стор для работы с инфинити запросами,
+ * Квери для работы с инфинити запросами,
  * которые должны быть закешированы,
  */
 export class InfiniteQuery extends QueryContainer {
-    constructor(executor, { incrementCount = DEFAULT_INFINITE_ITEMS_COUNT, onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage = null, }) {
+    constructor(executor, { incrementCount = DEFAULT_INFINITE_ITEMS_COUNT, onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage = null, submitValidity, }) {
         super(statusStorage, backgroundStatusStorage, new AuxiliaryQuery(statusStorage, backgroundStatusStorage));
         this.executor = executor;
         /**
-         * счетчик отступа для инфинити запроса
+         * Счетчик отступа для инфинити запроса
          */
         this.offset = 0;
         /**
-         * флаг того, что мы достигли предела запрашиваемых элементов
+         * Флаг того, что мы достигли предела запрашиваемых элементов
          */
         this.isEndReached = false;
         /**
-         * обработчик успешного запроса, проверяет что мы достигли предела
+         * Обработчик успешного запроса, проверяет что мы достигли предела
          */
         this.submitSuccess = (result, onSuccess, isIncrement) => {
+            var _a;
             onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(result);
             if (isIncrement && this.storage.hasData) {
                 this.storage.setData([...this.storage.data, ...result]);
             }
             else {
                 this.storage.setData(result);
+                (_a = this.submitValidity) === null || _a === void 0 ? void 0 : _a.call(this);
             }
             // убеждаемся что результат запроса действительно массив,
             // и если количество элементов в ответе меньше,
@@ -41,7 +43,7 @@ export class InfiniteQuery extends QueryContainer {
             }
         };
         /**
-         * форс метод для установки данных
+         * Форс метод для установки данных
          */
         this.forceUpdate = (data) => {
             this.offset = 0;
@@ -50,13 +52,13 @@ export class InfiniteQuery extends QueryContainer {
             this.submitSuccess(data);
         };
         /**
-         * метод для инвалидации данных
+         * Метод для инвалидации данных
          */
         this.invalidate = () => {
             this.auxiliary.invalidate();
         };
         /**
-         * метод для запроса следующего набора данных
+         * Метод для запроса следующего набора данных
          */
         this.fetchMore = () => {
             // если мы еще не достигли предела
@@ -72,7 +74,7 @@ export class InfiniteQuery extends QueryContainer {
             }
         };
         /**
-         * синхронный метод получения данных
+         * Синхронный метод получения данных
          */
         this.sync = (params) => {
             const isInstanceAllow = !(this.isLoading || this.isSuccess);
@@ -81,7 +83,7 @@ export class InfiniteQuery extends QueryContainer {
             }
         };
         /**
-         * метод для переиспользования синхронной логики запроса
+         * Метод для переиспользования синхронной логики запроса
          */
         this.proceedSync = ({ onSuccess, onError, } = {}) => {
             this.offset = 0;
@@ -102,7 +104,7 @@ export class InfiniteQuery extends QueryContainer {
             });
         };
         /**
-         * aсинхронный метод получения данных,
+         * Асинхронный метод получения данных,
          * подходит для изменения параметров запроса(фильтров),
          * при котором будет сброшен offset,
          * предполагается, что нужно будет самостоятельно обрабатывать ошибку
@@ -129,6 +131,7 @@ export class InfiniteQuery extends QueryContainer {
         this.defaultOnError = onError;
         this.enabledAutoFetch = enabledAutoFetch;
         this.defaultFetchPolicy = fetchPolicy;
+        this.submitValidity = submitValidity;
         makeObservable(this, {
             data: computed,
             infiniteExecutor: computed,
@@ -143,7 +146,7 @@ export class InfiniteQuery extends QueryContainer {
         return this.defaultFetchPolicy === 'network-only';
     }
     /**
-     * метод для обогащения параметров текущими значениями для инфинити
+     * Метод для обогащения параметров текущими значениями для инфинити
      */
     get infiniteExecutor() {
         return () => this.executor({
@@ -152,7 +155,7 @@ export class InfiniteQuery extends QueryContainer {
         });
     }
     /**
-     * вычисляемое свойство, содержащее реактивные данные,
+     * Вычисляемое свойство, содержащее реактивные данные,
      * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
      * следовательно, стриггерится условие невалидности,
      * и начнется запрос, в результате которого, данные обновятся