@fozy-labs/rx-toolkit 0.5.4 → 0.6.2

package/dist/query/core/Command/CommandAgent.js

@@ -1,54 +0,0 @@
-import { Computed, Signal } from "../../../signals";
-export class CommandAgent {
-    _command;
-    _commands$ = Signal.state({
-        current$: null,
-    }, { isDisabled: true });
-    state$ = Computed.create(() => {
-        const commands = this._commands$.get();
-        const currState = commands.current$?.value$.get();
-        // Нет текущего состояния — дефолт
-        if (!currState) {
-            return {
-                isLoading: false,
-                isDone: false,
-                isSuccess: false,
-                isError: false,
-                error: undefined,
-                data: undefined,
-                args: undefined,
-            };
-        }
-        return {
-            isLoading: currState.isLoading,
-            isDone: currState.isDone,
-            isSuccess: currState.isSuccess,
-            isError: currState.isError,
-            error: currState.error ?? undefined,
-            data: currState.data ?? undefined,
-            args: currState.arg,
-        };
-    }, { isDisabled: true });
-    constructor(_command) {
-        this._command = _command;
-    }
-    _next(newCache) {
-        this._commands$.set({
-            current$: newCache,
-        });
-    }
-    initiate(args) {
-        const cache = this._command.getQueryCache(args);
-        if (!cache) {
-            const newCache = this._command.initiate(args);
-            this._next(newCache);
-            return;
-        }
-        // Всегда запускаем команду заново, так как команды обычно не кэшируются как ресурсы
-        const newCache = this._command.initiate(args, { cache });
-        this._next(newCache);
-    }
-    createAgent() {
-        return new CommandAgent(this._command);
-    }
-}

package/dist/query/core/Command/index.d.ts

@@ -1,2 +0,0 @@
-export { Command } from "./Command";
-export { CommandAgent } from "./CommandAgent";

package/dist/query/core/Command/index.js

@@ -1,2 +0,0 @@
-export { Command } from "./Command";
-export { CommandAgent } from "./CommandAgent";

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

@@ -1,8 +0,0 @@
-/**
- * @deprecated Use `Command` from '../Command/Command' instead. Will be removed in v0.6.0.
- */
-export { Command as Operation } from "../Command/Command";
-/**
- * @deprecated Use `CoreCommandQueryState` from '../Command/Command' instead. Will be removed in v0.6.0.
- */
-export type { CoreCommandQueryState as CoreOperationQueryState } from "../Command/Command";

package/dist/query/core/Operation/Operation.js

@@ -1,4 +0,0 @@
-/**
- * @deprecated Use `Command` from '../Command/Command' instead. Will be removed in v0.6.0.
- */
-export { Command as Operation } from "../Command/Command";

package/dist/query/core/Operation/OperationAgent.d.ts

@@ -1,4 +0,0 @@
-/**
- * @deprecated Use `CommandAgent` from '../Command/CommandAgent' instead. Will be removed in v0.6.0.
- */
-export { CommandAgent as OperationAgent } from "../Command/CommandAgent";

package/dist/query/core/Operation/OperationAgent.js

@@ -1,4 +0,0 @@
-/**
- * @deprecated Use `CommandAgent` from '../Command/CommandAgent' instead. Will be removed in v0.6.0.
- */
-export { CommandAgent as OperationAgent } from "../Command/CommandAgent";

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

@@ -1,9 +0,0 @@
-import { ReactiveCache } from "../../query/lib/ReactiveCache";
-export declare class QueriesCache<KEY, VALUE> {
-    private _cacheLifeTime;
-    private readonly _cache;
-    constructor(_cacheLifeTime?: number | false, compareArgsFn?: (a: KEY, b: KEY) => boolean);
-    getQueryCache(args: KEY): ReactiveCache<VALUE> | undefined;
-    createQueryCache(args: KEY, initialState: VALUE): ReactiveCache<VALUE>;
-    values(): MapIterator<ReactiveCache<VALUE>>;
-}

package/dist/query/core/QueriesCache.js

