@fozy-labs/rx-toolkit 0.4.1

package/dist/query/core/Resource/Resource.js

@@ -0,0 +1,154 @@
+import { QueriesCache } from "../QueriesCache";
+import { SharedOptions } from "../SharedOptions";
+import { ResourceAgent } from "./ResourceAgent";
+import { ResourceRef } from "./ResourceRef";
+class ResourceQueryState {
+    static create() {
+        return {
+            abortController: null,
+            args: null,
+            data: null,
+            error: null,
+            isError: false,
+            isReloading: false,
+            isDone: false,
+            isSuccess: false,
+            isLocked: false,
+            isLoading: false,
+            isInitiated: false,
+            lockCount: 0
+        };
+    }
+    static load(state = ResourceQueryState.create(), args) {
+        return {
+            ...state,
+            args: args,
+            isLoading: !state.isDone,
+            isReloading: state.isDone,
+            isInitiated: true,
+        };
+    }
+    static success(state, data) {
+        return {
+            ...state,
+            data,
+            isLoading: false,
+            isReloading: false,
+            isDone: true,
+            isSuccess: true,
+            isError: false,
+            error: null,
+        };
+    }
+    static error(state, error) {
+        return {
+            ...state,
+            isLoading: false,
+            isReloading: false,
+            isDone: true,
+            isSuccess: false,
+            isError: true,
+            error,
+        };
+    }
+    static incrementLock(state) {
+        const lockCount = state.lockCount + 1;
+        return {
+            ...state,
+            isLocked: lockCount > 0,
+            lockCount
+        };
+    }
+    static decrementLock(state) {
+        const lockCount = Math.max(0, state.lockCount - 1);
+        return {
+            ...state,
+            isLocked: lockCount > 0,
+            lockCount
+        };
+    }
+    static setData(state, data) {
+        return {
+            ...state,
+            data
+        };
+    }
+}
+export class Resource {
+    _options;
+    _queriesCache = new QueriesCache('res');
+    constructor(_options) {
+        this._options = _options;
+    }
+    createAgent = () => {
+        return new ResourceAgent(this);
+    };
+    createRef = (args) => {
+        return new ResourceRef(this, args);
+    };
+    getQueryCache(args) {
+        return this._queriesCache.getQueryCache(args);
+    }
+    createQueryCache(args) {
+        return this._queriesCache.createQueryCache(args, ResourceQueryState.create());
+    }
+    incrementLock(args, options) {
+        let cache = options?.cache ?? this.getQueryCache(args);
+        if (!cache) {
+            cache = this.createQueryCache(args);
+        }
+        cache.next(ResourceQueryState.incrementLock(cache.value));
+        return cache;
+    }
+    decrementLock(args, options) {
+        let cache = options?.cache ?? this.getQueryCache(args);
+        if (!cache) {
+            return null;
+        }
+        cache.next(ResourceQueryState.decrementLock(cache.value));
+        return cache;
+    }
+    updateData(args, updateFn, options) {
+        let cache = options?.cache ?? this.getQueryCache(args);
+        if (!cache) {
+            return null;
+        }
+        const cacheValue = cache.value;
+        if (!cacheValue.isDone) {
+            return cache;
+        }
+        const newData = updateFn(cacheValue.data);
+        cache.next(ResourceQueryState.setData(cache.value, newData));
+        return cache;
+    }
+    initiate(args, options) {
+        let cache = options?.cache ?? this._queriesCache.getQueryCache(args);
+        const state = ResourceQueryState.load(cache?.value, args);
+        if (!cache) {
+            cache = this._queriesCache.createQueryCache(args, state);
+        }
+        else {
+            cache.next(state);
+        }
+        let abortController = state.abortController;
+        abortController?.abort();
+        abortController = new AbortController();
+        const query = this._options.queryFn(args, { abortSignal: abortController.signal });
+        query
+            .then((data) => {
+            if (abortController.signal.aborted) {
+                return;
+            }
+            const selectedData = this._options.select ? this._options.select(data) : data;
+            cache.next(ResourceQueryState.success(state, selectedData));
+        })
+            .catch((error) => {
+            if (abortController.signal.aborted) {
+                return;
+            }
+            SharedOptions.onError?.(error);
+            cache.next(ResourceQueryState.error(state, error));
+        });
+        return cache;
+    }
+}

