@astral/mobx-query 1.8.0 → 1.8.1

package/node/Query/Query.d.ts

@@ -0,0 +1,103 @@
+import { AuxiliaryQuery } from '../AuxiliaryQuery';
+import type { FetchPolicy, QueryBaseActions, Sync, SyncParams } from '../types';
+import type { DataStorage } from '../DataStorage';
+import { QueryContainer } from '../QueryContainer';
+import { type StatusStorage } from '../StatusStorage';
+/**
+ * Исполнитель запроса
+ */
+export type QueryExecutor<TResult> = () => Promise<TResult>;
+export type QueryParams<TResult, TError, TIsBackground extends boolean = false> = {
+    /**
+     * Обработчик ошибки, вызываемый по умолчанию
+     */
+    onError?: SyncParams<TResult, TError>['onError'];
+    /**
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     */
+    enabledAutoFetch?: boolean;
+    /**
+     * Политика получения данных.
+     * @enum cache-first - данные сначала берутся из кеша, если их нет, тогда идет обращение к сети, ответ записывается в кэш
+     * @enum network-only - данные всегда берутся из сети, при этом ответ записывается в кэш
+     */
+    fetchPolicy?: FetchPolicy;
+    /**
+     * Инстанс хранилища данных
+     */
+    dataStorage: DataStorage<TResult>;
+    /**
+     * Инстанс хранилища основных статусов
+     */
+    statusStorage: StatusStorage<TError>;
+    /**
+     * Инстанс хранилища фоновых статусов
+     */
+    backgroundStatusStorage?: TIsBackground extends true ? StatusStorage<TError> : null | undefined;
+    /**
+     * Колбэк, вызываемый при успешном завершении запроса, подразумевается использование, для подтверждения валидности данных, чтобы квери не был удален из памяти
+     */
+    submitValidity?: () => void;
+};
+/**
+ * Стор для работы с запросами,
+ * которые должны быть закешированы,
+ * но им не требуется усложнение в виде работы с фильтрами и инфинити запросами
+ */
+export declare class Query<TResult, TError = void, TIsBackground extends boolean = false> extends QueryContainer<TError, AuxiliaryQuery<TResult, TError>, TIsBackground> implements QueryBaseActions<TResult, TError, undefined> {
+    private readonly executor;
+    /**
+     * Хранилище данных, для обеспечения возможности синхронизации данных между разными инстансами
+     */
+    private storage;
+    /**
+     * Обработчик ошибки, вызываемый по умолчанию
+     */
+    private defaultOnError?;
+    /**
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     */
+    private enabledAutoFetch?;
+    /**
+     * Стандартное поведение политики кеширования
+     */
+    private readonly defaultFetchPolicy?;
+    /**
+     * Колбэк, вызываемый при успешном завершении запроса, подразумевается использование, для подтверждения валидности данных, чтобы квери не был удален из памяти
+     */
+    private readonly submitValidity?;
+    constructor(executor: QueryExecutor<TResult>, { onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage, submitValidity, }: QueryParams<TResult, TError, TIsBackground>);
+    private get isNetworkOnly();
+    /**
+     * Метод для инвалидации данных
+     */
+    invalidate: () => void;
+    /**
+     * Синхронный метод получения данных
+     */
+    sync: Sync<TResult, TError, undefined>;
+    /**
+     * Обработчик успешного ответа
+     */
+    private submitSuccess;
+    /**
+     * Форс метод для установки данных
+     */
+    forceUpdate: (data: TResult) => void;
+    /**
+     * Метод для переиспользования синхронной логики запроса
+     */
+    protected proceedSync: Sync<TResult, TError>;
+    /**
+     * Асинхронный метод получения данных,
+     * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+     */
+    async: () => Promise<TResult>;
+    /**
+     * Содержит реактивные данные
+     * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
+     * следовательно, стриггерится условие невалидности,
+     * и начнется запрос, в результате которого, данные обновятся
+     */
+    get data(): TResult | undefined;
+}

