@fozy-labs/rx-toolkit 0.4.1

package/dist/query/react/useOperationAgent.d.ts

@@ -0,0 +1,9 @@
+import { OperationAgentInstanse, OperationDefinition, OperationQueryState } from "../types/Operation.types";
+import { Prettify } from "../types/shared.types";
+type WithAgent<D extends OperationDefinition> = {
+    createAgent: () => OperationAgentInstanse<D>;
+};
+type TriggerFn<D extends OperationDefinition> = (args: D['Args']) => Promise<D['Data']>;
+type Result<D extends OperationDefinition> = [TriggerFn<D>, Prettify<OperationQueryState<D>>];
+export declare function useOperationAgent<D extends OperationDefinition>(op: WithAgent<D>): Result<D>;
+export {};

package/dist/query/react/useOperationAgent.js

@@ -0,0 +1,22 @@
+import { useConstant, useEventHandler, useSignal } from "../../react-hooks";
+export function useOperationAgent(op) {
+    const agent = useConstant(() => op.createAgent());
+    const state = useSignal(agent.state$);
+    const trigger = useEventHandler((args) => {
+        agent.initiate(args);
+        return new Promise((resolve, reject) => {
+            const sub = agent.state$.subscribe((s) => {
+                if (s.isDone && !s.isLoading) {
+                    sub.unsubscribe();
+                    if (s.isSuccess) {
+                        resolve(s.data);
+                    }
+                    else {
+                        reject(s.error);
+                    }
+                }
+            });
+        });
+    });
+    return [trigger, state];
+}

package/dist/query/react/useResourceAgent.d.ts

@@ -0,0 +1,9 @@
+import { ResourceAgentInstance, ResourceDefinition, ResourceQueryState } from "../types/Resource.types";
+import { Prettify } from "../types/shared.types";
+import { SKIP } from "../SKIP_TOKEN";
+type WithAgent<D extends ResourceDefinition> = {
+    createAgent: () => ResourceAgentInstance<D>;
+};
+type Result<D extends ResourceDefinition> = Prettify<ResourceQueryState<D>>;
+export declare function useResourceAgent<D extends ResourceDefinition>(res: WithAgent<D>, ...argss: D['Args'] extends void ? [] | [typeof SKIP] : [D['Args'] | typeof SKIP]): Result<D>;
+export {};

package/dist/query/react/useResourceAgent.js

@@ -0,0 +1,25 @@
+import React from "react";
+import { useConstant, useSignal } from "../../react-hooks";
+import { shallowEqual } from "../lib/shallowEqual";
+import { SKIP } from "../SKIP_TOKEN";
+export function useResourceAgent(res, ...argss) {
+    const args = (argss[0] === SKIP ? SKIP : argss[0]);
+    const agent = useConstant(() => {
+        const agent = res.createAgent();
+        if (args !== SKIP) {
+            agent.initiate(args);
+        }
+        return agent;
+    });
+    React.useEffect(() => {
+        if (args === SKIP) {
+            return;
+        }
+        const state = agent.state$.peek();
+        if (state.isInitiated && shallowEqual(args, state.args)) {
+            return;
+        }
+        agent.initiate(args);
+    }, [args]);
+    return useSignal(agent.state$);
+}

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

