@openglobus/og 0.19.4 → 0.20.1

package/lib/@openglobus/js/terrain/EmptyTerrain.d.ts

@@ -0,0 +1,113 @@
+import { TypedArray } from "../utils/shared";
+import { Geoid } from "./Geoid";
+import { LonLat } from "../LonLat";
+import { Planet } from "../scene/Planet";
+import { Segment } from "../segment/Segment";
+export interface IEmptyTerrainParams {
+    equalizeVertices?: boolean;
+    name?: string;
+    minZoom?: number;
+    maxZoom?: number;
+    maxNativeZoom?: number;
+    geoidSrc?: string;
+    geoid?: Geoid;
+    gridSizeByZoom?: number[];
+}
+export type UrlRewriteFunc = (tileX: number, tileY: number, tileZoom: number, tileGroup: number) => string | null | undefined;
+/**
+ * Class represents terrain provider without elevation data.
+ * @param {IEmptyTerrainParams} [options] - Provider options:
+ * @param {string} [options.name="empty"] - Provider name.
+ * @param {boolean} [options.equalizeVertices] -
+ * @param {number} [options.minZoom=2] - Minimal visible zoom index when terrain handler works.
+ * @param {number} [options.minZoom=50] - Maximal visible zoom index when terrain handler works.
+ * @param {number} [options.maxNativeZoom=19] - Maximal available terrain zoom level.
+ * @param {Array.<number>} [options.gridSizeByZoom] - Array of segment triangulation grid sizes where array index agreed to the segment zoom index.
+ * @param {Array.<number>} [gridSizeByZoom] - Array of values, where each value corresponds to the size of a tile(or segment) on the globe. Each value must be power of two.
+ * @param {Geoid} [options.geoid] -
+ * @param {string} [options.geoidSrc] -
+ */
+declare class EmptyTerrain {
+    static __counter__: number;
+    /**
+     * Uniq identifier.
+     * @public
+     * @type {number}
+     */
+    __id: number;
+    equalizeVertices: boolean;
+    equalizeNormals: boolean;
+    isEmpty: boolean;
+    /**
+     * Provider name is "empty"
+     * @public
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Minimal z-index value for segment elevation data handling.
+     * @public
+     * @type {number}
+     */
+    minZoom: number;
+    /**
+     * Maximal z-index value for segment elevation data handling.
+     * @public
+     * @type {number}
+     */
+    maxZoom: number;
+    noDataValues: number[];
+    /**
+     * Maximal existent available zoom
+     * @type {number}
+     */
+    maxNativeZoom: number;
+    /**
+     * @public
+     * @type {Array.<number>}
+     */
+    gridSizeByZoom: number[];
+    _maxNodeZoom: number;
+    /**
+     * Elevation grid size. Current is 2x2 is the smallest grid size.
+     * @public
+     * @type {number}
+     */
+    plainGridSize: number;
+    /**
+     * Planet scene.
+     * @public
+     * @type {Planet}
+     */
+    _planet: Planet | null;
+    _geoid: Geoid;
+    _isReady: boolean;
+    constructor(options?: IEmptyTerrainParams);
+    /**
+     * Sets url rewrite callback, used for custom url rewriting for every tile loading.
+     * @public
+     * @param {UrlRewriteFunc} ur - The callback that returns tile custom created url.
+     */
+    setUrlRewriteCallback(ur: UrlRewriteFunc): void;
+    get isIdle(): boolean;
+    isEqual(obj: this): boolean;
+    static checkNoDataValue(noDataValues: number[] | TypedArray, value: number): boolean;
+    isBlur(segment?: Segment): boolean;
+    set maxNodeZoom(val: number);
+    get maxNodeZoom(): number;
+    set geoid(geoid: Geoid);
+    get geoid(): Geoid;
+    getGeoid(): Geoid;
+    /**
+     * Loads or creates segment elevation data.
+     * @public
+     * @param {Segment} segment - Segment to create elevation data.
+     */
+    handleSegmentTerrain(segment: Segment): void;
+    isReady(): boolean;
+    abortLoading(): void;
+    clearCache(): void;
+    getHeightAsync(lonLat: LonLat, callback: (height: number) => void): boolean;
+    loadTerrain(segment: Segment, forceLoading?: boolean): void;
+}
+export { EmptyTerrain };

