@openglobus/og 0.24.2 → 0.25.1

package/lib/js/control/GeoImageDragControl.js

@@ -1,102 +0,0 @@
-import { BaseGeoImage } from '../layer/BaseGeoImage';
-import { Control } from './Control';
-import { ToggleButton } from "../ui/ToggleButton";
-const ICON_BUTTON_SVG = `<?xml version="1.0" encoding="UTF-8" standalone="no"?> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M16 13l6.964 4.062-2.973.85 2.125 3.681-1.732 1-2.125-3.68-2.223 2.15L16 13zm-2-7h2v2h5a1 1 0 0 1 1 1v4h-2v-3H10v10h4v2H9a1 1 0 0 1-1-1v-5H6v-2h2V9a1 1 0 0 1 1-1h5V6zM4 14v2H2v-2h2zm0-4v2H2v-2h2zm0-4v2H2V6h2zm0-4v2H2V2h2zm4 0v2H6V2h2zm4 0v2h-2V2h2zm4 0v2h-2V2h2z" fill="#000"/></svg>`;
-export class GeoImageDragControl extends Control {
-    constructor(options = {}) {
-        super(options);
-        this._cornerIndex = -1;
-        this._catchCorner = false;
-        this._toggleBtn = new ToggleButton({
-            classList: ["og-map-button", "og-geoimagegrag_button"],
-            icon: ICON_BUTTON_SVG
-        });
-    }
-    oninit() {
-        this._toggleBtn.appendTo(this.renderer.div);
-        this.planet.events.on('layeradd', (e) => {
-            if (this.isActive()) {
-                this._bindLayer(e);
-            }
-        }, this);
-        this._toggleBtn.events.on("change", (isActive) => {
-            if (isActive) {
-                this.activate();
-            }
-            else {
-                this.deactivate();
-            }
-        });
-    }
-    onactivate() {
-        super.onactivate();
-        const p = this.planet;
-        for (let i = 0; i < p.layers.length; i++) {
-            this._bindLayer(p.layers[i]);
-        }
-    }
-    ondeactivate() {
-        super.ondeactivate();
-        const p = this.planet;
-        for (let i = 0; i < p.layers.length; i++) {
-            this._unbindLayer(p.layers[i]);
-        }
-    }
-    _bindLayer(layer) {
-        if (layer instanceof BaseGeoImage) {
-            layer.events.on('mousemove', this._onMouseMove, this);
-            layer.events.on("mouseleave", this._onMouseLeave, this);
-            layer.events.on('ldown', this._onLDown, this);
-            layer.events.on('lup', this._onLUp, this);
-        }
-    }
-    _unbindLayer(layer) {
-        if (layer instanceof BaseGeoImage) {
-            layer.events.off('mousemove', this._onMouseMove);
-            layer.events.off("mouseleave", this._onMouseLeave);
-            layer.events.off('ldown', this._onLDown);
-            layer.events.off('lup', this._onLUp);
-        }
-    }
-    _onLUp(ms) {
-        this._catchCorner = false;
-        ms.renderer.controls.mouseNavigation.activate();
-    }
-    _onLDown(ms) {
-        if (this._cornerIndex !== -1) {
-            this._catchCorner = true;
-            ms.renderer.controls.mouseNavigation.deactivate();
-        }
-    }
-    _onMouseLeave() {
-        document.body.style.cursor = 'auto';
-    }
-    _onMouseMove(ms) {
-        let layer = ms.pickingObject;
-        const p = this.planet;
-        if (this._catchCorner) { // mouse is catching a corner
-            let corners = layer.getCornersLonLat();
-            // corners[this._cornerIndex] = p.getLonLatFromPixelTerrain(ms, true);
-            corners[this._cornerIndex] = p.getLonLatFromPixelTerrain(ms);
-            layer.setCornersLonLat(corners);
-        }
-        else { // mouse isn't catching
-            this._cornerIndex = -1;
-            for (let i = 0; i < layer._cornersWgs84.length; i++) {
-                // let ground = p.getLonLatFromPixelTerrain(ms, true);
-                let ground = p.getLonLatFromPixelTerrain(ms);
-                // mouse is near
-                //if (ground && p.ellipsoid.getGreatCircleDistance(layer._cornersWgs84[i], ground) / p.getDistanceFromPixel(ms, true) <= 0.05) {
-                if (ground && p.ellipsoid.getGreatCircleDistance(layer._cornersWgs84[i], ground) / p.getDistanceFromPixel(ms) <= 0.05) {
-                    this._cornerIndex = i;
-                    document.body.style.cursor = 'move';
-                    break;
-                    // mouse is far
-                }
-                else {
-                    document.body.style.cursor = 'auto';
-                }
-            }
-        }
-    }
-}