@@ -0,0 +1,91 @@
+import { ReadableSignalLike } from "../../signal";
+import { FallbackOnNever } from "../../query/types/shared.types";
+import { ResourceDefinition, ResourceInstance } from "./Resource.types";
+/**
+ * Функция создания операции
+ */
+export type OperationCreateFn<ARGS, RESULT, SELECTED = never> = (options: OperationCreateOptions<OperationDefinition<ARGS, RESULT, SELECTED>>) => OperationInstance<OperationDefinition<ARGS, RESULT, SELECTED>>;
+/**
+ * Опции создания операции
+ */
+export type OperationCreateOptions<D extends OperationDefinition> = {
+    /** Функция селектора для преобразования результата операции */
+    select?: (data: D["Result"]) => D["Selected"];
+    /** Функция выполнения операции */
+    queryFn: (args: D["Args"]) => Promise<D["Result"]>;
+    /** Связанные ресурсы */
+    link?: (link: <RD extends ResourceDefinition>(options: LinkOptions<D, RD>) => void) => void;
+};
+/**
+ * Настройки связи операции с ресурсом
+ */
+export type LinkOptions<D extends OperationDefinition, RD extends ResourceDefinition> = {
+    resource: ResourceInstance<RD>;
+    forwardArgs: (args: D["Args"]) => RD["Args"];
+    invalidate?: boolean;
+    lock?: boolean;
+    update?: (tools: {
+        draft: RD["Data"];
+        args: D["Args"];
+        data: D["Data"];
+    }) => void | RD["Data"] | Promise<RD["Data"]>;
+    optimisticUpdate?: (tools: {
+        draft: RD["Data"];
+        args: D["Args"];
+    }) => void | RD["Data"] | Promise<D["Data"]>;
+    create?: (tools: {
+        args: D["Args"];
+        data: D["Data"];
+    }) => RD["Data"] | Promise<RD["Data"]>;
+};
+/**
+ * Определение типов операции
+ */
+export type OperationDefinition<A = any, R = any, S = any> = {
+    Args: A;
+    Result: R;
+    Selected: S;
+    Data: FallbackOnNever<S, R>;
+};
+/**
+ * Экземпляр операции
+ */
+export type OperationInstance<D extends OperationDefinition> = {
+    /** Создает агента для выполнения операции */
+    createAgent(): OperationAgentInstanse<D>;
+    /**
+     * Выполняет операцию с указанными аргументами
+     * @deprecated
+     */
+    mutate: (args: D["Args"]) => Promise<D["Data"]>;
+};
+/**
+ * Агент для выполнения операции
+ */
+export type OperationAgentInstanse<D extends OperationDefinition> = {
+    /** Observable состояния выполнения операции */
+    state$: ReadableSignalLike<OperationQueryState<D>>;
+    /** Инициирует выполнение операции с указанными аргументами */
+    initiate(args: D["Args"]): void;
+    /** Создает новый агент операции */
+    createAgent(): OperationAgentInstanse<D>;
+};
+/**
+ * Состояние выполнения операции
+ */
+export type OperationQueryState<D extends OperationDefinition> = {
+    /** Выполняется ли операция в данный момент */
+    isLoading: boolean;
+    /** Завершена ли операция */
+    isDone: boolean;
+    /** Успешно ли завершена операция (false по умолчанию) */
+    isSuccess: boolean;
+    /** Произошла ли ошибка при выполнении операции (false по умолчанию) */
+    isError: boolean;
+    /** Оригинал ошибки, если есть */
+    error: unknown | undefined;
+    /** Результат выполнения операции */
+    data: D["Data"] | undefined;
+    /** Аргументы операции */
+    args: D["Args"];
+};

