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

Reactive state without boilerplate

import { ErrorHandler, InjectionToken } from "@angular/core";
import { Observable, OperatorFunction, Subject, Subscription } from "rxjs";
import { ActionMetadata, EventType, StoreConfig, StoreEvent } from "./interfaces";
import * as i0 from "@angular/core";
export declare const ACTION: InjectionToken<ActionMetadata>;
export declare const CONTEXT: InjectionToken<{
    instance: unknown;
}>;
export declare const STORE_CONFIG: InjectionToken<StoreConfig>;
export declare const ROOT_CONFIG: InjectionToken<StoreConfig>;
export declare const EVENTS: InjectionToken<Subject<StoreEvent<string, unknown, unknown, unknown>>>;
export declare class EventScheduler {
    private context;
    events: StoreEvent<any, any, any, any>[];
    dispatcher: Subject<StoreEvent<string, unknown, unknown, unknown>>;
    getId: () => number;
    schedule(type: EventType, name: string, value: unknown, changes: Map<any, any>): void;
    flush(): boolean;
    constructor(context: {});
}
export declare class EffectScheduler {
    source: Subject<Observable<any>>;
    queue: any[];
    operator?: OperatorFunction<Observable<any>, any>;
    connected: boolean;
    subscription: Subscription;
    pending: Set<unknown>;
    closed: boolean;
    next(source: Observable<any>): void;
    enqueue(source: Observable<any>): void;
    dequeue(): void;
    connect(): void;
    addPending(promise: Promise<any>): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EffectScheduler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EffectScheduler>;
}
export declare class Teardown {
    subscriptions: Subscription[];
    unsubscribe(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<Teardown, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Teardown>;
}
export declare class Changes {
    private target;
    get value(): any;
    constructor(target: any);
}
export declare class StoreErrorHandler implements ErrorHandler {
    private prototype;
    private instance;
    handleError(error: unknown): void;
    constructor(prototype: any, instance: any);
}