package/lib/js/control/KeyboardNavigation.d.ts

@@ -1,28 +0,0 @@
-import { Control, type IControlParams } from "./Control";
-interface IKeyboardNavigationParams extends IControlParams {
-    step?: number;
-}
-/**
- * Planet camera keyboard navigation. Use W,S,A,D and left shift key for fly around a planet.
- */
-export declare class KeyboardNavigation extends Control {
-    step: number;
-    constructor(options?: IKeyboardNavigationParams);
-    onactivate(): void;
-    ondeactivate(): void;
-    oninit(): void;
-    protected onCameraMoveForward(): void;
-    protected onCameraMoveBackward(): void;
-    protected onCameraStrifeLeft(): void;
-    protected onCameraStrifeRight(): void;
-    protected onCameraLookUp(): void;
-    protected onCameraLookDown(): void;
-    protected onCameraLookLeft(): void;
-    protected onCameraLookRight(): void;
-    protected onCameraTurnLeft(): void;
-    protected onCameraTurnRight(): void;
-    protected onCameraRollNorth(): void;
-    protected onCameraRollLeft(): void;
-    protected onCameraRollRight(): void;
-}
-export {};

package/lib/js/control/KeyboardNavigation.js

@@ -1,143 +0,0 @@
-import * as math from "../math";
-import { Control } from "./Control";
-import { input } from "../input/input";
-import { Vec3 } from "../math/Vec3";
-/**
- * Planet camera keyboard navigation. Use W,S,A,D and left shift key for fly around a planet.
- */
-export class KeyboardNavigation extends Control {
-    constructor(options = {}) {
-        options = options || {};
-        super({ name: "KeyboardNavigation", ...options });
-        this.step = options.step || 25000;
-    }
-    onactivate() {
-        let r = this.renderer;
-        r.events.on("keypress", input.KEY_PGUP, this.onCameraMoveForward, this);
-        r.events.on("keypress", input.KEY_PGDN, this.onCameraMoveBackward, this);
-        r.events.on("keypress", input.KEY_PLUS, this.onCameraMoveForward, this);
-        r.events.on("keypress", input.KEY_EQUALS, this.onCameraMoveForward, this);
-        r.events.on("keypress", input.KEY_MINUS, this.onCameraMoveBackward, this);
-        r.events.on("keypress", input.KEY_W, this.onCameraMoveForward, this);
-        r.events.on("keypress", input.KEY_S, this.onCameraMoveBackward, this);
-        r.events.on("keypress", input.KEY_A, this.onCameraStrifeLeft, this);
-        r.events.on("keypress", input.KEY_D, this.onCameraStrifeRight, this);
-        r.events.on("keypress", input.KEY_UP, this.onCameraLookUp, this);
-        r.events.on("keypress", input.KEY_DOWN, this.onCameraLookDown, this);
-        r.events.on("keypress", input.KEY_LEFT, this.onCameraLookLeft, this);
-        r.events.on("keypress", input.KEY_RIGHT, this.onCameraLookRight, this);
-        r.events.on("keypress", input.KEY_Q, this.onCameraRollLeft, this);
-        r.events.on("keypress", input.KEY_E, this.onCameraRollRight, this);
-        r.events.on("keypress", input.KEY_N, this.onCameraRollNorth, this);
-    }
-    ondeactivate() {
-        let r = this.renderer;
-        r.events.off("keypress", input.KEY_PGUP, this.onCameraMoveForward);
-        r.events.off("keypress", input.KEY_PGDN, this.onCameraMoveBackward);
-        r.events.off("keypress", input.KEY_PLUS, this.onCameraMoveForward);
-        r.events.off("keypress", input.KEY_EQUALS, this.onCameraMoveForward);
-        r.events.off("keypress", input.KEY_MINUS, this.onCameraMoveBackward);
-        r.events.off("keypress", input.KEY_W, this.onCameraMoveForward);
-        r.events.off("keypress", input.KEY_S, this.onCameraMoveBackward);
-        r.events.off("keypress", input.KEY_A, this.onCameraStrifeLeft);
-        r.events.off("keypress", input.KEY_D, this.onCameraStrifeRight);
-        r.events.off("keypress", input.KEY_UP, this.onCameraLookUp);
-        r.events.off("keypress", input.KEY_DOWN, this.onCameraLookDown);
-        r.events.off("keypress", input.KEY_LEFT, this.onCameraLookLeft);
-        r.events.off("keypress", input.KEY_RIGHT, this.onCameraLookRight);
-        r.events.off("keypress", input.KEY_Q, this.onCameraRollLeft);
-        r.events.off("keypress", input.KEY_E, this.onCameraRollRight);
-        r.events.off("keypress", input.KEY_N, this.onCameraRollNorth);
-    }
-    oninit() {
-        this.activate();
-    }
-    onCameraMoveForward() {
-        let cam = this.planet.camera;
-        cam.slide(0, 0, -cam.getAltitude() / this.step);
-    }
-    onCameraMoveBackward() {
-        let cam = this.planet.camera;
-        cam.slide(0, 0, cam.getAltitude() / this.step);
-    }
-    onCameraStrifeLeft() {
-        let cam = this.planet.camera;
-        cam.slide(-cam.getAltitude() / this.step, 0, 0);
-    }
-    onCameraStrifeRight() {
-        let cam = this.planet.camera;
-        cam.slide(cam.getAltitude() / this.step, 0, 0);
-    }
-    onCameraLookUp() {
-        let cam = this.planet.camera;
-        if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.setPitch(15 / this.renderer.handler.deltaTime);
-        }
-        else {
-            cam.rotateVertical((cam.getAltitude() / 3000000) * math.RADIANS, Vec3.ZERO);
-        }
-    }
-    onCameraLookDown() {
-        let cam = this.planet.camera;
-        if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.setPitch(-15 / this.renderer.handler.deltaTime);
-        }
-        else {
-            cam.rotateVertical((-cam.getAltitude() / 3000000) * math.RADIANS, Vec3.ZERO);
-        }
-    }
-    onCameraLookLeft() {
-        let cam = this.planet.camera;
-        if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.setRoll(15 / this.renderer.handler.deltaTime);
-        }
-        else {
-            cam.rotateHorizontal((cam.getAltitude() / 3000000) * math.RADIANS);
-        }
-    }
-    onCameraLookRight() {
-        let cam = this.planet.camera;
-        if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.setRoll(-15 / this.renderer.handler.deltaTime);
-        }
-        else {
-            cam.rotateHorizontal((-cam.getAltitude() / 3000000) * math.RADIANS);
-        }
-    }
-    onCameraTurnLeft() {
-        let cam = this.planet.camera;
-        if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.setYaw(15 / this.renderer.handler.deltaTime);
-        }
-        else {
-            cam.rotateHorizontal((cam.getAltitude() / 3000000) * math.RADIANS);
-        }
-    }
-    onCameraTurnRight() {
-        let cam = this.planet.camera;
-        if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.setYaw(-15 / this.renderer.handler.deltaTime);
-        }
-        else {
-            cam.rotateHorizontal((-cam.getAltitude() / 3000000) * math.RADIANS, false, Vec3.ZERO);
-        }
-    }
-    // from CompassButton._onClick()
-    onCameraRollNorth() {
-        let c = this.planet.getCartesianFromPixelTerrain(this.renderer.handler.getCenter());
-        if (c) {
-            this.planet.flyCartesian(c.normal().scaleTo(c.length() + c.distance(this.planet.camera.eye)), null, null, 0, null, null, () => {
-                this.planet.camera.look;
-            });
-        }
-        else {
-            this.planet.flyCartesian(this.planet.camera.eye);
-        }
-    }
-    onCameraRollLeft() {
-        this.planet.camera.setRoll(-15 / this.renderer.handler.deltaTime);
-    }
-    onCameraRollRight() {
-        this.planet.camera.setRoll(15 / this.renderer.handler.deltaTime);
-    }
-}