package/dist/query/types/Operation.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,90 @@
+import { ReadableSignalLike } from "../../signal";
+import { FallbackOnNever } from "../../query/types/shared.types";
+/**
+ * Функция создания ресурса
+ */
+export type ResourceCreateFn<ARGS, RESULT, SELECTED = never> = (options: ResourceCreateOptions<ResourceDefinition<ARGS, RESULT, SELECTED>>) => ResourceInstance<ResourceDefinition<ARGS, RESULT, SELECTED>>;
+/**
+ * Опции создания ресурса
+ */
+export type ResourceCreateOptions<D extends ResourceDefinition> = {
+    /** Функция селектора для преобразования данных */
+    select?: (data: D["Result"]) => D["Selected"];
+    /** Функция запроса данных */
+    queryFn: (args: D["Args"], tools: ResourceQueryFnTools) => Promise<D["Result"]>;
+};
+/**
+ * Определение типов ресурса
+ */
+export type ResourceDefinition<A = any, R = any, S = any> = {
+    Args: A;
+    Result: R;
+    Selected: S;
+    Data: FallbackOnNever<S, R>;
+};
+/** Инструменты для функции запроса */
+export type ResourceQueryFnTools = {
+    /** Сигнал для отмены запроса */
+    abortSignal?: AbortSignal;
+};
+/**
+ * Экземпляр ресурса
+ */
+export type ResourceInstance<D extends ResourceDefinition> = {
+    /** Создает агента для работы с ресурсом */
+    createAgent(): ResourceAgentInstance<D>;
+    /** Создает ссылку на ресурс с указанными аргументами */
+    createRef(args: D["Args"]): ResourceRefInstanse<D>;
+};
+/**
+ * Агент для работы с ресурсом
+ */
+export type ResourceAgentInstance<D extends ResourceDefinition> = {
+    /** Observable состояния запроса */
+    state$: ReadableSignalLike<ResourceQueryState<D>>;
+    /** Инициирует запрос с указанными аргументами */
+    initiate(args: D["Args"], force?: boolean): void;
+    /** Создает новый агент */
+    createAgent(): ResourceAgentInstance<D>;
+};
+/**
+ * Состояние запроса ресурса
+ */
+export type ResourceQueryState<D extends ResourceDefinition> = {
+    /** Инициализирован ли хотя бы один запрос */
+    isInitiated: boolean;
+    /** Первая загрузка */
+    isLoading: boolean;
+    /** Завершен ли запрос */
+    isDone: boolean;
+    /** Успешно ли завершен последний запрос (false по умолчанию) */
+    isSuccess: boolean;
+    /** Произошла ли ошибка последнего запроса (false по умолчанию) */
+    isError: boolean;
+    /** Заблокирован ли ресурс */
+    isLocked: boolean;
+    /** Перезагружается ли ресурс */
+    isReloading: boolean;
+    /** Оригинал ошибки, если есть */
+    error: unknown | undefined;
+    /** Данные, полученные в результате запроса (или select данных) */
+    data: D["Data"] | undefined;
+    /** Аргументы запроса */
+    args: D["Args"] | undefined;
+};
+/**
+ * Эте не ссылка в "классическом" понимании, а абстракция
+ * для работы с элементом кеша ресурса.
+ */
+export type ResourceRefInstanse<D extends ResourceDefinition> = {
+    get has(): boolean;
+    lock(): {
+        unlock: () => void;
+    };
+    unlockOne(): void;
+    update(updateFn: (data: D['Data']) => D['Data']): {
+        rollback: () => void;
+    };
+    invalidate(): void;
+    create(data: D['Data']): void;
+};

package/dist/query/types/Resource.types.js

@@ -0,0 +1 @@
+export {};

package/dist/query/types/shared.types.d.ts

@@ -0,0 +1,4 @@
+export type Prettify<T> = {
+    [KeyType in keyof T]: T[KeyType];
+} & {};
+export type FallbackOnNever<T, F> = [T] extends [never] ? F : T;

package/dist/query/types/shared.types.js

@@ -0,0 +1 @@
+export {};

package/dist/react-hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useSignal';
+export * from './useObservable';
+export * from './useSyncObservable';
+export * from './useEventHandler';
+export * from './useConstant';

package/dist/react-hooks/index.js

@@ -0,0 +1,5 @@
+export * from './useSignal';
+export * from './useObservable';
+export * from './useSyncObservable';
+export * from './useEventHandler';
+export * from './useConstant';

package/dist/react-hooks/useConstant.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hook like useMemo, but without unloading.
+ */
+export declare function useConstant<T>(fn: () => T, deps?: any[]): T;

package/dist/react-hooks/useConstant.js

@@ -0,0 +1,19 @@
+import React from 'react';
+/**
+ * Hook like useMemo, but without unloading.
+ */
+export function useConstant(fn, deps = []) {
+    const ref = React.useRef(null);
+    const depsRef = React.useRef(null);
+    if (ref.current === null) {
+        ref.current = { v: fn() };
+    }
+    if (depsRef.current === null) {
+        depsRef.current = deps;
+    }
+    if (depsRef.current.some((d, i) => d !== deps[i])) {
+        ref.current = { v: fn() };
+        depsRef.current = deps;
+    }
+    return ref.current.v;
+}

package/dist/react-hooks/useEventHandler.d.ts

@@ -0,0 +1 @@
+export declare function useEventHandler<T extends (...args: any[]) => any>(fn: T): T;

package/dist/react-hooks/useEventHandler.js

@@ -0,0 +1,6 @@
+import React from "react";
+export function useEventHandler(fn) {
+    const ref = React.useRef(fn);
+    ref.current = fn;
+    return React.useCallback((...args) => ref.current(...args), []);
+}