package/lib/@openglobus/js/terrain/Geoid.d.ts

@@ -0,0 +1,33 @@
+import { LonLat } from "../LonLat";
+interface IGeoidParams {
+    model?: GeoidModel;
+    src?: string | null;
+}
+export type GeoidModel = {
+    scale: number;
+    offset: number;
+    width: number;
+    height: number;
+    rlonres: number;
+    rlatres: number;
+    i: number;
+    rawfile: Uint8Array;
+};
+declare class Geoid {
+    model: GeoidModel | null;
+    src: string | null;
+    protected _cached_ix: number;
+    protected _cached_iy: number;
+    protected _v00: number;
+    protected _v01: number;
+    protected _v10: number;
+    protected _v11: number;
+    protected _t: number;
+    constructor(options?: IGeoidParams);
+    static loadModel(url?: string | null): Promise<GeoidModel | null>;
+    setModel(model: GeoidModel | null): void;
+    protected _rawval(ix: number, iy: number): number;
+    getHeightLonLat(lonlat: LonLat): number;
+    getHeight(lon: number, lat: number): number;
+}
+export { Geoid };

package/lib/@openglobus/js/terrain/GlobusRgbTerrain.d.ts

@@ -0,0 +1,6 @@
+import { IRgbTerrainParams, RgbTerrain } from "./RgbTerrain";
+import { Segment } from "../segment/Segment";
+export declare class GlobusRgbTerrain extends RgbTerrain {
+    constructor(name?: string | null, options?: IRgbTerrainParams);
+    isReadyToLoad(segment: Segment): boolean;
+}

package/lib/@openglobus/js/terrain/GlobusTerrain.d.ts

