@astral/mobx-query 1.8.0 → 1.8.1

package/node/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/node/AdaptableMap/AdaptableMap.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptableMap = void 0;
+/**
+ * Фасад для работы с 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 "Сильное" состояние подразумевает то, что значение хранится как есть, т.е. даже если в системе не останется других ссылок на хранимое значение, сборщик мусора не сможет удалить его из памяти.
+ */
+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);
+        };
+    }
+}
+exports.AdaptableMap = AdaptableMap;

package/node/AdaptableMap/index.d.ts

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

package/node/AdaptableMap/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("./AdaptableMap"), exports);

package/node/AuxiliaryQuery/AuxiliaryQuery.d.ts

@@ -0,0 +1,55 @@
+import { type StatusStorage } from '../StatusStorage';
+/**
+ * Испольнитель запроса
+ */
+type Executor<TResult> = () => Promise<TResult>;
+/**
+ * Вспомогательное хранилище данных, для композиции в Query сторах,
+ * содержащее флаги загрузки и ошибки,
+ * колбэки на успешный запрос и на ошибку,
+ * данные последней ошибки,
+ * а так же, управляющее синглтон промисом.
+ */
+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>, onSuccess?: (data: TResult) => void) => Promise<TResult>;
+    private setSuccess;
+    private checkBackgroundAndSet;
+    /**
+     * Обработчик успешного ответа
+     */
+    submitSuccess: () => void;
+    private setError;
+    /**
+     * Обработчик ошибки
+     */
+    submitError: (error: TError) => void;
+    private setLoading;
+    /**
+     * Метод, вызываемый в самом начале запроса, чтобы сбросить флаги в соответствующее значение
+     */
+    startLoading: () => void;
+    /**
+     * Метод для инвалидации данных
+     */
+    invalidate: () => void;
+}
+export {};