@@ -1,28 +0,0 @@
-import { shallowEqual } from "../../common/utils";
-import { IndirectMap } from "../../query/lib/IndirectMap";
-import { ReactiveCache } from "../../query/lib/ReactiveCache";
-export class QueriesCache {
-    _cacheLifeTime;
-    _cache;
-    constructor(_cacheLifeTime = 60_000, compareArgsFn = shallowEqual) {
-        this._cacheLifeTime = _cacheLifeTime;
-        this._cache = new IndirectMap(compareArgsFn);
-    }
-    getQueryCache(args) {
-        return this._cache.get(args);
-    }
-    createQueryCache(args, initialState) {
-        const cache = new ReactiveCache({
-            initialState,
-            cacheLifeTime: this._cacheLifeTime,
-        });
-        cache.onClean$.subscribe(() => {
-            this._cache.delete(args);
-        });
-        this._cache.set(args, cache);
-        return cache;
-    }
-    values() {
-        return this._cache.values();
-    }
-}

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

@@ -1,22 +0,0 @@
-import { Subject } from "rxjs";
-import { OnCacheEntryAdded, OnQueryStarted } from "../../query/types";
-type Options<ARGS, DATA> = {
-    onCacheEntryAdded?: OnCacheEntryAdded<ARGS, DATA>;
-    onQueryStarted?: OnQueryStarted<ARGS, DATA>;
-    devtoolsName?: string | false;
-};
-export declare class QueriesLifetimeHooks<ARGS, DATA> {
-    private onCacheEntryAddedListeners;
-    private onQueryStartedListeners;
-    constructor(options: Options<ARGS, DATA> | undefined);
-    onCacheEntryAdded: (args: ARGS) => {
-        cacheDataLoaded: () => void;
-        cacheEntryRemoved: () => void;
-        dataChanged$: Subject<DATA>;
-    };
-    onQueryStarted: (args: ARGS) => {
-        fulfilledSuccess: (data: DATA) => void;
-        fulfilledError: (error: unknown) => void;
-    };
-}
-export {};

package/dist/query/core/QueriesLifetimeHooks.js

@@ -1,86 +0,0 @@
-import { Subject } from "rxjs";
-import { SharedOptions } from "../../common/options/SharedOptions";
-import { PromiseResolver } from "../../common/utils";
-import { Devtools } from "../../signals";
-export class QueriesLifetimeHooks {
-    onCacheEntryAddedListeners = [];
-    onQueryStartedListeners = [];
-    constructor(options) {
-        if (options?.onCacheEntryAdded) {
-            this.onCacheEntryAddedListeners.push(options.onCacheEntryAdded);
-        }
-        if (options?.onQueryStarted) {
-            this.onQueryStartedListeners.push(options.onQueryStarted);
-        }
-        const devtoolsName = options?.devtoolsName;
-        if (devtoolsName !== false && Devtools.hasDevtools) {
-            this.onCacheEntryAddedListeners.push(async (_, { $cacheEntryRemoved, dataChanged$ }) => {
-                let stateDevtools = null;
-                dataChanged$.subscribe((state) => {
-                    if (!stateDevtools) {
-                        stateDevtools = Devtools.createState(state, {
-                            base: "Queries",
-                            name: devtoolsName || "",
-                        });
-                        return;
-                    }
-                    stateDevtools(state);
-                });
-                $cacheEntryRemoved.then(() => {
-                    stateDevtools("$CLEANED");
-                });
-            });
-        }
-        if (SharedOptions.onQueryError) {
-            this.onQueryStartedListeners.push(async (_, { $queryFulfilled }) => {
-                const result = await $queryFulfilled;
-                if (result.isError)
-                    SharedOptions.onQueryError(result.error);
-            });
-        }
-    }
-    onCacheEntryAdded = (args) => {
-        const cacheDataLoadedResolver = new PromiseResolver();
-        const cacheEntryRemovedResolver = new PromiseResolver();
-        const dataChanged$ = new Subject(); // TODO не нравится мне это, мб передавать $spy в аргументы?
-        cacheEntryRemovedResolver.promise.finally(() => {
-            dataChanged$.complete();
-        });
-        this.onCacheEntryAddedListeners.forEach((listener) => {
-            listener(args, {
-                $cacheDataLoaded: cacheDataLoadedResolver.promise,
-                $cacheEntryRemoved: cacheEntryRemovedResolver.promise,
-                dataChanged$,
-            });
-        });
-        return {
-            cacheDataLoaded: () => cacheDataLoadedResolver.resolve(),
-            cacheEntryRemoved: () => cacheEntryRemovedResolver.resolve(),
-            dataChanged$,
-        };
-    };
-    onQueryStarted = (args) => {
-        const queryFulfilledResolver = new PromiseResolver();
-        this.onQueryStartedListeners.forEach((listener) => {
-            listener(args, {
-                $queryFulfilled: queryFulfilledResolver.promise,
-            });
-        });
-        return {
-            fulfilledSuccess: (data) => {
-                queryFulfilledResolver.resolve({
-                    data,
-                    error: undefined,
-                    isError: false,
-                });
-            },
-            fulfilledError: (error) => {
-                queryFulfilledResolver.resolve({
-                    data: undefined,
-                    error,
-                    isError: true,
-                });
-            },
-        };
-    };
-}

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