@@ -0,0 +1,137 @@
+import { EventsHandler } from "../Events";
+import { TypedArray } from "../utils/shared";
+import { EmptyTerrain, IEmptyTerrainParams, UrlRewriteFunc } from "./EmptyTerrain";
+import { Extent } from "../Extent";
+import { Loader } from "../utils/Loader";
+import { LonLat } from "../LonLat";
+import { Segment } from "../segment/Segment";
+export interface IGlobusTerrainParams extends IEmptyTerrainParams {
+    subdomains?: string[];
+    url?: string;
+    extent?: Extent | [[number, number], [number, number]];
+    urlRewrite?: UrlRewriteFunc;
+    noDataValues?: number[];
+    plainGridSize?: number;
+    heightFactor?: number;
+}
+type TileData = {
+    heights: number[] | TypedArray | null;
+    extent: Extent | null;
+};
+/**
+ * Class that loads segment elevation data, converts it to the array and passes it to the planet segment.
+ * @class
+ * @extends {GlobusTerrain}
+ * @param {string} [name=""] - Terrain provider name.
+ * @param {IGlobusTerrainParams} [options] - Provider options:
+ * @param {number} [options.minZoom=3] - Minimal visible zoom index when terrain handler works.
+ * @param {number} [options.minZoom=14] - Maximal visible zoom index when terrain handler works.
+ * @param {number} [options.minNativeZoom=14] - Maximal available terrain zoom level.
+ * @param {string} [options.url="//openglobus.org/heights/srtm3/{z}/{y}/{x}.ddm"] - Terrain source path url template. Default is openglobus ddm elevation file.
+ * @param {Array.<number>} [options.gridSizeByZoom] - Array of segment triangulation grid sizes where array index agreed to the segment zoom index.
+ * @param {number} [options.plainGridSize=32] - Elevation grid size. Default is 32x32. Must be power of two.
+ * @param {string} [options.responseType="arraybuffer"] - Response type.
+ * @param {number} [options.MAX_LOADING_TILES] - Maximum at one time loading tiles.
+ * @param {Array.<number>} [gridSizeByZoom] - Array of values, where each value corresponds to the size of a tile(or segment) on the globe. Each value must be power of two.
+ * @param {number} [heightFactor=1] - Elevation height multiplier.
+ *
+ * @fires GlobusTerrainEvents#load
+ * @fires GlobusTerrainEvents#loadend
+ */
+declare class GlobusTerrain extends EmptyTerrain {
+    events: GlobusTerrainEvents;
+    protected _s: string[];
+    protected _requestCount: number;
+    protected _requestsPeerSubdomain: number;
+    /**
+     * Terrain source path url template.
+     * @protected
+     * @type {string}
+     */
+    protected url: string;
+    protected _extent: Extent;
+    protected _dataType: string;
+    protected _elevationCache: Record<string, TileData>;
+    protected _fetchCache: Record<string, Promise<any>>;
+    protected _loader: Loader<GlobusTerrain>;
+    /**
+     * Rewrites elevation storage url query.
+     * @protected
+     * @type {Function} -
+     */
+    protected _urlRewriteCallback: UrlRewriteFunc | null;
+    protected _heightFactor: number;
+    constructor(name?: string, options?: IGlobusTerrainParams);
+    get loader(): Loader<GlobusTerrain>;
+    clearCache(): void;
+    isBlur(segment: Segment): boolean;
+    setElevationCache(tileIndex: string, tileData: TileData): void;
+    getElevationCache(tileIndex: string): TileData | undefined;
+    getHeightAsync(lonLat: LonLat, callback: (h: number) => void, zoom?: number, firstAttempt?: boolean): boolean;
+    protected _getGroundHeightMerc(merc: LonLat, tileData: TileData): number;
+    /**
+     * Stop loading.
+     * @public
+     */
+    abortLoading(): void;
+    /**
+     * Sets terrain data url template.
+     * @public
+     * @param {string} url - Url template.
+     * @example <caption>Default openglobus url template:</caption>:
+     * "http://earth3.openglobus.org/{z}/{y}/{x}.ddm"
+     */
+    setUrl(url: string): void;
+    /**
+     * Sets provider name.
+     * @public
+     * @param {string} name - Name.
+     */
+    setName(name: string): void;
+    isReadyToLoad(segment: Segment): boolean;
+    /**
+     * Starts to load segment elevation data.
+     * @public
+     * @param {Segment} segment - Segment that wants a terrain data.
+     * @param {boolean} [forceLoading] -
+     */
+    loadTerrain(segment: Segment, forceLoading?: boolean): void;
+    protected _getSubdomain(): string;
+    buildURL(x: number, y: number, z: number, tileGroup: number): string;
+    /**
+     * Creates default query url string.
+     * @protected
+     * @param {Segment} segment -
+     * @returns {string} -
+     */
+    protected _createUrl(segment: Segment): string;
+    /**
+     * Returns actual url query string.
+     * @protected
+     * @param {Segment} segment - Segment that loads image data.
+     * @returns {string} - Url string.
+     */
+    protected _getHTTPRequestString(segment: Segment): string;
+    /**
+     * Sets url rewrite callback, used for custom url rewriting for every tile loading.
+     * @public
+     * @param {UrlRewriteFunc} ur - The callback that returns tile custom created url.
+     */
+    setUrlRewriteCallback(ur: UrlRewriteFunc): void;
+    /**
+     * Converts loaded data to segment elevation data type(column major elevation data array in meters)
+     * @public
+     * @returns {Array.<number>} -
+     */
+    protected _createHeights(data: any, segment?: Segment | null, tileGroup?: number, x?: number, y?: number, z?: number, extent?: Extent, isMaxZoom?: boolean): TypedArray | number[];
+    /**
+     * @protected
+     */
+    protected _applyElevationsData(segment: Segment, elevations: number[] | TypedArray | null): void;
+}
+type GlobusTerrainEventsList = [
+    "load",
+    "loadend"
+];
+type GlobusTerrainEvents = EventsHandler<GlobusTerrainEventsList>;
+export { GlobusTerrain };

package/lib/{js/terrain/MapboxTerrain.d.ts → @openglobus/js/terrain/RgbTerrain.d.ts}

@@ -3,20 +3,20 @@ import { GlobusTerrain, IGlobusTerrainParams } from "./GlobusTerrain";
 import { LonLat } from "../LonLat";
 import { Segment } from "../segment/Segment";
 import { TypedArray } from "../utils/shared";