package/dist/query/core/Resource/ResourceAgent.d.ts

@@ -0,0 +1,34 @@
+import { Computed } from "../../../signal";
+import { ResourceAgentInstance, ResourceDefinition } from "../../../query/types/Resource.types";
+import type { Resource } from "./Resource";
+export declare class ResourceAgent<D extends ResourceDefinition> implements ResourceAgentInstance<D> {
+    private _resource;
+    private _resources$;
+    state$: Computed<{
+        isInitiated: boolean;
+        isLoading: boolean;
+        isDone: boolean;
+        isSuccess: boolean;
+        isError: boolean;
+        isLocked: boolean;
+        isReloading: boolean;
+        error: undefined;
+        data: undefined;
+        args: D["Args"];
+    } | {
+        isInitiated: boolean;
+        isLoading: boolean;
+        isDone: boolean;
+        isSuccess: boolean;
+        isError: boolean;
+        isLocked: boolean;
+        isReloading: boolean;
+        error: {} | undefined;
+        data: NonNullable<D["Data"]> | undefined;
+        args: NonNullable<D["Args"]> | undefined;
+    }>;
+    constructor(_resource: Resource<D>);
+    private _next;
+    initiate(args: D["Args"], force?: boolean): void;
+    createAgent: () => ResourceAgentInstance<D>;
+}

package/dist/query/core/Resource/ResourceAgent.js

@@ -0,0 +1,87 @@
+import { Computed, Signal } from "../../../signal";
+export class ResourceAgent {
+    _resource;
+    _resources$ = new Signal({
+        previous$: null,
+        current$: null,
+    });
+    state$ = new Computed(() => {
+        const resources = this._resources$.value;
+        let prevState;
+        const currState = resources.current$?.value;
+        if (!currState?.isDone) {
+            prevState = resources.previous$?.value;
+        }
+        // Нет текущего состояния — дефолт
+        if (!currState) {
+            return {
+                isInitiated: false,
+                isLoading: false,
+                isDone: false,
+                isSuccess: false,
+                isError: false,
+                isLocked: false,
+                isReloading: false,
+                error: undefined,
+                data: undefined,
+                args: undefined,
+            };
+        }
+        // Если идёт загрузка, но есть успешные данные из прошлого запроса — показываем их
+        const isShowPrev = currState.isLoading && prevState && prevState.isSuccess;
+        return {
+            isInitiated: currState.isInitiated || !!prevState,
+            isLoading: currState.isLoading,
+            isDone: currState.isDone,
+            isSuccess: currState.isSuccess,
+            isError: currState.isError,
+            isLocked: currState.isLocked,
+            isReloading: currState.isReloading,
+            error: isShowPrev ? prevState.error ?? undefined : currState.error ?? undefined,
+            data: isShowPrev ? prevState.data ?? undefined : currState.data ?? undefined,
+            args: currState.args ?? undefined,
+        };
+    });
+    constructor(_resource) {
+        this._resource = _resource;
+    }
+    _next(newCache) {
+        const { previous$, current$ } = this._resources$.value;
+        if (!current$) {
+            this._resources$.next({
+                previous$: null,
+                current$: newCache,
+            });
+            return;
+        }
+        if (!current$.value.isDone && previous$?.value.isDone) {
+            this._resources$.next({
+                previous$: previous$,
+                current$: newCache,
+            });
+            return;
+        }
+        this._resources$.next({
+            previous$: current$,
+            current$: newCache,
+        });
+    }
+    initiate(args, force = false) {
+        const current = this._resources$.value.current$;
+        const cache = this._resource.getQueryCache(args);
+        if (!cache) {
+            const newCache = this._resource.initiate(args);
+            this._next(newCache);
+            return;
+        }
+        if (force || !(cache.value.isDone || cache.value.isLoading)) {
+            this._resource.initiate(args, { cache });
+        }
+        if (current !== cache) {
+            this._next(cache);
+        }
+    }
+    createAgent = () => {
+        return this;
+    };
+}

package/dist/query/core/Resource/ResourceRef.d.ts

