@antischematic/angular-state-library/transition.d.ts

Reactive state without boilerplate

/// <reference types="zone.js" />
import { InjectionToken } from "@angular/core";
import { BehaviorSubject, MonoTypeOperatorFunction, Observable, Observer, PartialObserver, Subject, Subscription } from "rxjs";
import { OnSelect } from "./select";
interface TransitionOptions {
    async?: boolean;
    slowMs?: number;
    timeoutMs?: number;
    resetOnSuccess?: boolean;
    cancelPrevious?: boolean;
}
export declare class TransitionSpec implements ZoneSpec {
    name: string;
    transition: Transition<any>;
    microtasks: number;
    macroTasks: number;
    parentZone: Zone;
    tasks: Set<Task>;
    timeout: any;
    properties: {
        id: number;
    };
    onScheduleTask(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task): Task;
    onInvokeTask(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task, applyThis: any, applyArgs?: any[]): any;
    onCancelTask(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task): any;
    onHasTask(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, hasTaskState: HasTaskState): void;
    onHandleError(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, error: any): boolean;
    cancelTasks(): void;
    constructor(name: string, transition: Transition<any>);
}
export declare class Transition<T = unknown> implements OnSelect {
    private options;
    private readonly spec;
    private readonly emitter;
    readonly timeoutMs: number;
    readonly slowMs: number;
    readonly resetOnSuccess: boolean;
    readonly isUnstable: BehaviorSubject<boolean>;
    readonly isSlow: BehaviorSubject<boolean>;
    readonly onError: Subject<unknown>;
    timeout: boolean;
    failed: boolean;
    retryCount: number;
    thrownError: unknown;
    get stable(): boolean;
    get unstable(): boolean;
    get slow(): boolean;
    next(value: T): void;
    error(error: unknown): void;
    complete(): void;
    emit(value: T): Observable<true>;
    cancel(): void;
    subscribe(next: (value: T) => void): Subscription;
    subscribe(observer?: Partial<Observer<T>>): Subscription;
    run<T extends (...args: any[]) => any>(fn: Function, applyThis?: {}, ...applyArgs: Parameters<T>): ReturnType<T>;
    ngOnSelect(observer: PartialObserver<any>): Subscription;
    constructor(options?: TransitionOptions);
}
export interface UseTransitionOptions {
    emit: boolean;
}
export declare function useTransition<T>(transition?: Transition<T>, options?: {
    emit: true;
}): MonoTypeOperatorFunction<T>;
export declare function useTransition<T>(transition?: Transition, options?: {
    emit: false;
}): MonoTypeOperatorFunction<T>;
interface TransitionToken {
    new <T>(name: string, options?: TransitionOptions): InjectionToken<Transition<T>>;
}
export declare const TransitionToken: TransitionToken;
export {};