package/node/Query/Query.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = void 0;
+const mobx_1 = require("mobx");
+const AuxiliaryQuery_1 = require("../AuxiliaryQuery");
+const QueryContainer_1 = require("../QueryContainer");
+/**
+ * Стор для работы с запросами,
+ * которые должны быть закешированы,
+ * но им не требуется усложнение в виде работы с фильтрами и инфинити запросами
+ */
+class Query extends QueryContainer_1.QueryContainer {
+    constructor(executor, { onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage = null, submitValidity, }) {
+        super(statusStorage, backgroundStatusStorage, new AuxiliaryQuery_1.AuxiliaryQuery(statusStorage, backgroundStatusStorage));
+        this.executor = executor;
+        /**
+         * Метод для инвалидации данных
+         */
+        this.invalidate = () => {
+            this.auxiliary.invalidate();
+        };
+        /**
+         * Синхронный метод получения данных
+         */
+        this.sync = (params) => {
+            const isInstanceAllow = !(this.isLoading || this.isSuccess);
+            if (this.isNetworkOnly || this.auxiliary.isInvalid || isInstanceAllow) {
+                this.proceedSync(params);
+            }
+        };
+        /**
+         * Обработчик успешного ответа
+         */
+        this.submitSuccess = (resData) => {
+            var _a;
+            this.storage.setData(resData);
+            (_a = this.submitValidity) === null || _a === void 0 ? void 0 : _a.call(this);
+            return resData;
+        };
+        /**
+         * Форс метод для установки данных
+         */
+        this.forceUpdate = (data) => {
+            this.auxiliary.submitSuccess();
+            this.submitSuccess(data);
+        };
+        /**
+         * Метод для переиспользования синхронной логики запроса
+         */
+        this.proceedSync = (options) => {
+            const { onSuccess, onError } = options || {};
+            this.auxiliary
+                .getUnifiedPromise(this.executor, (res) => {
+                this.submitSuccess(res);
+                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(res);
+            })
+                .catch((e) => {
+                var _a;
+                if (onError) {
+                    onError(e);
+                }
+                else {
+                    (_a = this.defaultOnError) === null || _a === void 0 ? void 0 : _a.call(this, e);
+                }
+            });
+        };
+        /**
+         * Асинхронный метод получения данных,
+         * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+         */
+        this.async = () => {
+            if (!this.isNetworkOnly && this.isSuccess && !this.auxiliary.isInvalid) {
+                return Promise.resolve(this.storage.data);
+            }
+            return this.auxiliary.getUnifiedPromise(this.executor, this.submitSuccess);
+        };
+        this.defaultOnError = onError;
+        this.enabledAutoFetch = enabledAutoFetch;
+        this.defaultFetchPolicy = fetchPolicy;
+        this.storage = dataStorage;
+        this.submitValidity = submitValidity;
+        (0, mobx_1.makeObservable)(this, {
+            async: mobx_1.action,
+            sync: mobx_1.action,
+            forceUpdate: mobx_1.action,
+            data: mobx_1.computed,
+            submitSuccess: mobx_1.action,
+        });
+    }
+    get isNetworkOnly() {
+        return this.defaultFetchPolicy === 'network-only';
+    }
+    /**
+     * Содержит реактивные данные
+     * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
+     * следовательно, стриггерится условие невалидности,
+     * и начнется запрос, в результате которого, данные обновятся
+     */
+    get data() {
+        const shouldSync = this.enabledAutoFetch &&
+            !this.isSuccess &&
+            !this.isLoading &&
+            !this.isError;
+        if (this.auxiliary.isInvalid || shouldSync) {
+            // т.к. при вызове апдейта, изменяются флаги, на которые подписан data,
+            // нужно вызывать этот экшн асинхронно
+            (0, mobx_1.when)(() => true, this.proceedSync);
+        }
+        // возвращаем имеющиеся данные
+        return this.storage.data;
+    }
+}
+exports.Query = Query;