@@ -0,0 +1,18 @@
+import { Resource } from "./Resource";
+import { ResourceDefinition, ResourceRefInstanse } from "../../types/Resource.types";
+export declare class ResourceRef<D extends ResourceDefinition> implements ResourceRefInstanse<D> {
+    private readonly _resource;
+    private readonly _args;
+    private _cacheItem;
+    constructor(_resource: Resource<D>, _args: D["Args"]);
+    get has(): boolean;
+    lock(): {
+        unlock: () => void;
+    };
+    unlockOne(): void;
+    update(updateFn: (data: D["Data"]) => D["Data"]): {
+        rollback: () => void;
+    };
+    create(data: D["Data"]): void;
+    invalidate(): void;
+}

package/dist/query/core/Resource/ResourceRef.js

@@ -0,0 +1,52 @@
+export class ResourceRef {
+    _resource;
+    _args;
+    _cacheItem = null;
+    constructor(_resource, _args) {
+        this._resource = _resource;
+        this._args = _args;
+    }
+    get has() {
+        if (this._cacheItem)
+            return true;
+        this._cacheItem = this._resource.getQueryCache(this._args) ?? null;
+        return !!this._cacheItem;
+    }
+    lock() {
+        this._cacheItem = this._resource.incrementLock(this._args, { cache: this._cacheItem ?? undefined });
+        let isLocked = true;
+        return {
+            unlock: () => {
+                if (!isLocked)
+                    return;
+                isLocked = false;
+                this._resource.decrementLock(this._args, { cache: this._cacheItem });
+            }
+        };
+    }
+    unlockOne() {
+        this._cacheItem = this._resource.decrementLock(this._args, { cache: this._cacheItem });
+    }
+    update(updateFn) {
+        const cacheItem = this._cacheItem ?? this._resource.getQueryCache(this._args);
+        if (!cacheItem) {
+            console.warn('Trying to update non-existing cache item');
+            return {
+                rollback: () => { }
+            };
+        }
+        const value = cacheItem.value;
+        this._resource.updateData(this._args, updateFn, { cache: cacheItem });
+        return {
+            rollback: () => {
+                this._resource.updateData(this._args, () => value.data, { cache: cacheItem });
+            }
+        };
+    }
+    create(data) {
+        throw new Error("Method not implemented.");
+    }
+    invalidate() {
+        throw new Error("Method not implemented.");
+    }
+}

package/dist/query/core/SharedOptions.d.ts

@@ -0,0 +1,5 @@
+import { Devtools } from '@reatom/devtools';
+export declare class SharedOptions {
+    static DEVTOOLS: Devtools | null;
+    static onError: ((error: unknown) => void) | null;
+}

package/dist/query/core/SharedOptions.js

@@ -0,0 +1,4 @@
+export class SharedOptions {
+    static DEVTOOLS = null;
+    static onError = null;
+}

package/dist/query/index.d.ts

@@ -0,0 +1,7 @@
+export * from './api/createResource';
+export * from './api/createOperation';
+export * from './api/DefaultOptions';
+export * from './api/createDevtools';
+export * from './SKIP_TOKEN';
+export * from './react/useResourceAgent';
+export * from './react/useOperationAgent';

package/dist/query/index.js

@@ -0,0 +1,7 @@
+export * from './api/createResource';
+export * from './api/createOperation';
+export * from './api/DefaultOptions';
+export * from './api/createDevtools';
+export * from './SKIP_TOKEN';
+export * from './react/useResourceAgent';
+export * from './react/useOperationAgent';

package/dist/query/lib/IndirectMap.d.ts

@@ -0,0 +1,18 @@
+type CompareFn<T> = (a: T, b: T) => boolean;
+export declare class IndirectMap<KEY, VALUE> {
+    private _compareObjectsFn;
+    private _compareCache;
+    private _map;
+    constructor(_compareObjectsFn?: CompareFn<KEY>);
+    private _getCachedKey;
+    get(key: KEY): VALUE | undefined;
+    set(key: KEY, value: VALUE): void;
+    /**
+     * Удаляет элемент из кеша, не зависимо от того,
+     *  ссылается ли на него другой объект или нет
+     * @param key
+     */
+    delete(key: KEY): void;
+    has(key: KEY): boolean;
+}
+export {};

package/dist/query/lib/IndirectMap.js

