@openglobus/og 0.17.2 → 0.18.1

package/lib/js/utils/FontAtlas.d.ts

@@ -0,0 +1,82 @@
+import { Deferred } from '../Deferred';
+import { Rectangle } from '../Rectangle';
+import { TextureAtlas, TextureAtlasNode } from './TextureAtlas';
+import { Handler } from "../webgl/Handler";
+import { HTMLImageElementExt } from "./ImagesCacheManager";
+interface IChar {
+    id: number;
+    char: string;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    chnl: number;
+    index: number;
+    page: number;
+    xadvance: number;
+    xoffset: number;
+    yoffset: number;
+}
+interface IKerning {
+    first: number;
+    second: number;
+    amount: number;
+}
+export interface IFontParams {
+    common: {
+        scaleH: number;
+        scaleW: number;
+    };
+    info: {
+        size: number;
+    };
+    distanceField: {
+        distanceRange: number;
+    };
+    chars: IChar[];
+    kernings: IKerning[];
+    pages: string[];
+}
+declare class FontTextureAtlas extends TextureAtlas {
+    width: number;
+    height: number;
+    gliphSize: number;
+    distanceRange: number;
+    nodes: Map<number, FontTextureAtlasNode>;
+    kernings: Record<number, Record<number, number>>;
+    constructor(width?: number, height?: number);
+    get(key: number): FontTextureAtlasNode | undefined;
+}
+interface IMetrics extends IChar {
+    nChar: string;
+    nCode: number;
+    nWidth: number;
+    nHeight: number;
+    nAdvance: number;
+    nXOffset: number;
+    nYOffset: number;
+}
+declare class FontTextureAtlasNode extends TextureAtlasNode {
+    metrics: IMetrics;
+    emptySize: number;
+    constructor(rect: Rectangle, texCoords: number[]);
+}
+declare class FontAtlas {
+    atlasesArr: FontTextureAtlas[];
+    samplerArr: Uint32Array;
+    sdfParamsArr: Float32Array;
+    catalogSrc: string;
+    protected atlasIndexes: Record<string, number>;
+    protected atlasIndexesDeferred: Record<string, Deferred<number>>;
+    protected tokenImageSize: number;
+    protected _handler: Handler | null;
+    constructor(catalogSrc?: string);
+    assignHandler(handler: Handler): void;
+    getFontIndex(face: string): Promise<number>;
+    getFullIndex(face: string): string;
+    protected _applyFontDataToAtlas(atlas: FontTextureAtlas, data: IFontParams, index?: number): void;
+    initFont(faceName: string, dataJson: IFontParams, imageBase64: string): void;
+    protected _createTexture(atlas: FontTextureAtlas, img: HTMLImageElementExt): void;
+    loadFont(faceName: string, srcDir: string, atlasUrl: string): void;
+}
+export { FontAtlas };

package/lib/js/utils/FontAtlas.js