package/dist/react-hooks/useObservable.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+/**
+ * Hook for automatically subscribing and unsubscribing from an Observable.
+ * If the Observable synchronously returns a value, it returns it.
+ * Else returns initialValue.
+ * If the value of the Observable changes, it resubscribes.
+ * If a value equal to the previous one arrives in the Observable,
+ *   the previous value is returned without triggering a re-render.
+ * @param input$ Observable.
+ * @param initialValue Initial value that will be used before the Observable emits a value.
+ */
+export declare function useObservable<T>(input$: Observable<T>, initialValue: T): T;

package/dist/react-hooks/useObservable.js

@@ -0,0 +1,48 @@
+import React from 'react';
+import { useEventHandler } from "../react-hooks/useEventHandler";
+import { BehaviorSubject } from 'rxjs';
+import { useConstant } from "../react-hooks/useConstant";
+const NONE = Symbol('NONE');
+/**
+ * Hook for automatically subscribing and unsubscribing from an Observable.
+ * If the Observable synchronously returns a value, it returns it.
+ * Else returns initialValue.
+ * If the value of the Observable changes, it resubscribes.
+ * If a value equal to the previous one arrives in the Observable,
+ *   the previous value is returned without triggering a re-render.
+ * @param input$ Observable.
+ * @param initialValue Initial value that will be used before the Observable emits a value.
+ */
+export function useObservable(input$, initialValue) {
+    const { subject$, subscription } = useConstant(() => {
+        const subject = new BehaviorSubject(NONE);
+        /**
+         * Check if the Observable synchronously returns a value,
+         *  like BehaviorSubject or etc.
+         */
+        const subscription = input$
+            .subscribe((value) => subject.next(value));
+        return {
+            subject$: subject,
+            subscription,
+        };
+    }, [input$]);
+    React.useEffect(() => {
+        return () => {
+            subscription.unsubscribe();
+            subject$.complete();
+        };
+    }, [subject$]);
+    const subscribe = React.useCallback((updateStore) => {
+        const subjectSubscription = subject$.subscribe(updateStore);
+        return () => {
+            subjectSubscription.unsubscribe();
+        };
+    }, [input$, subject$]);
+    const getSnapshot = useEventHandler(() => subject$.getValue());
+    let value = React.useSyncExternalStore(subscribe, getSnapshot);
+    if (value === NONE) {
+        value = initialValue;
+    }
+    return value;
+}

package/dist/react-hooks/useSignal.d.ts

@@ -0,0 +1,2 @@
+import type { ReadableSignalLike } from "../signal/base/types";
+export declare function useSignal<T>(signal$: ReadableSignalLike<T>): T;

package/dist/react-hooks/useSignal.js

@@ -0,0 +1,12 @@
+import React from "react";
+import { useEventHandler } from "../react-hooks";
+export function useSignal(signal$) {
+    const subscribe = React.useCallback((update) => {
+        const subscription = signal$.subscribe(update);
+        return () => {
+            subscription.unsubscribe();
+        };
+    }, [signal$]);
+    const getSnapshot = useEventHandler(() => signal$.peek());
+    return React.useSyncExternalStore(subscribe, getSnapshot);
+}

package/dist/react-hooks/useSyncObservable.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+declare const NONE: unique symbol;
+/**
+ * Hook for automatically subscribing and unsubscribing from an Observable.
+ * If the Observable synchronously returns a value, it returns it.
+ * Else if initialValue is provided, it returns it.
+ * Else (if initialValue is NONE and the Observable does not synchronously return a value),
+ *   throws error.
+ * If the value of the Observable changes, it resubscribes.
+ * If a value equal to the previous one arrives in the Observable,
+ *   the previous value is returned without triggering a re-render.
+ * @param input$ Observable.
+ * @param initialValue Initial value that will be used before the Observable emits a value.
+ */
+export declare function useSyncObservable<T>(input$: Observable<T>, initialValue?: T | typeof NONE): T;
+export {};

package/dist/react-hooks/useSyncObservable.js