@@ -0,0 +1,85 @@
+import { shallowEqual } from "../../query/lib/shallowEqual";
+export class IndirectMap {
+    _compareObjectsFn;
+    _compareCache = new WeakMap();
+    _map = new Map();
+    constructor(_compareObjectsFn = shallowEqual) {
+        this._compareObjectsFn = _compareObjectsFn;
+    }
+    _getCachedKey(key) {
+        const cachedKey = this._compareCache.get(key);
+        if (cachedKey) {
+            return cachedKey;
+        }
+        for (const cachedKey of this._map.keys()) {
+            if (this._compareObjectsFn(key, cachedKey)) {
+                this._compareCache.set(key, cachedKey);
+                return cachedKey;
+            }
+        }
+        return undefined;
+    }
+    get(key) {
+        const item = this._map.get(key);
+        if (!item) {
+            const isObject = typeof key === 'object' && key !== null;
+            if (!isObject) {
+                return undefined;
+            }
+            const cachedKey = this._getCachedKey(key);
+            if (!cachedKey) {
+                return undefined;
+            }
+            return this._map.get(cachedKey);
+        }
+        return item;
+    }
+    set(key, value) {
+        const has = this._map.has(key);
+        if (has) {
+            this._map.set(key, value);
+        }
+        else {
+            const isObject = typeof key === 'object' && key !== null;
+            if (!isObject) {
+                this._map.set(key, value);
+                return;
+            }
+            const cachedKey = this._getCachedKey(key);
+            if (cachedKey) {
+                this._map.set(cachedKey, value);
+            }
+            else {
+                this._map.set(key, value);
+                this._compareCache.set(key, key);
+            }
+        }
+    }
+    /**
+     * Удаляет элемент из кеша, не зависимо от того,
+     *  ссылается ли на него другой объект или нет
+     * @param key
+     */
+    delete(key) {
+        const isObject = typeof key === 'object' && key !== null;
+        if (isObject) {
+            const cachedKey = this._getCachedKey(key);
+            if (cachedKey) {
+                this._map.delete(cachedKey);
+                this._compareCache.delete(key);
+            }
+        }
+        this._map.delete(key);
+    }
+    has(key) {
+        const has = this._map.has(key);
+        if (!has && typeof key === 'object' && key !== null) {
+            const cachedKey = this._getCachedKey(key);
+            if (!cachedKey) {
+                return false;
+            }
+            return this._map.has(cachedKey);
+        }
+        return has;
+    }
+}

package/dist/query/lib/ReactiveCache.d.ts

@@ -0,0 +1,77 @@
+import { Observable, Subject } from "rxjs";
+type Options<VALUE> = {
+    /**
+     * Начальное состояние кэша
+     */
+    initialState: VALUE;
+    /**
+     * Время жизни кэша в миллисекундах (пока нет подписок на кеш)
+     * @default 60_000 (1 минута)
+     */
+    cacheLifeTime?: number;
+};
+/**
+ * Класс `ReactiveCache` представляет собой реактивный кэш,
+ * который позволяет управлять состоянием и временем жизни кэшированных данных.
+ *
+ * @template VALUE Тип значения, хранимого в кэше.
+ */
+export declare class ReactiveCache<VALUE> {
+    /**
+     * Время жизни кэша в миллисекундах.
+     * Если значение больше 0, то кэш очищается через указанное время после отписки.
+     * @private
+     */
+    private readonly _cacheLifeTime;
+    /**
+     * Внутренний `BehaviorSubject`, хранящий текущее состояние кэша.
+     * @private
+     */
+    private _state$;
+    /**
+     * Текущее значение.
+     * @private
+     */
+    private _value;
+    /**
+     * Реактивное значене (Observable)
+     */
+    value$: Observable<VALUE>;
+    /**
+     * Значение без сайд-эффектов (для использования в DevTools)
+     */
+    spy$: Observable<VALUE>;
+    /**
+     * Subject, уведомляющий об очистке кэша.
+     */
+    onClean$: Subject<VALUE>;
+    /**
+     * Создает новый экземпляр `ReactiveCacheItem`.
+     *
+     * @param options Параметры для настройки элемента кэша.
+     * @param options.initialState Начальное состояние кэша.
+     * @param options.cacheLifeTime Время жизни кэша в миллисекундах (по умолчанию 60_000).
+     */
+    constructor(options: Options<VALUE>);
+    /**
+     * Возвращает текущее значение кэша.
+     * @returns {VALUE} Текущее значение кэша.
+     */
+    get value(): VALUE;
+    /**
+     * Возвращает текущее значение кэша.
+     * @returns {VALUE} Текущее значение кэша.
+     */
+    peek(): VALUE;
+    /**
+     * Устанавливает новое значение в кэш и обновляет поток состояния.
+     *
+     * @param value Новое значение для кэша.
+     */
+    next(value: VALUE): void;
+    /**
+     * Завершает работу кэша, закрывая все потоки и уведомляя об очистке.
+     */
+    complete(): void;
+}
+export {};

