import * as DG from 'datagrok-api/dg';
import { Unsubscribable } from 'rxjs';
import { LRUCache } from 'lru-cache';
import { ILogger } from './logger';
import { CellRendererBackBase } from './cell-renderer-back-base';
export declare class PropsBase {
    readonly backColor: number;
    readonly width: number;
    readonly height: number;
    constructor(backColor: number, width: number, height: number);
}
export declare class RenderTask<TProps extends PropsBase, TAux> {
    readonly name: string;
    readonly props: TProps;
    readonly onAfterRender: (canvas: HTMLCanvasElement, aux: TAux) => void;
    readonly isPriority?: (() => boolean) | undefined;
    constructor(name: string, props: TProps, onAfterRender: (canvas: HTMLCanvasElement, aux: TAux) => void, isPriority?: (() => boolean) | undefined);
}
type RenderQueueItem<TProps extends PropsBase, TAux> = {
    consumerId: number;
    key?: keyof any;
    task: RenderTask<TProps, TAux>;
    tryCount: number;
    dt: number;
};
export declare abstract class RenderServiceBase<TProps extends PropsBase, TAux> {
    protected readonly logger: ILogger;
    protected readonly retryLimit: number;
    protected _errorCount: number;
    protected readonly errorLimit: number;
    protected readonly taskTimout: number;
    protected readonly maxQueueSize: number;
    private consumerCounter;
    protected readonly _queue: RenderQueueItem<TProps, TAux>[];
    protected readonly _queueDict: {
        [key: keyof any]: RenderTask<TProps, TAux>;
    };
    /** The flag allows {@link _processQueue}() on add item to the queue with {@link render}() */
    private _busy;
    private _sweeperHandle;
    constructor(logger: ILogger, retryLimit?: number, _errorCount?: number, errorLimit?: number, taskTimout?: number, maxQueueSize?: number);
    private static viewerCounter;
    private readonly viewerId;
    protected toLog(): string;
    get errorCount(): number;
    /** Disposes MolstarViewer to free WebGL context */
    reset(): Promise<void>;
    /** Queues render tasks
     * @param consumerId   Identifier of the consumer of this render service
     * @param task         Task to render
     * @param key          Specify to skip previously queued tasks with the same key
     * @return             {@link consumerId} or assigned new if null
     */
    render(consumerId: number | null, task: RenderTask<TProps, TAux>, key?: keyof any, tryCount?: number): number;
    isBusy(consumerId: number): boolean;
    protected getTask(): RenderQueueItem<TProps, TAux> | undefined;
    private _processQueue;
    /** Sweep queue for stalled tasks */
    private _sweepQueue;
    private _sweepToggle;
    protected abstract requestRender(key: keyof any | undefined, task: RenderTask<TProps, TAux>, renderHandler: (aux: TAux) => void): Promise<[Unsubscribable, number, () => void]>;
    protected abstract onRendered(key: keyof any | undefined, task: RenderTask<TProps, TAux>, emptyCanvasHash: number, aux: TAux): boolean;
}
export declare abstract class CellRendererBackAsyncBase<TProps extends PropsBase, TAux> extends CellRendererBackBase<string> {
    readonly cacheEnabled: boolean;
    protected readonly taskQueueMap: Map<string, RenderTask<TProps, TAux>>;
    protected imageCache: LRUCache<string, ImageData, unknown>;
    protected get minWidth(): number;
    protected get minHeight(): number;
    /** Consumer identifier of the render service */
    protected consumerId: number | null;
    protected constructor(gridCol: DG.GridColumn | null, tableCol: DG.Column, logger: ILogger, cacheEnabled?: boolean);
    protected reset(): void;
    protected abstract getRenderService(): RenderServiceBase<TProps, TAux> | null;
    protected abstract getRenderTaskProps(gridCell: DG.GridCell, backColor: number, width: number, height: number): TProps;
    render(g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell, cellStyle: DG.GridCellStyle): void;
    /** Renders cell from image data (cache)
     * @param {CanvasRenderingContext2D} gCtx Grid canvas context
     * @param {DG.Rect} bd                    Bound rect to clip drawing
     * @param {DG.GridCell} gridCell          Grid cell to draw
     * @param {ImageData} cellImageData       Cell image data from cache
     * @return {boolean}                      true - cell is requiring update by render service
     */
    protected renderCellImageData(gCtx: CanvasRenderingContext2D, bd: DG.Rect, gCell: DG.GridCell, cellImageData: ImageData): boolean;
    protected abstract storeAux(gridCell: DG.GridCell, aux: TAux): void;
    /** Default implementation of rendering tree on grid cell
     * @param gCtx           Context to draw on grid
     * @param bd             Bound rect to clip drawing on task moment
     * @param gCell          Grid cell to draw
     * @param cellImageData  Image data of the cell to be drawn
     */
    protected renderOnGrid(gCtx: CanvasRenderingContext2D, bd: DG.Rect, gCell: DG.GridCell, cellImageData: ImageData): void;
}
export {};
//# sourceMappingURL=cell-renderer-async-base.d.ts.map