@@ -1,6 +0,0 @@
-import { Subject } from "rxjs";
-export declare class ResetAllQueriesSignal {
-    private static subject$;
-    static clean$: Subject<void>;
-    static clean(): void;
-}

package/dist/query/core/ResetAllQueriesSignal.js

@@ -1,11 +0,0 @@
-import { Subject } from "rxjs";
-import { Batcher } from "../../signals";
-export class ResetAllQueriesSignal {
-    static subject$ = new Subject();
-    static clean$ = ResetAllQueriesSignal.subject$;
-    static clean() {
-        Batcher.run(() => {
-            ResetAllQueriesSignal.subject$.next();
-        });
-    }
-}

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

@@ -1,51 +0,0 @@
-import { ReactiveCache } from "../../../query/lib/ReactiveCache";
-import type { ResourceCreateOptions, ResourceDefinition, ResourceInstance, ResourceRefInstance, ResourceTransaction } from "../../../query/types";
-import { ResourceAgent } from "./ResourceAgent";
-export type CoreResourceQueryState<D extends ResourceDefinition> = {
-    transactions: ResourceTransaction[] | null;
-    abortController: AbortController | null;
-    args: D["Args"];
-    savedData: D["Data"] | null;
-    data: D["Data"] | null;
-    error: unknown | null;
-    isError: boolean;
-    isLoading: boolean;
-    isReloading: boolean;
-    isDone: boolean;
-    isSuccess: boolean;
-    isLocked: boolean;
-    isInitiated: boolean;
-    lockCount: number;
-};
-export type CoreResourceQueryCache<D extends ResourceDefinition> = ReactiveCache<CoreResourceQueryState<D>>;
-export declare class Resource<D extends ResourceDefinition> implements ResourceInstance<D> {
-    private readonly _options;
-    private readonly _queriesCache;
-    private readonly _hooks;
-    private _DEFAULT_CACHE_LIFETIME;
-    constructor(_options: ResourceCreateOptions<D>);
-    createAgent: () => ResourceAgent<D>;
-    createRef: (args: D["Args"]) => ResourceRefInstance<D>;
-    getQueryCache(args: D["Args"]): CoreResourceQueryCache<D> | undefined;
-    createQueryCache(args: D["Args"], state?: CoreResourceQueryState<D>): CoreResourceQueryCache<D>;
-    incrementLock(args: D["Args"], options?: {
-        cache?: CoreResourceQueryCache<D>;
-    }): CoreResourceQueryCache<D>;
-    decrementLock(args: D["Args"], options?: {
-        cache?: CoreResourceQueryCache<D>;
-    }): CoreResourceQueryCache<D> | null;
-    update(args: D["Args"], updateFn: (data: D["Data"], savedData: D["Data"] | null, transactions: ResourceTransaction[] | null) => {
-        data: D["Data"];
-        transactions: ResourceTransaction[] | null;
-        savedData: D["Data"] | null;
-    }, options?: {
-        cache?: CoreResourceQueryCache<D>;
-    }): CoreResourceQueryCache<D> | null;
-    createWithData(args: D["Args"], data: D["Data"], options?: {
-        cache?: CoreResourceQueryCache<D>;
-    }): CoreResourceQueryCache<D>;
-    initiate(args: D["Args"], options?: {
-        cache?: CoreResourceQueryCache<D>;
-    }): CoreResourceQueryCache<D>;
-    compareArgs(args1: D["Args"], args2: D["Args"]): boolean;
-}

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

