reactronic 0.22.308 → 0.22.309

package/build/dist/source/impl/Operation.d.ts

@@ -0,0 +1,93 @@
+import { F } from '../util/Utils';
+import { MemberOptions } from '../Options';
+import { Controller } from '../Controller';
+import { MemberName, ObjectHandle, Subscription, Subscriber, SubscriptionInfo, AbstractChangeset } from './Data';
+import { Transaction } from './Transaction';
+import { OptionsImpl } from './Hooks';
+export declare class OperationController extends Controller<any> {
+    readonly objectHandle: ObjectHandle;
+    readonly memberName: MemberName;
+    configure(options: Partial<MemberOptions>): MemberOptions;
+    get options(): MemberOptions;
+    get nonreactive(): any;
+    get args(): ReadonlyArray<any>;
+    get result(): any;
+    get error(): boolean;
+    get stamp(): number;
+    get isUpToDate(): boolean;
+    markObsolete(): void;
+    pullLastResult(args?: any[]): any;
+    constructor(h: ObjectHandle, m: MemberName);
+    useOrRun(weak: boolean, args: any[] | undefined): Operation;
+    static of(method: F<any>): Controller<any>;
+    static configureImpl(self: OperationController | undefined, options: Partial<MemberOptions>): MemberOptions;
+    static runWithin<T>(op: Operation | undefined, func: F<T>, ...args: any[]): T;
+    static why(): string;
+    static briefWhy(): string;
+    static dependencies(): string[];
+    private peek;
+    private use;
+    private edit;
+    private acquireFromSnapshot;
+    private run;
+    private static markObsolete;
+}
+declare class Operation extends Subscription implements Subscriber {
+    static current?: Operation;
+    static queuedReactions: Array<Subscriber>;
+    static deferredReactions: Array<Operation>;
+    readonly margin: number;
+    readonly transaction: Transaction;
+    readonly controller: OperationController;
+    readonly changeset: AbstractChangeset;
+    subscriptions: Map<Subscription, SubscriptionInfo> | undefined;
+    options: OptionsImpl;
+    cause: string | undefined;
+    args: any[];
+    result: any;
+    error: any;
+    started: number;
+    obsoleteDueTo: string | undefined;
+    obsoleteSince: number;
+    successor: Operation | undefined;
+    constructor(controller: OperationController, changeset: AbstractChangeset, former: Operation | OptionsImpl);
+    get isOperation(): boolean;
+    get originSnapshotId(): number;
+    hint(): string;
+    get order(): number;
+    get ['#this'](): string;
+    why(): string;
+    briefWhy(): string;
+    dependencies(): string[];
+    wrap<T>(func: F<T>): F<T>;
+    run(proxy: any, args: any[] | undefined): void;
+    markObsoleteDueTo(subscription: Subscription, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactions: Subscriber[]): void;
+    runIfNotUpToDate(now: boolean, nothrow: boolean): void;
+    isNotUpToDate(): boolean;
+    reenterOver(head: Operation): this;
+    private static run;
+    private enter;
+    private leaveOrAsync;
+    private leave;
+    private monitorEnter;
+    private monitorLeave;
+    private addToDeferredReactions;
+    private static processDeferredReactions;
+    private static markUsed;
+    private static markEdited;
+    private static isConflicting;
+    private static propagateAllChangesThroughSubscriptions;
+    private static revokeAllSubscriptions;
+    private static propagateMemberChangeThroughSubscriptions;
+    private static enqueueReactionsToRun;
+    private static runQueuedReactionsLoop;
+    private unsubscribeFromAllSubscriptions;
+    private subscribeTo;
+    private static canSubscribe;
+    private static createOperation;
+    private static rememberOperationOptions;
+    static init(): void;
+}
+export declare function resolveReturn(value: any): any;
+export declare function rejectRethrow(error: any): never;
+export {};