@@ -0,0 +1,220 @@
+import { Deferred } from '../Deferred';
+import { Rectangle } from '../Rectangle';
+import { TextureAtlas, TextureAtlasNode } from './TextureAtlas';
+//@todo: get the value from shader module
+const MAX_SIZE = 11;
+class FontTextureAtlas extends TextureAtlas {
+    constructor(width, height) {
+        super(width, height);
+        this.width = 0;
+        this.height = 0;
+        this.gliphSize = 0;
+        this.distanceRange = 0;
+        this.nodes = new Map();
+        this.kernings = {};
+    }
+    get(key) {
+        return this.nodes.get(key);
+    }
+}
+class FontTextureAtlasNode extends TextureAtlasNode {
+    constructor(rect, texCoords) {
+        super(rect, texCoords);
+        this.emptySize = 1;
+        this.metrics = {
+            id: 0,
+            char: "",
+            width: 0,
+            height: 0,
+            x: 0,
+            y: 0,
+            chnl: 0,
+            index: 0,
+            page: 0,
+            xadvance: 0,
+            xoffset: 0,
+            yoffset: 0,
+            nChar: "",
+            nCode: 0,
+            nWidth: 0,
+            nHeight: 0,
+            nAdvance: 0,
+            nXOffset: 0,
+            nYOffset: 0
+        };
+    }
+}
+class FontAtlas {
+    constructor(catalogSrc) {
+        this.atlasesArr = [];
+        this.atlasIndexes = {};
+        this.atlasIndexesDeferred = {};
+        this.tokenImageSize = 64;
+        this.samplerArr = new Uint32Array(MAX_SIZE);
+        this.sdfParamsArr = new Float32Array(MAX_SIZE * 4);
+        this._handler = null;
+        this.catalogSrc = catalogSrc || "./";
+    }
+    assignHandler(handler) {
+        this._handler = handler;
+    }
+    getFontIndex(face) {
+        let fullName = this.getFullIndex(face);
+        // Try to load font from the directory
+        if (!this.atlasIndexes[fullName]) {
+            this.loadFont(fullName, this.catalogSrc, `${fullName}.json`);
+        }
+        if (!this.atlasIndexesDeferred[fullName]) {
+            this.atlasIndexesDeferred[fullName] = new Deferred();
+        }
+        return this.atlasIndexesDeferred[fullName].promise;
+    }
+    getFullIndex(face) {
+        return face.trim().toLowerCase();
+    }
+    _applyFontDataToAtlas(atlas, data, index = 0) {
+        let chars = data.chars;
+        atlas.height = data.common.scaleH;
+        atlas.width = data.common.scaleW;
+        atlas.gliphSize = data.info.size;
+        atlas.distanceRange = data.distanceField.distanceRange;
+        let w = atlas.width, h = atlas.height, s = atlas.gliphSize;
+        this.sdfParamsArr[index * 4] = w;
+        this.sdfParamsArr[index * 4 + 1] = h;
+        this.sdfParamsArr[index * 4 + 2] = s;
+        this.sdfParamsArr[index * 4 + 3] = atlas.distanceRange;
+        let idToChar = {};
+        for (let i = 0; i < chars.length; i++) {
+            let ci = chars[i];
+            let ti = ci.char;
+            idToChar[ci.id] = ti;
+            let r = new Rectangle(ci.x, ci.y, ci.x + ci.width, ci.y + ci.height);
+            let tc = new Array(12);
+            tc[0] = r.left / w;
+            tc[1] = r.top / h;
+            tc[2] = r.left / w;
+            tc[3] = r.bottom / h;
+            tc[4] = r.right / w;
+            tc[5] = r.bottom / h;
+            tc[6] = r.right / w;
+            tc[7] = r.bottom / h;
+            tc[8] = r.right / w;
+            tc[9] = r.top / h;
+            tc[10] = r.left / w;
+            tc[11] = r.top / h;
+            let taNode = new FontTextureAtlasNode(r, tc);
+            let ciNorm = ci.char.normalize('NFKC');
+            let ciCode = ciNorm.charCodeAt(0);
+            //taNode.metrics = ci;
+            let m = taNode.metrics;
+            m.id = ci.id;
+            m.char = ci.char;
+            m.width = ci.width;
+            m.height = ci.height;
+            m.x = ci.x;
+            m.y = ci.y;
+            m.chnl = ci.chnl;
+            m.index = ci.index;
+            m.page = ci.page;
+            m.xadvance = ci.xadvance;
+            m.xoffset = ci.xoffset;
+            m.yoffset = ci.yoffset;
+            m.nChar = ciNorm;
+            m.nCode = ciCode;
+            m.nWidth = taNode.metrics.width / s;
+            m.nHeight = taNode.metrics.height / s;
+            m.nAdvance = taNode.metrics.xadvance / s;
+            m.nXOffset = taNode.metrics.xoffset / s;
+            m.nYOffset = 1.0 - taNode.metrics.yoffset / s;
+            taNode.emptySize = 1;
+            atlas.nodes.set(ciNorm.charCodeAt(0), taNode);
+        }
+        atlas.kernings = {};
+        for (let i = 0; i < data.kernings.length; i++) {
+            let ki = data.kernings[i];
+            let first = ki.first, second = ki.second;
+            //let charFirst = idToChar[first],
+            //    charSecond = idToChar[second];
+            // if (!atlas.kernings[charFirst]) {
+            //     atlas.kernings[charFirst] = {};
+            // }
+            //
+            // atlas.kernings[charFirst][charSecond] = ki.amount / s;
+            if (!atlas.kernings[first]) {
+                atlas.kernings[first] = {};
+            }
+            atlas.kernings[first][second] = ki.amount / s;
+        }
+    }
+    initFont(faceName, dataJson, imageBase64) {
+        let index = this.atlasesArr.length;
+        let fullName = this.getFullIndex(faceName);
+        this.atlasIndexes[fullName] = index;
+        let def = this.atlasIndexesDeferred[fullName];
+        if (!def) {
+            def = this.atlasIndexesDeferred[fullName] = new Deferred();
+        }
+        this.samplerArr[this.atlasesArr.length] = index;
+        // TODO: FontTextureAtlas();
+        let atlas = new FontTextureAtlas();
+        atlas.height = 0;
+        atlas.width = 0;
+        atlas.gliphSize = 0;
+        atlas.distanceRange = 0;
+        atlas.kernings = {};
+        atlas.assignHandler(this._handler);
+        this.atlasesArr[index] = atlas;
+        this._applyFontDataToAtlas(atlas, dataJson, index);
+        let img = new Image();
+        img.onload = () => {
+            this._createTexture(atlas, img);
+            def.resolve(index);
+        };
+        img.src = imageBase64;
+    }
+    _createTexture(atlas, img) {
+        atlas.createTexture(img);
+    }
+    loadFont(faceName, srcDir, atlasUrl) {
+        let index = this.atlasesArr.length;
+        let fullName = this.getFullIndex(faceName);
+        this.atlasIndexes[fullName] = index;
+        let def = this.atlasIndexesDeferred[fullName];
+        if (!def) {
+            def = this.atlasIndexesDeferred[fullName] = new Deferred();
+        }
+        this.samplerArr[this.atlasesArr.length] = index;
+        // TODO: FontTextureAtlas();
+        let atlas = new FontTextureAtlas();
+        atlas.height = 0;
+        atlas.width = 0;
+        atlas.gliphSize = 0;
+        atlas.distanceRange = 0;
+        atlas.kernings = {};
+        atlas.assignHandler(this._handler);
+        this.atlasesArr[index] = atlas;
+        fetch(`${srcDir}/${atlasUrl}`)
+            .then((response) => {
+            if (!response.ok) {
+                throw Error(`Unable to load "${srcDir}/${atlasUrl}"`);
+            }
+            //return response.json(response);
+            return response.json();
+        })
+            .then((data) => {
+            this._applyFontDataToAtlas(atlas, data, index);
+            let img = new Image();
+            img.onload = () => {
+                this._createTexture(atlas, img);
+                def.resolve(index);
+            };
+            img.src = `${srcDir}/${data.pages[0]}`;
+            img.crossOrigin = "Anonymous";
+        })
+            .catch(err => {
+            def.reject();
+            return { 'status': "error", 'msg': err.toString() };
+        });
+    }
+}
+export { FontAtlas };

