@astral/mobx-query 1.7.2 → 1.8.1

package/AuxiliaryQuery/AuxiliaryQuery.d.ts

@@ -30,7 +30,7 @@ export declare class AuxiliaryQuery<TResult, TError = void> {
      * Метод ответственный за создание единого промиса,
      * для устранения гонки запросов
      */
-    getUnifiedPromise: (executor: Executor<TResult>, onSuccess?: ((data: TResult) => void) | undefined) => Promise<TResult>;
+    getUnifiedPromise: (executor: Executor<TResult>, onSuccess?: (data: TResult) => void) => Promise<TResult>;
     private setSuccess;
     private checkBackgroundAndSet;
     /**

package/MobxQuery/MobxQuery.d.ts

@@ -24,20 +24,27 @@ type MobxQueryParams = {
      */
     enabledAutoFetch?: boolean;
 };
-type CreateQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<QueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
+export type CreateQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<QueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
     /**
      * Режим фонового обновления
      * @default false
      */
     isBackground?: TIsBackground;
 };
-type CreateInfiniteQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<InfiniteQueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
+export type CreateInfiniteQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<InfiniteQueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
     /**
      * Режим фонового обновления
      * @default false
      */
     isBackground?: TIsBackground;
 };
+export type CreateMutationParams<TResult, TError> = MutationParams<TResult, TError>;
+/**
+ * Стратегия инвалидации кэша
+ * @property 'partial-match' - Проверяет наличие хотя бы одной части ключа в кэше
+ * @property 'chain-match' - Проверяет наличие полной связки ключей в кэше
+ */
+type InvalidateStrategy = 'partial-match' | 'chain-match';
 /**
  * Сервис, позволяющий кэшировать данные.
  */
@@ -74,10 +81,26 @@ export declare class MobxQuery<TDefaultError = void> {
     private serialize;
     constructor({ onError, fetchPolicy, enabledAutoFetch, }?: MobxQueryParams);
     /**
-     * Метод для инвалидации по списку ключей,
-     * предполагается использование из домена
-     */
-    invalidate: (keysParts: CacheKey[]) => void;
+     * Проверяет пересечение ключей в зависимости от стратегии
+     * @param invalidatedKeys - Ключи для инвалидации
+     * @param queryKeys - Ключи запроса
+     * @param strategy - Стратегия проверки:
+     * - 'chain-match' - все ключи из invalidatedKeys должны присутствовать в queryKeys
+     * - 'partial-match' - хотя бы один ключ из invalidatedKeys должен быть в queryKeys
+     */
+    private checkTouchedElement;
+    /**
+     * Метод для инвалидации по списку ключей, предполагается использование из домена
+     * @param invalidatedKeys - Массив ключей для инвалидации
+     * @param strategy - Стратегия инвалидации. 'chain-match' - инвалидировать при совпадении связки ключей в кэше, 'partial-match' - инвалидировать при частичном совпадении ключей. По умолчанию 'partial-match'
+     * @example
+     * // Инвалидация по частичному совпадению ключей
+     * mobxQuery.invalidate(['users', '1']); // Инвалидирует все query, содержащие ключ 'users' или '1'
+     *
+     * // Инвалидация по совпадению связки ключей
+     * mobxQuery.invalidate(['users', '1'], 'chain-match'); // Инвалидирует только query с точным набором ключей ['users', '1']
+     */
+    invalidate: (invalidatedKeys: CacheKey[], strategy?: InvalidateStrategy) => void;
     private submitValidity;
     /**
      * Метод инвалидации всех query
@@ -96,14 +119,14 @@ export declare class MobxQuery<TDefaultError = void> {
     /**
      * Метод создания стора, кешируется
      */
-    createQuery: <TResult, TError = TDefaultError, TIsBackground extends boolean = false>(key: CacheKey[], executor: QueryExecutor<TResult>, params?: CreateQueryParams<TResult, TError, TIsBackground> | undefined) => Query<TResult, TError, TIsBackground>;
+    createQuery: <TResult, TError = TDefaultError, TIsBackground extends boolean = false>(key: CacheKey[], executor: QueryExecutor<TResult>, params?: CreateQueryParams<TResult, TError, TIsBackground>) => Query<TResult, TError, TIsBackground>;
     /**
      * Метод создания инфинит стора, кешируется
      */
-    createInfiniteQuery: <TResult, TError = TDefaultError, TIsBackground extends boolean = false>(key: CacheKey[], executor: InfiniteExecutor<TResult>, params?: CreateInfiniteQueryParams<TResult, TError, TIsBackground> | undefined) => InfiniteQuery<TResult, TError, TIsBackground>;
+    createInfiniteQuery: <TResult, TError = TDefaultError, TIsBackground extends boolean = false>(key: CacheKey[], executor: InfiniteExecutor<TResult>, params?: CreateInfiniteQueryParams<TResult, TError, TIsBackground>) => InfiniteQuery<TResult, TError, TIsBackground>;
     /**
      * Метод создания мутации, не кешируется
      */
-    createMutation: <TResult, TError = TDefaultError, TExecutorParams = void>(executor: MutationExecutor<TResult, TExecutorParams>, params?: MutationParams<TResult, TError> | undefined) => Mutation<TResult, TError, TExecutorParams>;
+    createMutation: <TResult, TError = TDefaultError, TExecutorParams = void>(executor: MutationExecutor<TResult, TExecutorParams>, params?: CreateMutationParams<TResult, TError>) => Mutation<TResult, TError, TExecutorParams>;
 }
 export {};