package/dist/query/lib/ReactiveCache.js

@@ -0,0 +1,96 @@
+import { finalize, ReplaySubject, share, Subject, takeUntil, timer } from "rxjs";
+import { Signal } from "../../signal";
+/**
+ * Класс `ReactiveCache` представляет собой реактивный кэш,
+ * который позволяет управлять состоянием и временем жизни кэшированных данных.
+ *
+ * @template VALUE Тип значения, хранимого в кэше.
+ */
+export class ReactiveCache {
+    /**
+     * Время жизни кэша в миллисекундах.
+     * Если значение больше 0, то кэш очищается через указанное время после отписки.
+     * @private
+     */
+    _cacheLifeTime;
+    /**
+     * Внутренний `BehaviorSubject`, хранящий текущее состояние кэша.
+     * @private
+     */
+    _state$;
+    /**
+     * Текущее значение.
+     * @private
+     */
+    _value;
+    /**
+     * Реактивное значене (Observable)
+     */
+    value$;
+    /**
+     * Значение без сайд-эффектов (для использования в DevTools)
+     */
+    spy$;
+    /**
+     * Subject, уведомляющий об очистке кэша.
+     */
+    onClean$ = new Subject();
+    /**
+     * Создает новый экземпляр `ReactiveCacheItem`.
+     *
+     * @param options Параметры для настройки элемента кэша.
+     * @param options.initialState Начальное состояние кэша.
+     * @param options.cacheLifeTime Время жизни кэша в миллисекундах (по умолчанию 60_000).
+     */
+    constructor(options) {
+        this._cacheLifeTime = options.cacheLifeTime || 60_000;
+        this._state$ = new Signal(options.initialState);
+        this._value = options.initialState;
+        this.spy$ = this._state$.pipe(takeUntil(this.onClean$));
+        this.value$ = this._state$.pipe(finalize(() => {
+            this.complete();
+        }), share({
+            connector: () => new ReplaySubject(1),
+            /**
+             * Если lifetime больше 0,
+             * то очистим кэш значения по истечении этого времени,
+             * иначе очищаем сразу после отписки.
+             */
+            resetOnRefCountZero: this._cacheLifeTime > 0
+                ? () => timer(this._cacheLifeTime)
+                : true,
+            resetOnComplete: true,
+        }));
+    }
+    /**
+     * Возвращает текущее значение кэша.
+     * @returns {VALUE} Текущее значение кэша.
+     */
+    get value() {
+        return this._state$.value;
+    }
+    /**
+     * Возвращает текущее значение кэша.
+     * @returns {VALUE} Текущее значение кэша.
+     */
+    peek() {
+        return this._value;
+    }
+    /**
+     * Устанавливает новое значение в кэш и обновляет поток состояния.
+     *
+     * @param value Новое значение для кэша.
+     */
+    next(value) {
+        this._value = value;
+        this._state$.next(value);
+    }
+    /**
+     * Завершает работу кэша, закрывая все потоки и уведомляя об очистке.
+     */
+    complete() {
+        this._state$.complete();
+        this.onClean$.next(this._value);
+        this.onClean$.complete();
+    }
+}

package/dist/query/lib/shallowEqual.d.ts

@@ -0,0 +1 @@
+export declare function shallowEqual(a: unknown, b: unknown): boolean;

package/dist/query/lib/shallowEqual.js

@@ -0,0 +1,21 @@
+export function shallowEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+        return false;
+    }
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (let i = 0; i < keysA.length; i++) {
+        const key = keysA[i];
+        // @ts-ignore
+        if (!Object.prototype.hasOwnProperty.call(b, key) || a[key] !== b[key]) {
+            return false;
+        }
+    }
+    return true;
+}