package/node/AuxiliaryQuery/AuxiliaryQuery.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuxiliaryQuery = void 0;
+const mobx_1 = require("mobx");
+/**
+ * Вспомогательное хранилище данных, для композиции в Query сторах,
+ * содержащее флаги загрузки и ошибки,
+ * колбэки на успешный запрос и на ошибку,
+ * данные последней ошибки,
+ * а так же, управляющее синглтон промисом.
+ */
+class AuxiliaryQuery {
+    constructor(statusStorage, backgroundStatusStorage) {
+        this.statusStorage = statusStorage;
+        this.backgroundStatusStorage = backgroundStatusStorage;
+        /**
+         * Флаг, обозначающий простаивание, т.е. запроса еще не было
+         */
+        this.isIdle = true;
+        /**
+         * Флаг, по которому реактивно определяется необходимость запуска инвалидации
+         */
+        this.isInvalid = false;
+        /**
+         * Метод ответственный за создание единого промиса,
+         * для устранения гонки запросов
+         */
+        this.getUnifiedPromise = (executor, onSuccess) => {
+            // проверяем, если синглтона нет, то надо создать
+            if (!Boolean(this.unifiedPromise)) {
+                this.startLoading();
+                this.unifiedPromise = executor()
+                    .then((resData) => {
+                    (0, mobx_1.runInAction)(this.submitSuccess);
+                    onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(resData);
+                    return resData;
+                })
+                    .catch((e) => {
+                    (0, mobx_1.runInAction)(() => {
+                        this.submitError(e);
+                    });
+                    throw e;
+                })
+                    .finally(() => {
+                    this.unifiedPromise = undefined;
+                    (0, mobx_1.runInAction)(() => {
+                        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);
+            }
+        };
+        /**
+         * Обработчик успешного ответа
+         */
+        this.submitSuccess = () => {
+            this.checkBackgroundAndSet(this.setSuccess);
+            this.isInvalid = false;
+        };
+        this.setError = (storage, error) => {
+            storage.isSuccess = false;
+            storage.isError = true;
+            storage.error = error;
+        };
+        /**
+         * Обработчик ошибки
+         */
+        this.submitError = (error) => {
+            this.checkBackgroundAndSet((storage) => this.setError(storage, error));
+        };
+        this.setLoading = (storage) => {
+            storage.isLoading = true;
+            storage.isError = false;
+            storage.isSuccess = false;
+        };
+        /**
+         * Метод, вызываемый в самом начале запроса, чтобы сбросить флаги в соответствующее значение
+         */
+        this.startLoading = () => {
+            this.isIdle = false;
+            this.checkBackgroundAndSet(this.setLoading);
+        };
+        /**
+         * Метод для инвалидации данных
+         */
+        this.invalidate = () => {
+            this.isInvalid = true;
+        };
+        (0, mobx_1.makeObservable)(this, {
+            getUnifiedPromise: mobx_1.action,
+            isIdle: mobx_1.observable,
+            isInvalid: mobx_1.observable,
+            submitSuccess: mobx_1.action,
+            setSuccess: mobx_1.action,
+            setError: mobx_1.action,
+            setLoading: mobx_1.action,
+            submitError: mobx_1.action,
+            startLoading: mobx_1.action,
+            invalidate: mobx_1.action,
+        });
+    }
+}
+exports.AuxiliaryQuery = AuxiliaryQuery;

package/node/AuxiliaryQuery/index.d.ts

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

package/node/AuxiliaryQuery/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("./AuxiliaryQuery"), exports);

package/node/DataStorage/DataStorage.d.ts

@@ -0,0 +1,33 @@
+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>(keyHash: string) => DataStorage<TData>;
+}

package/node/DataStorage/DataStorage.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataStorageFactory = exports.DataStorage = void 0;
+const mobx_1 = require("mobx");
+const StorageFactory_1 = require("../StorageFactory");
+/**
+ * Хранилище данных, предназначено для обеспечения единого интерфейса при работе с данными
+ */
+class DataStorage {
+    constructor() {
+        /**
+         * Поле, отвечающее за непосредственное хранение данных
+         */
+        this.internalData = undefined;
+        /**
+         * Метод для установки данных
+         */
+        this.setData = (value) => {
+            this.internalData = value;
+        };
+        (0, mobx_1.makeAutoObservable)(this);
+    }
+    /**
+     * Флаг, отображающий наличие данных
+     */
+    get hasData() {
+        return Boolean(this.internalData);
+    }
+    /**
+     * Геттер данных
+     */
+    get data() {
+        return this.internalData;
+    }
+}
+exports.DataStorage = DataStorage;
+/**
+ * Фабрика ответственная за создание и хранение экземляров хранилищ
+ */
+class DataStorageFactory extends StorageFactory_1.StorageFactory {
+    constructor() {
+        super(() => new DataStorage());
+        /**
+         * Фабричный метод получения/создания инстанса хранилища по ключу
+         */
+        this.getStorage = (keyHash) => {
+            return this.getInternalStorage(keyHash);
+        };
+    }
+}
+exports.DataStorageFactory = DataStorageFactory;

package/node/DataStorage/index.d.ts

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

package/node/DataStorage/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("./DataStorage"), exports);

package/node/InfiniteQuery/InfiniteQuery.d.ts

@@ -0,0 +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;
+};
+/**
+ * Исполнитель запроса, ожидается,
+ * что будет использоваться что-то возвращающее массив данных
+ */
+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
+     */
+    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
+     */
+    private enabledAutoFetch?;
+    /**
+     * Стандартное поведение политики кеширования
+     */
+    private readonly defaultFetchPolicy?;
+    /**
+     * Колбэк, вызываемый при успешном завершении запроса, подразумевается использование, для подтверждения валидности данных, чтобы квери не был удален из памяти
+     */
+    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;
+    /**
+     * Асинхронный метод получения данных,
+     * подходит для изменения параметров запроса(фильтров),
+     * при котором будет сброшен offset,
+     * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+     */
+    async: () => Promise<TResult[]>;
+    /**
+     * Вычисляемое свойство, содержащее реактивные данные,
+     * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
+     * следовательно, стриггерится условие невалидности,
+     * и начнется запрос, в результате которого, данные обновятся
+     */
+    get data(): TResult[] | undefined;
+}