@@ -0,0 +1,52 @@
+import React from 'react';
+import { BehaviorSubject } from 'rxjs';
+import { useConstant, useEventHandler } from "../react-hooks";
+const NONE = Symbol('NONE');
+/**
+ * Hook for automatically subscribing and unsubscribing from an Observable.
+ * If the Observable synchronously returns a value, it returns it.
+ * Else if initialValue is provided, it returns it.
+ * Else (if initialValue is NONE and the Observable does not synchronously return a value),
+ *   throws error.
+ * If the value of the Observable changes, it resubscribes.
+ * If a value equal to the previous one arrives in the Observable,
+ *   the previous value is returned without triggering a re-render.
+ * @param input$ Observable.
+ * @param initialValue Initial value that will be used before the Observable emits a value.
+ */
+export function useSyncObservable(input$, initialValue = NONE) {
+    const { subject$, subscription } = useConstant(() => {
+        const subject = new BehaviorSubject(NONE);
+        /**
+         * Check if the Observable synchronously returns a value,
+         *  like BehaviorSubject or etc.
+         */
+        const subscription = input$
+            .subscribe((value) => subject.next(value));
+        return {
+            subject$: subject,
+            subscription,
+        };
+    }, [input$]);
+    React.useEffect(() => {
+        return () => {
+            subscription.unsubscribe();
+            subject$.complete();
+        };
+    }, [subject$]);
+    const subscribe = React.useCallback((updateStore) => {
+        const subjectSubscription = subject$.subscribe(updateStore);
+        return () => {
+            subjectSubscription.unsubscribe();
+        };
+    }, [input$, subject$]);
+    const getSnapshot = useEventHandler(() => subject$.getValue());
+    let value = React.useSyncExternalStore(subscribe, getSnapshot);
+    if (value === NONE) {
+        value = initialValue;
+    }
+    if (value === NONE) {
+        throw new Error('Observable did not return a value and no initial value provided');
+    }
+    return value;
+}

package/dist/signal/base/Batcher.d.ts

@@ -0,0 +1,7 @@
+import { BehaviorSubject } from "rxjs";
+export declare const Batcher: {
+    isLocked$: BehaviorSubject<boolean>;
+    lock(): void;
+    unlock(): void;
+    batch(fn: () => void): void;
+};

package/dist/signal/base/Batcher.js

@@ -0,0 +1,21 @@
+import { BehaviorSubject } from "rxjs";
+export const Batcher = {
+    isLocked$: new BehaviorSubject(false),
+    lock() {
+        if (this.isLocked$.value)
+            return;
+        this.isLocked$.next(true);
+    },
+    unlock() {
+        if (!this.isLocked$.value)
+            return;
+        this.isLocked$.next(false);
+    },
+    batch(fn) {
+        if (this.isLocked$.value)
+            return fn();
+        this.lock();
+        fn();
+        this.unlock();
+    },
+};

package/dist/signal/base/Computed.d.ts

@@ -0,0 +1,10 @@
+import { SubscriptionLike } from "rxjs";
+import { ReadableSignalLike } from "../../signal/base/types";
+import { Signal } from "./Signal";
+export declare class Computed<T> extends Signal<T> implements SubscriptionLike, ReadableSignalLike<T> {
+    private static _EMPTY;
+    private _effect;
+    constructor(computeFn: () => T, doLog?: boolean);
+    unsubscribe(): void;
+    complete(): void;
+}

package/dist/signal/base/Computed.js

@@ -0,0 +1,26 @@
+import { Signal } from "./Signal";
+import { Effect } from "./Effect";
+export class Computed extends Signal {
+    static _EMPTY = Symbol('empty');
+    _effect;
+    constructor(computeFn, doLog = false) {
+        let initialValue = Computed._EMPTY;
+        const effect = new Effect(() => {
+            if (initialValue === Computed._EMPTY) {
+                initialValue = computeFn();
+                return;
+            }
+            this.value = computeFn();
+        }, doLog);
+        super(initialValue);
+        this._effect = effect;
+    }
+    unsubscribe() {
+        this._effect.unsubscribe();
+        super.unsubscribe();
+    }
+    complete() {
+        this._effect.unsubscribe();
+        super.complete();
+    }
+}

package/dist/signal/base/Effect.d.ts