package/lib/js/utils/GeoImageCreator.d.ts

@@ -0,0 +1,34 @@
+import { BaseGeoImage } from "../layer/BaseGeoImage";
+import { Framebuffer } from '../webgl/Framebuffer';
+import { LonLat } from '../LonLat';
+import { Planet } from "../scene/Planet";
+import { WebGLBufferExt, WebGLTextureExt } from "../webgl/Handler";
+export declare class GeoImageCreator {
+    MAX_FRAMES: number;
+    protected _gridSize: number;
+    protected _planet: Planet;
+    _framebuffer: Framebuffer | null;
+    protected _framebufferMercProj: Framebuffer | null;
+    _texCoordsBuffer: WebGLBufferExt | null;
+    _indexBuffer: WebGLBufferExt | null;
+    protected _currentFrame: number;
+    protected _queue: BaseGeoImage[];
+    protected _animate: BaseGeoImage[];
+    protected _quadTexCoordsBuffer: WebGLBufferExt | null;
+    protected _quadVertexBuffer: WebGLTextureExt | null;
+    constructor(planet: Planet, maxFrames?: number);
+    init(): void;
+    /**
+     * Creates geoImage corners coordinates grid buffer.
+     * @public
+     * @param{Array.<LonLat>} c - GeoImage corners coordinates.
+     * @param{boolean} [toMerc=false] - Transform to web mercator.
+     * @return{WebGLBuffer} Grid coordinates buffer.
+     */
+    createGridBuffer(c: LonLat[], toMerc?: boolean): [WebGLBufferExt, WebGLBufferExt];
+    frame(): void;
+    add(geoImage: BaseGeoImage): void;
+    remove(geoImage: BaseGeoImage): void;
+    protected _initBuffers(): void;
+    protected _initShaders(): void;
+}