package/lib/js/control/LayerAnimation.d.ts

@@ -1,71 +0,0 @@
-import { type EventsHandler } from '../Events';
-import { Layer } from '../layer/Layer';
-import { Control, type IControlParams } from "./Control";
-type LayerAnimationEventsList = ["change", "idle", "play", "pause", "stop"];
-interface ILayerAnimationParams extends IControlParams {
-    layers?: Layer;
-    playInterval?: number;
-    frameSize?: number;
-    repeat?: boolean;
-    skipTimeout?: number;
-}
-export declare class LayerAnimation extends Control {
-    events: EventsHandler<LayerAnimationEventsList>;
-    protected _layersArr: Layer[];
-    protected _currentIndex: number;
-    protected _playInterval: number;
-    protected _playIntervalHandler: any;
-    protected _playIndex: number;
-    protected _frameSize: number;
-    repeat: boolean;
-    skipTimeout: number;
-    protected _timeoutStart: number;
-    protected _currVisibleIndex: number;
-    constructor(options?: ILayerAnimationParams);
-    protected _onViewchange: () => void;
-    protected _getFramesNum(): number;
-    protected _setFrame(frameIndex: number): void;
-    protected _getFrameIndex(layerIndex: number): number;
-    protected _appendFrameToPlanet(frameIndex: number): void;
-    protected _removeFrameFromPlanet(frameIndex: number): void;
-    oninit(): void;
-    onactivate(): void;
-    ondeactivate(): void;
-    protected _onVisibilityChange: (isVisible: boolean) => void;
-    clear(): void;
-    protected _initLayers(): void;
-    setLayers(layers: Layer[]): void;
-    appendLayer(layer: Layer): void;
-    /**
-     * warning: Use XYZ.isIdle in requestAnimationFrame(after setVisibility)
-     * @returns Returns true if current layer is idle
-     */
-    get isIdle(): boolean;
-    get playInterval(): number;
-    set playInterval(val: number);
-    get isPlaying(): boolean;
-    get layers(): Layer[];
-    protected _checkEnd(): void;
-    play(): void;
-    stop(): void;
-    pause(): void;
-    protected _clearInterval(): void;
-    /**
-     * Waiting for the current index layer loadend and make it non-transparent,
-     * and make prev layer transparent, also check previous frame index to clean up.
-     */
-    private _onLayerLoadend;
-    /**
-     * Function sets layer index visible.
-     * @param {number} index
-     * @param {boolean} [stopPropagation=false]
-     */
-    setCurrentIndex(index: number, stopPropagation?: boolean): void;
-    /**
-     * Function sets layer index visible. If the layer is idle (all visible tiles loaded), sets opacity to one,
-     * otherwise to ZERO it means that when all visible tiles will be loaded the opacity becomes ONE. So, previous
-     * layer remains not transparent (opacity = 1) till current layer is loading.
-     */
-    protected _setCurrentIndexAsync(index: number, forceVisibility?: boolean, stopPropagation?: boolean): void;
-}
-export {};