package/MobxQuery/MobxQuery.js

@@ -27,20 +27,39 @@ export class MobxQuery {
         this.statusStorageFactory = new StatusStorageFactory();
         this.serialize = (data) => JSON.stringify(data);
         /**
-         * Метод для инвалидации по списку ключей,
-         * предполагается использование из домена
+         * Проверяет пересечение ключей в зависимости от стратегии
+         * @param invalidatedKeys - Ключи для инвалидации
+         * @param queryKeys - Ключи запроса
+         * @param strategy - Стратегия проверки:
+         * - 'chain-match' - все ключи из invalidatedKeys должны присутствовать в queryKeys
+         * - 'partial-match' - хотя бы один ключ из invalidatedKeys должен быть в queryKeys
          */
-        this.invalidate = (keysParts) => {
-            // Сет сериализованных ключей
-            const keysSet = new Set(keysParts.map(this.serialize));
-            [...this.keys.keys()].forEach((keyHash) => {
-                const key = this.keys.get(keyHash);
-                if (!key) {
+        this.checkTouchedElement = (invalidatedKeys, queryKeys, strategy) => {
+            const serializedInvalidatedKeys = invalidatedKeys.map(this.serialize);
+            if (strategy === 'chain-match') {
+                return serializedInvalidatedKeys.every((invalidatedKey) => queryKeys.some((queryKey) => invalidatedKey === this.serialize(queryKey)));
+            }
+            return queryKeys.some((queryKey) => serializedInvalidatedKeys.find((invalidatedKey) => invalidatedKey === this.serialize(queryKey)));
+        };
+        /**
+         * Метод для инвалидации по списку ключей, предполагается использование из домена
+         * @param invalidatedKeys - Массив ключей для инвалидации
+         * @param strategy - Стратегия инвалидации. 'chain-match' - инвалидировать при совпадении связки ключей в кэше, 'partial-match' - инвалидировать при частичном совпадении ключей. По умолчанию 'partial-match'
+         * @example
+         * // Инвалидация по частичному совпадению ключей
+         * mobxQuery.invalidate(['users', '1']); // Инвалидирует все query, содержащие ключ 'users' или '1'
+         *
+         * // Инвалидация по совпадению связки ключей
+         * mobxQuery.invalidate(['users', '1'], 'chain-match'); // Инвалидирует только query с точным набором ключей ['users', '1']
+         */
+        this.invalidate = (invalidatedKeys, strategy = 'partial-match') => {
+            for (const keyHash of this.keys.keys()) {
+                const queryKeys = this.keys.get(keyHash);
+                if (!queryKeys) {
                     return;
                 }
                 // Проверяем, есть ли пересечение между закешированными ключами и набором ключей для инвалидации
-                const hasTouchedElement = key.some((valuePart) => keysSet.has(this.serialize(valuePart)));
-                if (hasTouchedElement) {
+                if (this.checkTouchedElement(invalidatedKeys, queryKeys, strategy)) {
                     const query = this.queriesMap.get(keyHash);
                     if (query) {
                         query.invalidate();
@@ -49,7 +68,7 @@ export class MobxQuery {
                         this.queriesMap.convertToWeak(keyHash);
                     }
                 }
-            });
+            }
         };
         // Метод для подтверждения того, что квери успешно получил валидные данные
         this.submitValidity = (keyHash) => {

package/index.d.ts

@@ -1,4 +1,5 @@
 export { Mutation } from './Mutation';
 export { Query } from './Query';
-export { InfiniteQuery } from './InfiniteQuery';
-export { MobxQuery } from './MobxQuery';
+export { type InfiniteParams } from './InfiniteQuery';
+export { MobxQuery, type CreateQueryParams, type CreateInfiniteQueryParams, type CreateMutationParams, } from './MobxQuery';
+export { type CacheKey, type FetchPolicy } from './types';

package/index.js

@@ -1,4 +1,3 @@
 export { Mutation } from './Mutation';
 export { Query } from './Query';
-export { InfiniteQuery } from './InfiniteQuery';
-export { MobxQuery } from './MobxQuery';
+export { MobxQuery, } from './MobxQuery';

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);