package/lib/js/utils/GeoImageCreator.js

@@ -0,0 +1,163 @@
+import * as utils from '../utils/shared';
+import { Framebuffer } from '../webgl/Framebuffer';
+import { LonLat } from '../LonLat';
+import { Program } from '../webgl/Program';
+import { doubleToTwoFloats2 } from "../math/coder";
+export class GeoImageCreator {
+    constructor(planet, maxFrames = 5) {
+        this.MAX_FRAMES = maxFrames;
+        this._gridSize = 64;
+        this._planet = planet;
+        this._framebuffer = null;
+        this._framebufferMercProj = null;
+        this._texCoordsBuffer = null;
+        this._indexBuffer = null;
+        this._currentFrame = 0;
+        this._queue = [];
+        this._animate = [];
+        this._quadTexCoordsBuffer = null;
+        this._quadVertexBuffer = null;
+    }
+    init() {
+        this._initShaders();
+        this._initBuffers();
+    }
+    /**
+     * Creates geoImage corners coordinates grid buffer.
+     * @public
+     * @param{Array.<LonLat>} c - GeoImage corners coordinates.
+     * @param{boolean} [toMerc=false] - Transform to web mercator.
+     * @return{WebGLBuffer} Grid coordinates buffer.
+     */
+    createGridBuffer(c, toMerc = false) {
+        let gs = this._gridSize;
+        let v03 = new LonLat((c[3].lon - c[0].lon) / gs, (c[3].lat - c[0].lat) / gs), v12 = new LonLat((c[2].lon - c[1].lon) / gs, (c[2].lat - c[1].lat) / gs), v01 = new LonLat((c[1].lon - c[0].lon) / gs, (c[1].lat - c[0].lat) / gs), v32 = new LonLat((c[2].lon - c[3].lon) / gs, (c[2].lat - c[3].lat) / gs);
+        const size = (gs + 1) * (gs + 1) * 2, halfSize = size / 2;
+        let gridHigh = new Float32Array(size), gridLow = new Float32Array(size);
+        let lonLatArr = new Array(halfSize);
+        let kh = 0, kl = 0, k = 0;
+        let tempArr = new Float32Array(2);
+        for (let i = 0; i <= gs; i++) {
+            let P03i = new LonLat(c[0].lon + i * v03.lon, c[0].lat + i * v03.lat), P12i = new LonLat(c[1].lon + i * v12.lon, c[1].lat + i * v12.lat);
+            for (let j = 0; j <= gs; j++) {
+                let P01j = new LonLat(c[0].lon + j * v01.lon, c[0].lat + j * v01.lat), P32j = new LonLat(c[3].lon + j * v32.lon, c[3].lat + j * v32.lat);
+                let xx = utils.getLinesIntersectionLonLat(P03i, P12i, P01j, P32j);
+                doubleToTwoFloats2(xx.lon, tempArr);
+                gridHigh[kh++] = tempArr[0];
+                gridLow[kl++] = tempArr[1];
+                doubleToTwoFloats2(xx.lat, tempArr);
+                gridHigh[kh++] = tempArr[0];
+                gridLow[kl++] = tempArr[1];
+                lonLatArr[k++] = xx;
+            }
+        }
+        if (toMerc) {
+            for (let i = 0; i < halfSize; i++) {
+                let c = lonLatArr[i].forwardMercator();
+                doubleToTwoFloats2(c.lon, tempArr);
+                gridHigh[i * 2] = tempArr[0];
+                gridLow[i * 2] = tempArr[1];
+                doubleToTwoFloats2(c.lat, tempArr);
+                gridHigh[i * 2 + 1] = tempArr[0];
+                gridLow[i * 2 + 1] = tempArr[1];
+            }
+        }
+        return [
+            this._planet.renderer.handler.createArrayBuffer(gridHigh, 2, halfSize),
+            this._planet.renderer.handler.createArrayBuffer(gridLow, 2, halfSize)
+        ];
+    }
+    frame() {
+        let i = this.MAX_FRAMES;
+        while (i-- && this._queue.length) {
+            const q = this._queue.shift();
+            q._isRendering = false;
+            q.rendering();
+            q.events.dispatch(q.events.loadend);
+        }
+        i = this._animate.length;
+        while (i--) {
+            this._animate[i].rendering();
+        }
+    }
+    add(geoImage) {
+        if (!geoImage._isRendering) {
+            geoImage._isRendering = true;
+            if (geoImage._animate) {
+                this._animate.push(geoImage);
+            }
+            else {
+                this._queue.push(geoImage);
+            }
+        }
+    }
+    remove(geoImage) {
+        if (geoImage._isRendering) {
+            geoImage._creationProceeding = false;
+            geoImage._isRendering = false;
+            let arr;
+            if (geoImage._animate) {
+                arr = this._animate;
+            }
+            else {
+                arr = this._queue;
+            }
+            for (let i = 0; i < arr.length; i++) {
+                if (arr[i].isEqual(geoImage)) {
+                    arr.splice(i, 1);
+                    return;
+                }
+            }
+        }
+    }
+    _initBuffers() {
+        let h = this._planet.renderer.handler;
+        this._framebuffer = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
+        this._framebuffer.init();
+        this._framebufferMercProj = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
+        this._framebufferMercProj.init();
+        let gs = Math.log2(this._gridSize);
+        this._texCoordsBuffer = this._planet._textureCoordsBufferCache[gs];
+        this._indexBuffer = this._planet._indexesCache[gs][gs][gs][gs][gs].buffer;
+        this._quadTexCoordsBuffer = h.createArrayBuffer(new Float32Array([0, 1, 1, 1, 0, 0, 1, 0]), 2, 4);
+        this._quadVertexBuffer = h.createArrayBuffer(new Float32Array([-1, 1, 1, 1, -1, -1, 1, -1]), 2, 4);
+    }
+    _initShaders() {
+        this._planet.renderer.handler.addProgram(new Program("geoImageTransform", {
+            uniforms: {
+                sourceTexture: "sampler2d",
+                extentParamsHigh: "vec4",
+                extentParamsLow: "vec4",
+                isFullExtent: "bool"
+            },
+            attributes: {
+                cornersHigh: "vec2",
+                cornersLow: "vec2",
+                texCoords: "vec2"
+            },
+            vertexShader: `attribute vec2 cornersHigh; 
+                     attribute vec2 cornersLow;
+                      attribute vec2 texCoords; 
+                      uniform vec4 extentParamsHigh; 
+                      uniform vec4 extentParamsLow; 
+                      varying vec2 v_texCoords;
+                      void main() {                                                             
+                          v_texCoords = texCoords; 
+                          vec2 highDiff = cornersHigh - extentParamsHigh.xy;
+                          vec2 lowDiff = cornersLow - extentParamsLow.xy;                                        
+                          gl_Position = vec4((-1.0 + (highDiff + lowDiff) * extentParamsHigh.zw) * vec2(1.0, -1.0), 0.0, 1.0); 
+                      }`,
+            fragmentShader: `precision highp float;
+                        uniform sampler2D sourceTexture;
+                        uniform bool isFullExtent;
+                        varying vec2 v_texCoords;
+                        void main () {
+                            if(!isFullExtent && (v_texCoords.x <= 0.001 || v_texCoords.x >= 0.999 ||
+                                v_texCoords.y <= 0.001 || v_texCoords.y >= 0.999)) {
+                                discard;
+                            }
+                            gl_FragColor = texture2D(sourceTexture, v_texCoords);
+                        }`
+        }));
+    }
+}