@@ -1,232 +0,0 @@
-import { SharedOptions } from "../../../common/options/SharedOptions";
-import { QueriesCache } from "../QueriesCache";
-import { QueriesLifetimeHooks } from "../QueriesLifetimeHooks";
-import { ResetAllQueriesSignal } from "../ResetAllQueriesSignal";
-import { ResourceAgent } from "./ResourceAgent";
-import { ResourceRef } from "./ResourceRef";
-class ResourceQueryState {
-    static create(args) {
-        return {
-            transactions: null,
-            savedData: null,
-            abortController: null,
-            args,
-            data: null,
-            error: null,
-            isError: false,
-            isReloading: false,
-            isDone: false,
-            isSuccess: false,
-            isLocked: false,
-            isLoading: false,
-            isInitiated: false,
-            lockCount: 0,
-        };
-    }
-    static load(state, args) {
-        state = state ?? ResourceQueryState.create(args);
-        return {
-            ...state,
-            abortController: new AbortController(),
-            args: args,
-            isLoading: !state.isDone,
-            isReloading: state.isDone,
-            isInitiated: true,
-        };
-    }
-    static success(state, data) {
-        return {
-            ...state,
-            abortController: null,
-            savedData: null,
-            transactions: null,
-            data,
-            isLoading: false,
-            isReloading: false,
-            isDone: true,
-            isSuccess: true,
-            isError: false,
-            error: null,
-        };
-    }
-    static error(state, error) {
-        return {
-            ...state,
-            abortController: null,
-            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 update(state, data, savedData, transactions) {
-        return {
-            ...state,
-            transactions,
-            savedData,
-            data,
-        };
-    }
-    static createWithData(data, args) {
-        return {
-            savedData: null,
-            transactions: null,
-            data,
-            isLoading: false,
-            isReloading: false,
-            isDone: true,
-            isSuccess: true,
-            isError: false,
-            error: null,
-            abortController: null,
-            args,
-            isInitiated: false,
-            isLocked: false,
-            lockCount: 0,
-        };
-    }
-}
-export class Resource {
-    _options;
-    _queriesCache;
-    _hooks;
-    _DEFAULT_CACHE_LIFETIME = 60_000;
-    constructor(_options) {
-        this._options = _options;
-        this._hooks = new QueriesLifetimeHooks({
-            onCacheEntryAdded: _options.onCacheEntryAdded,
-            onQueryStarted: _options.onQueryStarted,
-            devtoolsName: _options.devtoolsName,
-        });
-        this._queriesCache = new QueriesCache(_options.cacheLifetime ?? this._DEFAULT_CACHE_LIFETIME);
-        ResetAllQueriesSignal.clean$.subscribe(() => {
-            const caches = Array.from(this._queriesCache.values());
-            caches.forEach((cache) => {
-                cache.value.abortController?.abort();
-                cache.next(ResourceQueryState.create(cache.value.args));
-            });
-        });
-    }
-    createAgent = () => {
-        return new ResourceAgent(this);
-    };
-    createRef = (args) => {
-        return new ResourceRef(this, args);
-    };
-    getQueryCache(args) {
-        return this._queriesCache.getQueryCache(args);
-    }
-    createQueryCache(args, state = ResourceQueryState.create(args)) {
-        const cache = this._queriesCache.createQueryCache(args, state);
-        const hookResolvers = this._hooks.onCacheEntryAdded(args);
-        const spySub = cache.spy$.subscribe((state) => {
-            if (!state.isDone)
-                return;
-            hookResolvers.cacheDataLoaded();
-            spySub.unsubscribe();
-        });
-        cache.spy$.subscribe((data) => {
-            hookResolvers.dataChanged$.next(data);
-        });
-        cache.onClean$.subscribe(() => {
-            hookResolvers.cacheEntryRemoved();
-        });
-        return cache;
-    }
-    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) {
-        const cache = options?.cache ?? this.getQueryCache(args);
-        if (!cache) {
-            return null;
-        }
-        cache.next(ResourceQueryState.decrementLock(cache.value));
-        return cache;
-    }
-    update(args, updateFn, options) {
-        const cache = options?.cache ?? this.getQueryCache(args);
-        if (!cache) {
-            return null;
-        }
-        const cacheValue = cache.value;
-        if (!cacheValue.isDone) {
-            return cache;
-        }
-        const { data, transactions, savedData } = updateFn(cacheValue.data, cacheValue.savedData, cacheValue.transactions);
-        cache.next(ResourceQueryState.update(cache.value, data, savedData, transactions));
-        return cache;
-    }
-    createWithData(args, data, options) {
-        let cache = options?.cache ?? this.getQueryCache(args);
-        const state = ResourceQueryState.createWithData(data, args);
-        if (!cache) {
-            cache = this.createQueryCache(args, state);
-            // Только обновляем кэш новыми данными, если он еще не был инициализирован.
-            // Это предотвращает перезапись уже инициализированного кэша.
-        }
-        else if (!cache.value.isInitiated) {
-            cache.next(state);
-        }
-        return cache;
-    }
-    initiate(args, options) {
-        let cache = options?.cache ?? this.getQueryCache(args);
-        const prevAbortController = cache?.value.abortController ?? null;
-        const state = ResourceQueryState.load(cache?.value, args);
-        if (!cache) {
-            cache = this.createQueryCache(args, state);
-        }
-        else {
-            cache.next(state);
-        }
-        prevAbortController?.abort();
-        const abortController = state.abortController;
-        const query = this._options.queryFn(args, { abortSignal: abortController.signal });
-        const hookResolvers = this._hooks.onQueryStarted(args);
-        query
-            .then((result) => {
-            if (abortController.signal.aborted) {
-                return;
-            }
-            const data = this._options.select ? this._options.select(result) : result;
-            cache.next(ResourceQueryState.success(state, data));
-            hookResolvers.fulfilledSuccess(data);
-        })
-            .catch((error) => {
-            if (abortController.signal.aborted) {
-                return;
-            }
-            cache.next(ResourceQueryState.error(state, error));
-            hookResolvers.fulfilledError(error);
-        });
-        return cache;
-    }
-    compareArgs(args1, args2) {
-        const compareFn = this._options.compareArgsFn ?? SharedOptions.defaultCompareArgs;
-        return compareFn(args1, args2);
-    }
-}

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

@@ -1,35 +0,0 @@
-import { ResourceAgentInstance, ResourceDefinition } from "../../../query/types";
-import type { Resource } from "./Resource";
-export declare class ResourceAgent<D extends ResourceDefinition> implements ResourceAgentInstance<D> {
-    private _resource;
-    private _resources$;
-    state$: import("../../../signals").ComputeFn<{
-        isInitiated: boolean;
-        isLoading: boolean;
-        isInitialLoading: boolean;
-        isDone: boolean;
-        isSuccess: boolean;
-        isError: boolean;
-        isLocked: boolean;
-        isReloading: boolean;
-        error: undefined;
-        data: undefined;
-        args: D["Args"];
-    } | {
-        isInitiated: boolean;
-        isLoading: boolean;
-        isInitialLoading: 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>);
-    initiate(args: D["Args"], force?: boolean): void;
-    compareArgs(args: D["Args"], otherArgs: D["Args"]): boolean;
-    private _next;
-}