package/node/Query/index.d.ts

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

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

package/node/QueryContainer/QueryContainer.d.ts

@@ -0,0 +1,61 @@
+import { type StatusStorage } from '../StatusStorage';
+export type QueryContainerAuxiliary = {
+    isIdle: boolean;
+};
+type Statuses<TError> = StatusStorage<TError>;
+/**
+ * Контейнер для бойлерплейт части,
+ * позволяет не повторять в каждом наследуемом классе использование стандартных статусов
+ */
+export declare abstract class QueryContainer<TError, TAuxiliary extends QueryContainerAuxiliary, TIsBackground extends boolean> implements Statuses<TError> {
+    private readonly statusStorage;
+    private readonly backgroundStatusStorage;
+    protected readonly auxiliary: TAuxiliary;
+    protected constructor(statusStorage: StatusStorage<TError>, backgroundStatusStorage: StatusStorage<TError> | null, auxiliary: TAuxiliary);
+    /**
+     * Флаг загрузки данных
+     */
+    get isLoading(): boolean;
+    /**
+     * Флаг обозначающий, что последний запрос был зафейлен
+     */
+    get isError(): boolean;
+    /**
+     * Данные о последней ошибке
+     */
+    get error(): TError | undefined;
+    /**
+     * Флаг обозначающий, что последний запрос был успешно завершен
+     */
+    get isSuccess(): boolean;
+    /**
+     * Флаг, обозначающий простаивание, т.е. запроса еще не было
+     */
+    get isIdle(): boolean;
+    /**
+     * Статусы, изменяющиеся после первого успешного запроса в режиме isBackground: true
+     * @example
+     * const query = mobxQuery.createQuery(
+     *     ['some cache key'],
+     *     () => Promise.resolve('foo'),
+     *     { isBackground: true }
+     * );
+     *
+     * await query.async();
+     * console.log(query.isLoading); // переключался в true на момент запроса
+     * console.log(query.isSuccess); // true
+     *
+     * query.invalidate();
+     * await query.async();
+     * console.log(query.isLoading); // не изменялся
+     * console.log(query.isSuccess); // остался неизменным - true
+     *
+     * console.log(query.background.isLoading); // переключался в true на момент обновления
+     * console.log(query.background.isSuccess); // true
+     *
+     * @exception isBackground:false (а так же по умолчанию) background не доступен, и равен null
+     * @exception Mutation не доступен в мутации и равен null
+     */
+    get background(): TIsBackground extends true ? Statuses<TError> : null;
+}
+export {};

