featurehub-javascript-client-sdk/dist/polling_sdk.d.ts

FeatureHub client/browser SDK

import { FeatureEnvironmentCollection } from './models';
import { EdgeService } from './edge_service';
import { FeatureHubConfig } from './feature_hub_config';
import { InternalFeatureRepository } from './internal_feature_repository';
export interface PollingService {
    get frequency(): number;
    poll(): Promise<void>;
    stop(): void;
    attributeHeader(header: string): Promise<void>;
    busy: boolean;
}
export type FeaturesFunction = (environments: Array<FeatureEnvironmentCollection>) => void;
export type PromiseLikeFunction = (value: void | PromiseLike<void>) => void;
export type RejectLikeFunction = (response?: any) => void;
interface PromiseLikeData {
    resolve: PromiseLikeFunction;
    reject: RejectLikeFunction;
}
export declare abstract class PollingBase implements PollingService {
    protected url: string;
    protected _frequency: number;
    protected _callback: FeaturesFunction;
    protected _stopped: boolean;
    protected _header?: string;
    protected _shaHeader: string;
    protected _etag: string | undefined | null;
    protected _busy: boolean;
    protected _outstandingPromises: Array<PromiseLikeData>;
    protected constructor(url: string, frequency: number, callback: FeaturesFunction);
    attributeHeader(header: string): Promise<void>;
    stop(): void;
    get frequency(): number;
    abstract poll(): Promise<void>;
    parseCacheControl(cacheHeader: string | undefined | null): void;
    protected delayTimer(): Promise<void>;
    get busy(): boolean;
    protected resolveOutstanding(): void;
    rejectOutstanding(result?: any): void;
}
export interface NodejsOptions {
    timeout?: number;
}
export interface BrowserOptions {
    timeout?: number;
}
export declare class BrowserPollingService extends PollingBase implements PollingService {
    private readonly _options;
    private localStorageLastUrl;
    static httpRequestor: () => XMLHttpRequest;
    static localStorageRequestor: () => Storage | {
        getItem: () => null;
        setItem: () => void;
    };
    constructor(options: BrowserOptions, url: string, frequency: number, callback: FeaturesFunction);
    private loadLocalState;
    poll(): Promise<void>;
}
export type PollingClientProvider = (options: BrowserOptions, url: string, frequency: number, callback: FeaturesFunction) => PollingService;
export declare class FeatureHubPollingClient implements EdgeService {
    private readonly _frequency;
    private readonly _url;
    private _repository;
    private _pollingService;
    private readonly _options;
    private _startable;
    private readonly _config;
    private _xHeader;
    private _pollPromiseResolve;
    private _pollPromiseReject;
    private _currentTimer;
    static pollingClientProvider: PollingClientProvider;
    constructor(repository: InternalFeatureRepository, config: FeatureHubConfig, frequency: number, options?: BrowserOptions | NodejsOptions);
    private _initService;
    contextChange(header: string): Promise<void>;
    clientEvaluated(): boolean;
    requiresReplacementOnHeaderChange(): boolean;
    close(): void;
    private stop;
    poll(): Promise<void>;
    get canStart(): boolean;
    get pollingFrequency(): undefined | number;
    get active(): boolean;
    get awaitingFirstSuccess(): boolean;
    private _restartTimer;
    private _pollFunc;
    private _readyNextPoll;
    private response;
}
export {};