-interface IMapboxTerrainParams extends IGlobusTerrainParams {
+export interface IRgbTerrainParams extends IGlobusTerrainParams {
     equalizeNormals?: boolean;
     key?: string;
     imageSize?: number;
 }
-declare class MapboxTerrain extends GlobusTerrain {
+declare class RgbTerrain extends GlobusTerrain {
     protected _imageSize: number;
     protected _ctx: CanvasRenderingContext2D;
     protected _imageDataCache: Record<string, Uint8ClampedArray>;
-    constructor(name: string | null, options?: IMapboxTerrainParams);
+    constructor(name: string | null, options?: IRgbTerrainParams);
     static checkNoDataValue(noDataValues: number[] | TypedArray, value: number): boolean;
     isBlur(segment: Segment): boolean;
     protected _createTemporalCanvas(size: number): CanvasRenderingContext2D;
-    protected _createHeights(data: HTMLImageElement | ImageBitmap, tileIndex: string, tileX: number, tileY: number, tileZoom: number, extent: Extent, preventChildren: boolean): TypedArray | number[];
+    protected _createHeights(data: HTMLImageElement | ImageBitmap, segment: Segment | null, tileGroup: number, tileX: number, tileY: number, tileZoom: number, extent: Extent, preventChildren: boolean): TypedArray | number[];
     getHeightAsync(lonLat: LonLat, callback: (h: number) => void, zoom?: number): boolean;
 }
-export { MapboxTerrain };
+export { RgbTerrain };

package/lib/@openglobus/js/terrain/index.d.ts

@@ -0,0 +1,6 @@
+import { BilTerrain } from './BilTerrain';
+import { EmptyTerrain } from './EmptyTerrain';
+import { GlobusTerrain } from './GlobusTerrain';
+import { RgbTerrain } from './RgbTerrain';
+import { GlobusRgbTerrain } from './GlobusRgbTerrain';
+export { EmptyTerrain, GlobusTerrain, RgbTerrain, BilTerrain, GlobusRgbTerrain };

package/lib/@openglobus/js/ui/Button.d.ts

@@ -0,0 +1,32 @@
+import { IViewParams, View, ViewEventsList } from './View';
+import { EventsHandler } from "../Events";
+interface HTMLElementExt extends HTMLElement {
+    __og_button__: Button;
+}
+export type ButtonEventsList = ["click", "mousedown", "mouseup", "touchstart", "touchend", "touchcancel"];
+export interface IButtonParams extends IViewParams {
+    icon?: string;
+    text?: string;
+    title?: string;
+    name?: string;
+}
+declare class Button extends View<null> {
+    events: EventsHandler<ButtonEventsList> & EventsHandler<ViewEventsList>;
+    el: HTMLElementExt | null;
+    name: string;
+    $icon: HTMLElement | null;
+    $text: HTMLElement | null;
+    constructor(options?: IButtonParams);
+    render(params: any): this;
+    protected _initEvents(): void;
+    protected _onMouseDown: (e: MouseEvent) => void;
+    protected _onMouseUp: (e: MouseEvent) => void;
+    protected _onTouchStart: (e: TouchEvent) => void;
+    protected _onTouchEnd: (e: TouchEvent) => void;
+    protected _onTouchCancel: (e: TouchEvent) => void;
+    protected _mouseClickHandler(e: MouseEvent): void;
+    protected _onMouseClick: (e: MouseEvent) => void;
+    remove(): void;
+    protected _clearEvents(): void;
+}
+export { Button };

package/lib/@openglobus/js/ui/ButtonGroup.d.ts

@@ -0,0 +1,16 @@
+import { ToggleButton } from "./ToggleButton";
+import { EventsHandler } from '../Events';
+interface IButtonGroupParams {
+    buttons?: ToggleButton[];
+}
+type ButtonGroupEventsList = ["change"];
+declare class ButtonGroup {
+    events: EventsHandler<ButtonGroupEventsList>;
+    protected _buttons: ToggleButton[];
+    constructor(options?: IButtonGroupParams);
+    protected _bindButton(button: ToggleButton): void;
+    add(button: ToggleButton): void;
+    protected _onChange: (isActive: boolean, btn: ToggleButton) => void;
+    remove(button: ToggleButton): void;
+}
+export { ButtonGroup };

package/lib/@openglobus/js/ui/Color.d.ts

@@ -0,0 +1,22 @@
+import { EventsHandler } from "../Events";
+import { IViewParams, View, ViewEventsList } from './View';
+interface IColorParams extends IViewParams {
+    label?: string;
+    value?: string;
+}
+type ColorEventsList = ["input"];
+declare class Color extends View<null> {
+    events: EventsHandler<ColorEventsList> & EventsHandler<ViewEventsList>;
+    protected _value: string;
+    protected $label: HTMLElement | null;
+    protected $input: HTMLInputElement | null;
+    constructor(options?: IColorParams);
+    render(params: any): this;
+    set value(val: string);
+    get value(): string;
+    protected _initEvents(): void;
+    protected _clearEvents(): void;
+    protected _onInput: (e: Event) => void;
+    remove(): void;
+}
+export { Color };

package/lib/@openglobus/js/ui/Dialog.d.ts

@@ -0,0 +1,55 @@
+import { Button } from './Button';
+import { IViewParams, View, ViewEventsList } from './View';
+import { EventsHandler } from "../Events";
+export interface IDialogParams extends IViewParams {
+    title?: string;
+    visible?: boolean;
+    resizable?: boolean;
+    width?: number;
+    height?: number;
+    left?: number;
+    top?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    useHide?: boolean;
+}
+type DialogEventsList = ["resize", "focus", "visibility", "dragstart", "dragend"];
+declare class Dialog<M> extends View<M> {
+    static __zIndex__: number;
+    events: EventsHandler<DialogEventsList> & EventsHandler<ViewEventsList>;
+    $header: HTMLElement | null;
+    $title: HTMLElement | null;
+    $container: HTMLElement | null;
+    $buttons: HTMLElement | null;
+    useHide: boolean;
+    protected _startPosX: number;
+    protected _startPosY: number;
+    protected _closeBtn: Button;
+    protected _visibility: boolean;
+    constructor(options?: IDialogParams);
+    setContainer(htmlStr: string): void;
+    get container(): HTMLElement | null;
+    get width(): number;
+    get height(): number;
+    bringToFront(): void;
+    render(params: any): this;
+    show(): void;
+    hide(): void;
+    close(): void;
+    setVisibility(visibility: boolean): void;
+    protected _initButtons(): void;
+    protected _initEvents(): void;
+    protected _onCloseBtnClick: () => void;
+    protected _onMouseDownAll: () => void;
+    protected _onMouseDown: (e: MouseEvent) => void;
+    setPosition(x?: number, y?: number): void;
+    protected _onMouseMove: (e: MouseEvent) => void;
+    protected _startDragging(): void;
+    protected _clearDragging(): void;
+    protected _onMouseUp: () => void;
+    remove(): void;
+    protected _clearEvents(): void;
+}
+export { Dialog };

package/lib/@openglobus/js/ui/Slider.d.ts

@@ -0,0 +1,38 @@
+import { EventsHandler } from "../Events";
+import { IViewParams, View, ViewEventsList } from './View';
+interface ISliderParams extends IViewParams {
+    label?: string;
+    value?: number;
+    min?: number;
+    max?: number;
+}
+type SliderEventsList = ["change"];
+declare class Slider extends View<null> {
+    events: EventsHandler<SliderEventsList> & EventsHandler<ViewEventsList>;
+    protected _value: number;
+    protected _min: number;
+    protected _max: number;
+    protected _startPosX: number;
+    protected _resizeObserver: ResizeObserver;
+    protected $label: HTMLElement | null;
+    protected $pointer: HTMLElement | null;
+    protected $progress: HTMLElement | null;
+    protected $input: HTMLInputElement | null;
+    protected $panel: HTMLElement | null;
+    constructor(options?: ISliderParams);
+    render(params: any): this;
+    protected _onResize: () => void;
+    set value(val: number);
+    get value(): number;
+    protected _initEvents(): void;
+    protected _clearEvents(): void;
+    protected _onMouseWheel: (e: WheelEvent) => void;
+    protected _onMouseWheelFF: (e: WheelEvent) => void;
+    protected _onInput: (e: Event) => void;
+    protected _onMouseDown: (e: MouseEvent) => void;
+    protected _setOffset(x: number): void;
+    protected _onMouseMove: (e: MouseEvent) => void;
+    protected _onMouseUp: () => void;
+    remove(): void;
+}
+export { Slider };

package/lib/@openglobus/js/ui/ToggleButton.d.ts

@@ -0,0 +1,20 @@
+import { Button, IButtonParams, ButtonEventsList } from './Button';
+import { EventsHandler } from "../Events";
+import { ViewEventsList } from "./View";
+interface IToggleButtonParams extends IButtonParams {
+    isActive?: boolean;
+    preventClick?: boolean;
+}
+type ToggleButtonEventsList = ["change"];
+declare class ToggleButton extends Button {
+    events: EventsHandler<ToggleButtonEventsList> & EventsHandler<ButtonEventsList> & EventsHandler<ViewEventsList>;
+    protected _isActive: boolean;
+    preventClick: boolean;
+    constructor(options: IToggleButtonParams);
+    setActive(isActive: boolean, stopPropagation?: boolean): void;
+    protected _toggle(): void;
+    get isActive(): boolean;
+    render(params: any): this;
+    protected _onMouseClick: (e: MouseEvent) => void;
+}
+export { ToggleButton };

package/lib/@openglobus/js/ui/View.d.ts

@@ -0,0 +1,37 @@
+import { EventsHandler } from '../Events';
+export interface IViewParams {
+    model?: any;
+    template?: string;
+    parent?: View<any> | null;
+    classList?: string[];
+}
+export type ViewEventsList = ["render"];
+declare class View<M> {
+    static __counter__: number;
+    protected __id: number;
+    events: EventsHandler<ViewEventsList>;
+    model: M;
+    template: string;
+    parent: View<any> | null;
+    el: HTMLElement | null;
+    protected _classList: string[];
+    constructor(options?: IViewParams);
+    static getHTML(template: string, params: any): string;
+    static parseHTML(htmlStr: string): HTMLElement[];
+    static insertAfter(newNodes: HTMLElement | HTMLElement[], referenceNode: Node): HTMLElement[];
+    static insertBefore(newNodes: HTMLElement | HTMLElement[], referenceNode: Node): HTMLElement[];
+    insertBefore(view: View<any> | HTMLElement): void;
+    insertAfter(view: View<any> | HTMLElement): void;
+    isEqual(view: View<any>): boolean;
+    appendTo(node: HTMLElement, clean?: boolean, firstPosition?: boolean): this;
+    afterRender(parentNode: HTMLElement): void;
+    beforeRender(parentNode: HTMLElement): void;
+    stopPropagation(): void;
+    renderTemplate(params: any): HTMLElement;
+    render(params?: any): this;
+    select<T extends HTMLElement>(queryStr: string): T | null;
+    selectRemove(queryStr: string): HTMLElement | undefined;
+    selectAll(queryStr: string, callback?: Function): NodeListOf<Element> | undefined;
+    remove(): void;
+}
+export { View };

package/lib/@openglobus/js/ui/icons.d.ts

@@ -0,0 +1 @@
+export declare const CLOSE_ICON = "<svg className=\"svg-icon\" style=\"width: 1em; height: 1em;vertical-align: middle;fill: currentColor; overflow: hidden;\" viewBox=\"0 0 1024 1024\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">\n    <path d=\"M777.856 280.192l-33.92-33.952-231.872 231.872-231.84-231.872-33.984 33.888 231.872 231.904-231.84 231.84 33.888 33.984 231.904-231.904 231.84 231.872 33.952-33.888-231.872-231.904z\"/>\n</svg>";

package/lib/@openglobus/js/utils/BaseWorker.d.ts

@@ -0,0 +1,14 @@
+export declare class BaseWorker<T> {
+    protected _sourceId: number;
+    protected _source: Map<number, T>;
+    protected _pendingQueue: T[];
+    protected _numWorkers: number;
+    protected _workerQueue: Worker[];
+    constructor(numWorkers?: number, program?: string);
+    check(): void;
+    setProgram(program: string): void;
+    make(data: T): void;
+    protected _onMessage(e: MessageEvent): void;
+    destroy(): void;
+    get pendingQueue(): T[];
+}

package/lib/@openglobus/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 };