package/node/QueryContainer/QueryContainer.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryContainer = void 0;
+const mobx_1 = require("mobx");
+/**
+ * Контейнер для бойлерплейт части,
+ * позволяет не повторять в каждом наследуемом классе использование стандартных статусов
+ */
+class QueryContainer {
+    constructor(statusStorage, backgroundStatusStorage, auxiliary) {
+        this.statusStorage = statusStorage;
+        this.backgroundStatusStorage = backgroundStatusStorage;
+        this.auxiliary = auxiliary;
+        (0, mobx_1.makeObservable)(this, {
+            error: mobx_1.computed,
+            isError: mobx_1.computed,
+            isIdle: mobx_1.computed,
+            isLoading: mobx_1.computed,
+            isSuccess: mobx_1.computed,
+        });
+    }
+    /**
+     * Флаг загрузки данных
+     */
+    get isLoading() {
+        return this.statusStorage.isLoading;
+    }
+    /**
+     * Флаг обозначающий, что последний запрос был зафейлен
+     */
+    get isError() {
+        return this.statusStorage.isError;
+    }
+    /**
+     * Данные о последней ошибке
+     */
+    get error() {
+        return this.statusStorage.error;
+    }
+    /**
+     * Флаг обозначающий, что последний запрос был успешно завершен
+     */
+    get isSuccess() {
+        return this.statusStorage.isSuccess;
+    }
+    /**
+     * Флаг, обозначающий простаивание, т.е. запроса еще не было
+     */
+    get isIdle() {
+        return this.auxiliary.isIdle;
+    }
+    /**
+     * Статусы, изменяющиеся после первого успешного запроса в режиме isBackground: true
+     * @example
+     * const query = mobxQuery.createQuery(
+     *     ['some cache key'],
+     *     () => Promise.resolve('foo'),
+     *     { isBackground: true }
+     * );
+     *
+     * await query.async();
+     * console.log(query.isLoading); // переключался в true на момент запроса
+     * console.log(query.isSuccess); // true
+     *
+     * query.invalidate();
+     * await query.async();
+     * console.log(query.isLoading); // не изменялся
+     * console.log(query.isSuccess); // остался неизменным - true
+     *
+     * console.log(query.background.isLoading); // переключался в true на момент обновления
+     * console.log(query.background.isSuccess); // true
+     *
+     * @exception isBackground:false (а так же по умолчанию) background не доступен, и равен null
+     * @exception Mutation не доступен в мутации и равен null
+     */
+    get background() {
+        if (!this.backgroundStatusStorage) {
+            return null;
+        }
+        return this.backgroundStatusStorage;
+    }
+}
+exports.QueryContainer = QueryContainer;

package/node/QueryContainer/index.d.ts

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

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

package/node/StatusStorage/StatusStorage.d.ts

@@ -0,0 +1,24 @@
+import { StorageFactory } from '../StorageFactory';
+export declare class StatusStorage<TError> {
+    constructor();
+    /**
+     * Флаг обозначающий загрузку данных
+     */
+    isLoading: boolean;
+    /**
+     * Флаг обозначающий, что последний запрос был зафейлен
+     */
+    isError: boolean;
+    /**
+     * Данные о последней ошибке
+     */
+    error?: TError;
+    /**
+     * Флаг, обозначающий успешность завершения последнего запроса
+     */
+    isSuccess: boolean;
+}
+export declare class StatusStorageFactory extends StorageFactory<StatusStorage<void>> {
+    constructor();
+    getStorage: <TError>(keyHash: string) => StatusStorage<TError>;
+}

package/node/StatusStorage/StatusStorage.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusStorageFactory = exports.StatusStorage = void 0;
+const mobx_1 = require("mobx");
+const StorageFactory_1 = require("../StorageFactory");
+class StatusStorage {
+    constructor() {
+        /**
+         * Флаг обозначающий загрузку данных
+         */
+        this.isLoading = false;
+        /**
+         * Флаг обозначающий, что последний запрос был зафейлен
+         */
+        this.isError = false;
+        /**
+         * Данные о последней ошибке
+         */
+        this.error = undefined;
+        /**
+         * Флаг, обозначающий успешность завершения последнего запроса
+         */
+        this.isSuccess = false;
+        (0, mobx_1.makeObservable)(this, {
+            error: mobx_1.observable,
+            isError: mobx_1.observable,
+            isLoading: mobx_1.observable,
+            isSuccess: mobx_1.observable,
+        });
+    }
+}
+exports.StatusStorage = StatusStorage;
+class StatusStorageFactory extends StorageFactory_1.StorageFactory {
+    constructor() {
+        super(() => new StatusStorage());
+        this.getStorage = (keyHash) => {
+            return this.getInternalStorage(keyHash);
+        };
+    }
+}
+exports.StatusStorageFactory = StatusStorageFactory;

package/node/StatusStorage/index.d.ts

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

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

package/node/StorageFactory/StorageFactory.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class StorageFactory<TStorage extends {}> {
+    private readonly createStorage;
+    private readonly adaptableMap;
+    protected constructor(createStorage: () => TStorage);
+    /**
+     * Фабричный метод получения/создания инстанса хранилища по ключу
+     */
+    getInternalStorage: (keyHash: string) => TStorage;
+}