@@ -0,0 +1,12 @@
+import { SubscriptionLike } from "rxjs";
+export declare class Effect implements SubscriptionLike {
+    private _doLog;
+    closed: boolean;
+    private _subscriptions;
+    constructor(effectFn: (runInTrackedContext: (fn: () => void) => void) => void, _doLog?: boolean);
+    /**
+     * Выполняет функцию в tracked-контексте, подписываясь на Tracker.
+     */
+    private _runInTrackedContext;
+    unsubscribe(): void;
+}

package/dist/signal/base/Effect.js

@@ -0,0 +1,69 @@
+import { Batcher } from "../../signal/base/Batcher";
+import { Tracker } from "./Tracker";
+export class Effect {
+    _doLog;
+    closed = false;
+    _subscriptions = [];
+    constructor(effectFn, _doLog = false) {
+        this._doLog = _doLog;
+        if (this._doLog)
+            console.log("Run EffectFn. Reason: init");
+        this._runInTrackedContext(effectFn, false);
+    }
+    /**
+     * Выполняет функцию в tracked-контексте, подписываясь на Tracker.
+     */
+    _runInTrackedContext(effectFn, doUnsubscribe = true) {
+        // Отписываемся от предыдущих подписок
+        if (doUnsubscribe) {
+            this._subscriptions.forEach((sub) => sub.unsubscribe());
+            this._subscriptions = [];
+        }
+        let isTrackedContext = true;
+        let isWaitingBatching = false;
+        // Подписываемся на Tracker. Во время выполнения подпишемся на все tracked наблюдатели.
+        const trackerSub = Tracker.tracked$.subscribe((tracked$) => {
+            if (!isTrackedContext)
+                return;
+            this._subscriptions.push(tracked$.subscribe(() => {
+                if (isTrackedContext) {
+                    return;
+                }
+                if (isWaitingBatching) {
+                    if (this._doLog)
+                        console.log("Effect: still waiting for batching to finish", { tracked$ });
+                    return;
+                }
+                if (Batcher.isLocked$.value) {
+                    // console.log("Effect: waiting for batching to finish");
+                    isWaitingBatching = true;
+                    const sub = Batcher.isLocked$
+                        .subscribe((isLocked) => {
+                        if (isLocked)
+                            return;
+                        sub.unsubscribe();
+                        isWaitingBatching = false;
+                        if (this._doLog)
+                            console.log("Run EffectFn. Reason: tracked observable change after batching", { tracked$ });
+                        this._runInTrackedContext(effectFn);
+                    });
+                    return;
+                }
+                if (this._doLog)
+                    console.log("Run EffectFn. Reason: tracked observable change", { tracked$ });
+                this._runInTrackedContext(effectFn);
+            }));
+        });
+        effectFn((fn) => {
+            if (this._doLog)
+                console.log("Run EffectFn. Reason: manual trigger sub context");
+            this._runInTrackedContext(fn, false);
+        });
+        trackerSub.unsubscribe();
+        isTrackedContext = false;
+    }
+    unsubscribe() {
+        this.closed = true;
+        this._subscriptions.forEach((sub) => sub.unsubscribe());
+    }
+}

package/dist/signal/base/ReadonlySignal.d.ts

@@ -0,0 +1,12 @@
+import { Observable, Subscriber, TeardownLogic } from "rxjs";
+import { SyncObservable } from "./SyncObservable";
+import type { ReadableSignalLike } from "./types";
+export declare class ReadonlySignal<T> extends SyncObservable<T> implements ReadableSignalLike<T> {
+    constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
+    get value(): T;
+    peek(): T;
+    /**
+     * @deprecated
+     */
+    get(): T;
+}

package/dist/signal/base/ReadonlySignal.js

@@ -0,0 +1,20 @@
+import { SyncObservable } from "./SyncObservable";
+import { Tracker } from "./Tracker";
+export class ReadonlySignal extends SyncObservable {
+    constructor(subscribe) {
+        super(subscribe);
+    }
+    get value() {
+        Tracker.next(this);
+        return super.value;
+    }
+    peek() {
+        return super.value;
+    }
+    /**
+     * @deprecated
+     */
+    get() {
+        return this.value;
+    }
+}