package/lib/js/control/LayerAnimation.js

@@ -1,283 +0,0 @@
-import { createEvents } from '../Events';
-import { Control } from "./Control";
-const LAYERANIMATION_EVENTS = ["change", "idle", "play", "pause", "stop"];
-export class LayerAnimation extends Control {
-    constructor(options = {}) {
-        super(options);
-        this._currVisibleIndex = 0;
-        this._onViewchange = () => {
-            this._timeoutStart = performance.now();
-        };
-        this._onVisibilityChange = (isVisible) => {
-            if (!isVisible) {
-                this.pause();
-            }
-        };
-        /**
-         * Waiting for the current index layer loadend and make it non-transparent,
-         * and make prev layer transparent, also check previous frame index to clean up.
-         */
-        this._onLayerLoadend = (layer) => {
-            let currLayer = this._layersArr[this._currentIndex];
-            if (currLayer && currLayer.isEqual(layer)) {
-                // BRUTE
-                let currFrame = this._getFrameIndex(this._currentIndex);
-                let from = currFrame * this._frameSize, to = this._currentIndex;
-                for (let i = from; i < to; i++) {
-                    let li = this._layersArr[i];
-                    li.opacity = 0;
-                    li.setVisibility(false);
-                }
-                // * Make CURRENT Layer VISIBLE *
-                currLayer.opacity = 1.0;
-                let currVisibleLayer = this._layersArr[this._currVisibleIndex];
-                if (currVisibleLayer) {
-                    currVisibleLayer.opacity = 0.0;
-                    currVisibleLayer.setVisibility(false);
-                    // If frame is changed - remove it from the planet
-                    let prevFrame = this._getFrameIndex(this._currVisibleIndex);
-                    if (this._getFrameIndex(this._currentIndex) !== prevFrame) {
-                        this._removeFrameFromPlanet(prevFrame);
-                    }
-                }
-                this.events.dispatch(this.events.idle, currLayer);
-            }
-        };
-        this.events = createEvents(LAYERANIMATION_EVENTS);
-        this._name = options.name || `layerAnimation-${this.__id}`;
-        this._layersArr = options.layers ? [].concat(options.layers) : [];
-        this._currentIndex = -1;
-        this._playInterval = options.playInterval || 120;
-        this._playIntervalHandler = -1;
-        this._playIndex = 0;
-        this._frameSize = options.frameSize || 50;
-        this.repeat = options.repeat != undefined ? options.repeat : true;
-        this.skipTimeout = options.skipTimeout || 5000;
-        this._timeoutStart = 0;
-    }
-    _getFramesNum() {
-        return Math.ceil(this._layersArr.length / this._frameSize);
-    }
-    _setFrame(frameIndex) {
-        for (let i = 0, len = this._getFramesNum(); i < len; i++) {
-            if (i !== frameIndex) {
-                this._removeFrameFromPlanet(i);
-            }
-            else {
-                this._appendFrameToPlanet(i);
-            }
-        }
-    }
-    _getFrameIndex(layerIndex) {
-        return Math.floor(layerIndex / this._frameSize);
-    }
-    _appendFrameToPlanet(frameIndex) {
-        if (this.planet) {
-            let minIndex = frameIndex * this._frameSize;
-            let maxIndex = minIndex + this._frameSize;
-            for (let i = minIndex, len = maxIndex > this._layersArr.length ? this._layersArr.length : maxIndex; i < len; i++) {
-                this.planet.addLayer(this._layersArr[i]);
-            }
-        }
-    }
-    _removeFrameFromPlanet(frameIndex) {
-        if (this.planet) {
-            let minIndex = frameIndex * this._frameSize;
-            let maxIndex = minIndex + this._frameSize;
-            for (let i = minIndex, len = maxIndex > this._layersArr.length ? this._layersArr.length : maxIndex; i < len; i++) {
-                this._layersArr[i].abortLoading();
-                this._layersArr[i].remove();
-                this._layersArr[i].setVisibility(false);
-            }
-        }
-    }
-    oninit() {
-        super.oninit();
-        this.onactivate();
-        this._initLayers();
-        this.planet.events.on("layerloadend", this._onLayerLoadend);
-        this._setCurrentIndexAsync(0, false, true);
-    }
-    onactivate() {
-        super.onactivate();
-        this.planet.camera.events.on("viewchange", this._onViewchange);
-        this.planet.renderer.handler.events.on("visibilitychange", this._onVisibilityChange);
-    }
-    ondeactivate() {
-        super.ondeactivate();
-        this.planet.camera.events.off("viewchange", this._onViewchange);
-        for (let i = 0; i < this._layersArr.length; i++) {
-            this._layersArr[i].setVisibility(false);
-        }
-        this.planet.events.off("layerloadend", this._onLayerLoadend);
-        this.planet.renderer.handler.events.off("visibilitychange", this._onVisibilityChange);
-    }
-    clear() {
-        this.stop();
-        this._currentIndex = -1;
-        this._currVisibleIndex = -1;
-        let layersToRemove = this._layersArr;
-        this._layersArr = [];
-        for (let i = 0; i < layersToRemove.length; i++) {
-            layersToRemove[i].remove();
-        }
-    }
-    _initLayers() {
-        if (this.planet) {
-            for (let i = 0, len = this._layersArr.length; i < len; i++) {
-                let li = this._layersArr[i];
-                li.setVisibility(false);
-                li.setBaseLayer(false);
-                li.opacity = 0.0;
-            }
-            this._appendFrameToPlanet(0);
-        }
-    }
-    setLayers(layers) {
-        this.clear();
-        this._layersArr = [].concat(layers);
-        this._initLayers();
-    }
-    appendLayer(layer) {
-        this._layersArr.push(layer);
-        layer.setVisibility(false);
-        layer.setBaseLayer(false);
-        layer.opacity = 0.0;
-        //check current frame
-        this.planet?.addLayer(layer);
-    }
-    /**
-     * warning: Use XYZ.isIdle in requestAnimationFrame(after setVisibility)
-     * @returns Returns true if current layer is idle
-     */
-    get isIdle() {
-        let currLayer = this._layersArr[this._currentIndex];
-        return currLayer && currLayer.isIdle || !currLayer;
-    }
-    get playInterval() {
-        return this._playInterval;
-    }
-    set playInterval(val) {
-        if (val !== this._playInterval) {
-            this._playInterval = val;
-            if (this.isPlaying) {
-                this.pause();
-                this.play();
-            }
-        }
-    }
-    get isPlaying() {
-        return this._playIntervalHandler !== -1;
-    }
-    get layers() {
-        return this._layersArr;
-    }
-    _checkEnd() {
-        if (this._playIndex > this._layersArr.length) {
-            if (this.repeat) {
-                this._playIndex = 0;
-            }
-            else {
-                this.pause();
-            }
-        }
-    }
-    play() {
-        if (!this.isPlaying) {
-            if (this._currentIndex >= this._layersArr.length - 1) {
-                this.stop();
-            }
-            this._timeoutStart = performance.now();
-            this._playIntervalHandler = setInterval(() => {
-                this._checkEnd();
-                this._setCurrentIndexAsync(this._playIndex, false, false);
-                requestAnimationFrame(() => {
-                    if (this.isIdle || (performance.now() - this._timeoutStart > this.skipTimeout)) {
-                        this._playIndex++;
-                        this._timeoutStart = performance.now();
-                    }
-                });
-            }, this._playInterval);
-            this.events.dispatch(this.events.play);
-        }
-    }
-    stop() {
-        if (this._playIndex > 0) {
-            this._clearInterval();
-            this._playIndex = 0;
-            this.setCurrentIndex(0);
-            this.events.dispatch(this.events.stop);
-        }
-    }
-    pause() {
-        if (this.isPlaying) {
-            this._clearInterval();
-            this.events.dispatch(this.events.pause);
-        }
-    }
-    _clearInterval() {
-        clearInterval(this._playIntervalHandler);
-        this._playIntervalHandler = -1;
-    }
-    /**
-     * Function sets layer index visible.
-     * @param {number} index
-     * @param {boolean} [stopPropagation=false]
-     */
-    setCurrentIndex(index, stopPropagation = false) {
-        this._setCurrentIndexAsync(index, true, stopPropagation);
-    }
-    /**
-     * Function sets layer index visible. If the layer is idle (all visible tiles loaded), sets opacity to one,
-     * otherwise to ZERO it means that when all visible tiles will be loaded the opacity becomes ONE. So, previous
-     * layer remains not transparent (opacity = 1) till current layer is loading.
-     */
-    _setCurrentIndexAsync(index, forceVisibility = false, stopPropagation = false) {
-        if (index != this._currentIndex && index >= 0 && index < this._layersArr.length) {
-            let prevCurrIndex = this._currentIndex;
-            this._currentIndex = index;
-            this._playIndex = index;
-            let prevCurrFrame = this._getFrameIndex(prevCurrIndex);
-            let currFrame = this._getFrameIndex(this._currentIndex);
-            let prevCurrLayer = this._layersArr[prevCurrIndex], currLayer = this._layersArr[index];
-            let frameChanged = currFrame != prevCurrFrame;
-            if (frameChanged) {
-                this._appendFrameToPlanet(currFrame);
-            }
-            if (prevCurrLayer) {
-                if (prevCurrLayer.isIdle) {
-                    this._currVisibleIndex = prevCurrIndex;
-                }
-                else {
-                    prevCurrLayer.opacity = 0;
-                    prevCurrLayer.setVisibility(false);
-                }
-            }
-            if (currLayer) {
-                currLayer.opacity = 0.0;
-                currLayer.setVisibility(true);
-                requestAnimationFrame(() => {
-                    if (currLayer.isIdle || forceVisibility) {
-                        currLayer.opacity = 1.0;
-                        // If frame is changed - remove it from the planet
-                        if (frameChanged) {
-                            this._removeFrameFromPlanet(prevCurrFrame);
-                        }
-                        if (prevCurrLayer) {
-                            prevCurrLayer.opacity = 0.0;
-                            prevCurrLayer.setVisibility(false);
-                        }
-                        let currVisibleLayer = this._layersArr[this._currVisibleIndex];
-                        if (currVisibleLayer) {
-                            currVisibleLayer.opacity = 0.0;
-                            currVisibleLayer.setVisibility(false);
-                        }
-                    }
-                });
-                if (!stopPropagation) {
-                    this.events.dispatch(this.events.change, this._currentIndex, prevCurrIndex);
-                }
-            }
-        }
-    }
-}