package/node/StorageFactory/StorageFactory.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageFactory = void 0;
+const AdaptableMap_1 = require("../AdaptableMap");
+class StorageFactory {
+    constructor(createStorage) {
+        this.createStorage = createStorage;
+        this.adaptableMap = new AdaptableMap_1.AdaptableMap();
+        /**
+         * Фабричный метод получения/создания инстанса хранилища по ключу
+         */
+        this.getInternalStorage = (keyHash) => {
+            const storage = this.adaptableMap.get(keyHash);
+            if (!storage) {
+                const createdStorage = this.createStorage();
+                this.adaptableMap.set(keyHash, createdStorage);
+                return createdStorage;
+            }
+            return storage;
+        };
+    }
+}
+exports.StorageFactory = StorageFactory;

package/node/StorageFactory/index.d.ts

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

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

package/node/index.d.ts

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

package/node/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobxQuery = exports.Query = exports.Mutation = void 0;
+var Mutation_1 = require("./Mutation");
+Object.defineProperty(exports, "Mutation", { enumerable: true, get: function () { return Mutation_1.Mutation; } });
+var Query_1 = require("./Query");
+Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return Query_1.Query; } });
+var MobxQuery_1 = require("./MobxQuery");
+Object.defineProperty(exports, "MobxQuery", { enumerable: true, get: function () { return MobxQuery_1.MobxQuery; } });

package/node/types.d.ts

@@ -0,0 +1,55 @@
+export type SyncParams<TResult, TError, TExecutorParams = void> = {
+    onSuccess?: (res: TResult) => void;
+    onError?: (e: TError) => void;
+    params?: TExecutorParams;
+};
+/**
+ * синхронный метод получения данных
+ */
+export type Sync<TResult, TError, TExecutorParams = void> = (params?: SyncParams<TResult, TError, TExecutorParams>) => void;
+/**
+ * асинхронный метод получения данных
+ */
+export type Async<TResult, TExecutorParams = void> = (params: TExecutorParams) => Promise<TResult>;
+export type QueryBaseActions<TResult, TError, TExecutorParams = void> = {
+    /**
+     * синхронный метод получения данных
+     */
+    sync: Sync<TResult, TError, TExecutorParams>;
+    /**
+     * асинхронный метод получения данных
+     */
+    async: Async<TResult, TExecutorParams>;
+    /**
+     * флаг обозначающий загрузку данных
+     */
+    isLoading: boolean;
+    /**
+     * флаг обозначающий, что последний запрос был зафейлен
+     */
+    isError: boolean;
+    /**
+     * данные о последней ошибке
+     */
+    error?: TError;
+    /**
+     * флаг обзначающий, что последний запрос был успешно выполнен
+     */
+    isSuccess: boolean;
+    /**
+     * флаг, обозначающий простаивание, т.е. запроса еще не было
+     */
+    isIdle: boolean;
+};
+/**
+ * политика получения данных.
+ * @enum cache-first - данные сначала берутся из кеша, если их нет, тогда идет обращение к сети, ответ записывается в кэш
+ * @enum network-only - данные всегда берутся из сети, при этом ответ записывается в кэш
+ */
+export type FetchPolicy = 'network-only' | 'cache-first';
+/**
+ * ключ для кешированя
+ */
+export type CacheKey = string | number | boolean | null | undefined | CacheKey[] | {
+    [key: string]: CacheKey;
+};

package/node/types.js

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

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@astral/mobx-query",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "browser": "./index.js",
-  "main": "./index.js",
+  "main": "./node/index.js",
   "dependencies": {
     "mobx": "^6.9.0"
   },
@@ -20,6 +20,10 @@
   "types": "./index.d.ts",
   "module": "./index.js",
   "exports": {
-    ".": "./index.js"
+    ".": {
+      "vitest": "./node/index.js",
+      "module": "./index.js",
+      "require": "./node/index.js"
+    }
   }
 }