package/lib/js/utils/ImagesCacheManager.d.ts

@@ -0,0 +1,22 @@
+import { QueueArray } from '../QueueArray';
+export type HTMLImageElementExt = HTMLImageElement & {
+    __nodeIndex?: number;
+    atlasWidth?: number;
+    atlasHeight?: number;
+};
+export type ImagesCacheManagerCallback = (image: HTMLImageElementExt) => void;
+interface IImagesCacheRequest {
+    "src": string;
+    "success": ImagesCacheManagerCallback;
+}
+declare class ImagesCacheManager {
+    imagesCache: Record<string, HTMLImageElementExt>;
+    protected _counter: number;
+    protected _pendingsQueue: QueueArray<IImagesCacheRequest>;
+    protected _imageIndexCounter: number;
+    constructor();
+    load(src: string, success: ImagesCacheManagerCallback): void;
+    protected _exec(req: IImagesCacheRequest): void;
+    protected _dequeueRequest(): void;
+}
+export { ImagesCacheManager };

package/lib/js/utils/ImagesCacheManager.js

@@ -0,0 +1,63 @@
+import { QueueArray } from '../QueueArray';
+class ImagesCacheManager {
+    constructor() {
+        this.imagesCache = {};
+        this._counter = 0;
+        this._pendingsQueue = new QueueArray();
+        this._imageIndexCounter = 0;
+    }
+    load(src, success) {
+        if (this.imagesCache[src]) {
+            success(this.imagesCache[src]);
+        }
+        else {
+            let req = { "src": src, "success": success };
+            if (this._counter >= 1) {
+                this._pendingsQueue.unshift(req);
+            }
+            else {
+                this._exec(req);
+            }
+        }
+    }
+    _exec(req) {
+        this._counter++;
+        const that = this;
+        let img = new Image();
+        img.crossOrigin = '';
+        img.onload = function () {
+            that.imagesCache[req.src] = img;
+            img.__nodeIndex = that._imageIndexCounter++;
+            req.success(img);
+            that._dequeueRequest();
+        };
+        img.onerror = function () {
+            that._dequeueRequest();
+        };
+        img.src = req.src;
+    }
+    _dequeueRequest() {
+        this._counter--;
+        if (this._pendingsQueue.length && this._counter < 1) {
+            while (this._pendingsQueue.length) {
+                let req = this._pendingsQueue.pop();
+                if (req) {
+                    if (this.imagesCache[req.src]) {
+                        if (this._counter <= 0) {
+                            this._counter = 0;
+                        }
+                        else {
+                            this._counter--;
+                        }
+                        req.success(this.imagesCache[req.src]);
+                    }
+                    else {
+                        this._exec(req);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
+export { ImagesCacheManager };

package/lib/js/utils/Loader.d.ts

@@ -0,0 +1,63 @@
+import { EventsHandler } from '../Events';
+import { Planet } from "../scene/Planet";
+import { Segment } from "../segment/Segment";
+type LoaderEventsList = ["loadend", "layerloadend"];
+export interface IResponse {
+    status: string;
+    data?: any;
+    msg?: string;
+}
+type IResponseCallback = (response: IResponse) => void;
+interface Obj<T> {
+    __id: number;
+    isIdle: boolean;
+    isEqual: (obj: T) => boolean;
+    events: EventsHandler<any>;
+    _planet: Planet | null;
+}
+type QueryParams<T> = {
+    sender?: T;
+    src: string;
+    type: string;
+    filter?: (val: QueryParams<T>) => boolean;
+    options?: any;
+    segment?: Segment;
+};
+type QueueData<T> = {
+    params: QueryParams<T>;
+    callback: IResponseCallback;
+};
+type RequestCounter<T> = {
+    sender: T;
+    counter: number;
+    __requestCounterFrame__: number;
+};
+export declare class Loader<T extends Obj<T>> {
+    MAX_REQUESTS: number;
+    events: EventsHandler<LoaderEventsList>;
+    protected _loading: number;
+    protected _queue: QueueData<T>[];
+    protected _senderRequestCounter: RequestCounter<T>[];
+    protected _promises: {
+        [key: string]: (r: Response) => Promise<any>;
+    };
+    constructor(maxRequests?: number);
+    load(params: QueryParams<T>, callback: IResponseCallback): void;
+    fetch(params: QueryParams<T>): Promise<{
+        status: string;
+        data: any;
+    } | {
+        status: string;
+        msg: string;
+    }>;
+    getRequestCounter(sender: T): number;
+    isIdle(sender: T): boolean;
+    protected _checkLoadend(request: RequestCounter<T>, sender: T): void;
+    protected _handleResponse(q: QueueData<T>, response: IResponse): void;
+    protected _exec(): Promise<void> | undefined;
+    abort(sender: T): void;
+    abortAll(): void;
+    get loading(): number;
+    get queue(): QueueData<T>[];
+}
+export {};