package/lib/js/control/LayerSwitcher.d.ts

@@ -1,38 +0,0 @@
-import { Control } from "./Control";
-import type { IControlParams } from "./Control";
-import { Dialog } from "../ui/Dialog";
-import { Layer } from "../layer/Layer";
-import { ToggleButton } from "../ui/ToggleButton";
-import { View } from "../ui/View";
-import type { IViewParams } from "../ui/View";
-interface ILayerSwitcherParams extends IControlParams {
-}
-declare class LayerButtonView extends View<Layer> {
-    constructor(params: IViewParams);
-    render(params?: any): this;
-    protected _onVisibilityChange: (layer: Layer) => void;
-    protected _onClick: () => void;
-    protected _onDblClick: () => void;
-    remove(): void;
-}
-/**
- * Advanced :) layer switcher, includes base layers, overlays, geo images etc. groups.
- * Double click for zoom, drag-and-drop to change zIndex
- */
-export declare class LayerSwitcher extends Control {
-    protected _dialog: Dialog<null>;
-    protected _toggleBtn: ToggleButton;
-    protected _panel: View<null>;
-    $baseLayers: HTMLElement | null;
-    $overlays: HTMLElement | null;
-    _layerViews: LayerButtonView[];
-    constructor(options?: ILayerSwitcherParams);
-    oninit(): void;
-    protected _initLayers(): void;
-    protected _createLayerButton(layer: Layer): LayerButtonView;
-    addLayer: (layer: Layer) => void;
-    removeLayer: (layer: Layer) => void;
-    onactivate(): void;
-    ondeactivate(): void;
-}
-export {};