raain-ui 1.0.15

package/layers/PixiGridLayer.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixiGridLayer = void 0;
+const leaflet_1 = require("leaflet");
+const pixi_js_1 = require("pixi.js");
+function setInteractionManager(interactionManager, destroyInteractionManager, autoPreventDefault) {
+    if (destroyInteractionManager) {
+        interactionManager.destroy();
+    }
+    else if (!autoPreventDefault) {
+        interactionManager.autoPreventDefault = false;
+    }
+}
+class ApplicationOptions {
+}
+class PixiGridLayer extends leaflet_1.GridLayer {
+    constructor(id) {
+        super();
+        this._id = id;
+        this._lastUpdate = new Date('01-01-01');
+        this._gridOptions = {
+            // @option padding: Number = 0.1
+            // How much to extend the clip area around the map view (relative to its size)
+            // e.g. 0.1 would be 10% of map view in each direction
+            padding: 0,
+            // @option forceCanvas: Boolean = false
+            // Force use of a 2d-canvas
+            forceCanvas: true,
+            // @option doubleBuffering: Boolean = false
+            // Help to prevent flicker when refreshing display on some devices (e.g. iOS devices)
+            // It is ignored if rendering is done with 2d-canvas
+            doubleBuffering: false,
+            // @option resolution: Number = 1
+            // Resolution of the renderer canvas
+            resolution: leaflet_1.Browser.retina ? 2 : 1,
+            // @option projectionZoom(map: map): Number
+            // return the layer projection zoom level
+            projectionZoom: (map) => {
+                return (map.getMaxZoom() + map.getMinZoom()) / 2;
+            },
+            // @option destroyInteractionManager:  Boolean = false
+            // Destroy PIXI Interaction Manager
+            destroyInteractionManager: false,
+            // @option
+            // Customize PIXI Interaction Manager autoPreventDefault property
+            // This option is ignored if destroyInteractionManager is set
+            autoPreventDefault: true,
+            // @option resolution: Boolean = false
+            // Enables drawing buffer preservation
+            preserveDrawingBuffer: false,
+            // @option resolution: Boolean = true
+            // Clear the canvas before the new render pass
+            clearBeforeRender: true,
+            // @option shouldRedrawOnMove(e: moveEvent): Boolean
+            // filter move events that should trigger a layer redraw
+            shouldRedrawOnMove: () => {
+                return false;
+            },
+        };
+        this.renderFn = (pixiContainer) => {
+        };
+    }
+    // @Override
+    onAdd(targetMap) {
+        // console.log('PIGL onAdd New: ', this._id);
+        super.onAdd(targetMap);
+        this._setMap(targetMap);
+        if (!this._gridContainer) {
+            const container = this._gridContainer = leaflet_1.DomUtil.create('div', 'leaflet-pixi-overlay');
+            container.appendChild(this._gridRenderer.view);
+        }
+        this._addContainer();
+        this._setEvents();
+        this._gridInitialZoom = this._gridOptions.projectionZoom(this._gridMap);
+        this._gridWgsOrigin = (0, leaflet_1.latLng)([0, 0]);
+        this._gridWgsInitialShift = this._gridMap.project(this._gridWgsOrigin, this._gridInitialZoom);
+        this._gridMapInitialZoom = this._gridMap.getZoom();
+        return this;
+    }
+    // @Override
+    onRemove(targetMap) {
+        // console.log('PIGL onRemove New', this._id);
+        super.onRemove(targetMap);
+        const pane = this._gridMap.getPanes()[this._getPaneName()];
+        if (pane && pane.children.length > 0) {
+            pane.removeChild(this._gridContainer);
+        }
+        const events = this.getEvents();
+        // tslint:disable-next-line:forin
+        for (const evt in events) {
+            this._gridMap.off(evt, events[evt], this);
+        }
+        this.pixiApp.destroy();
+        this._gridContainer = null;
+        this._pixiContainer = null;
+        this._gridRenderer = this;
+        return this;
+    }
+    setCurrentWidth(currentWidth) {
+        this.currentWidth = currentWidth;
+    }
+    setCurrentHeight(currentHeight) {
+        this.currentHeight = currentHeight;
+    }
+    setRenderFn(fn) {
+        this.renderFn = fn;
+    }
+    _initializeLayer() {
+        // console.log('_initializeLayer');
+        this._gridRendererOptions = {
+            // backgroundAlpha: 0.5,
+            transparent: true,
+            width: this.currentWidth,
+            height: this.currentHeight,
+            // forceCanvas: this._gridOptions.forceCanvas,
+            // preserveDrawingBuffer: this._gridOptions.preserveDrawingBuffer,
+            // clearBeforeRender: this._gridOptions.clearBeforeRender
+        };
+        // utils.isWebGLSupported() && !this._gridOptions.forceCanvas && this._gridOptions.doubleBuffering;
+        this._gridDoubleBuffering = false;
+        this.pixiApp = new pixi_js_1.Application(this._gridRendererOptions);
+        this._pixiContainer = this.pixiApp.stage;
+        this._gridRenderer = this.pixiApp.renderer;
+    }
+    // @Override
+    _update() {
+        // @ts-ignore
+        super._update();
+        if (!this._gridMap || !this._gridContainer) {
+            return;
+        }
+        // console.log('PIGL _update', this._gridMap.getPixelOrigin(), this._gridMap.getPixelBounds().min);
+        const pt = this._gridMap.getPixelBounds().min.subtract(this._gridMap.getPixelOrigin());
+        // console.log('pt:', pt);
+        leaflet_1.DomUtil.setPosition(this._gridContainer, pt);
+        this._layerRedraw();
+    }
+    setMeAsFirst() {
+        // const mapNode = this._gridMap.getPanes()[this._getPaneName()];
+        // this._gridContainer.parentNode.insertBefore(this._gridContainer, mapNode.childNodes[0]);
+        // console.log('setMeAsFirst', this._getPaneName());
+        for (const paneName of Object.getOwnPropertyNames(this._gridMap.getPanes())) {
+            const pane = this._gridMap.getPanes()[paneName];
+            if (paneName === this._getPaneName()) {
+                pane.style.visibility = 'visible';
+            }
+            else {
+                pane.style.visibility = 'hidden';
+            }
+        }
+    }
+    isFirst() {
+        const mapNode = this._gridMap.getPanes()[this._getPaneName()];
+        return mapNode.childNodes[0].nodeName === this._getPaneName();
+    }
+    _setMap(map) {
+        this._gridMap = map;
+        this._gridZoomAnimated = map._gridZoomAnimated;
+    }
+    _addContainer() {
+        this._gridMap.getPanes()[this._getPaneName()]
+            .appendChild(this._gridContainer);
+    }
+    _setEvents() {
+        const events = ['zoomend', 'viewreset'];
+        // const events = this.getEvents();
+        // tslint:disable-next-line:forin
+        for (const evt in events) {
+            // this._gridMap.on(evt, events[evt], this);
+            this._gridMap.on(evt, this._update, this);
+        }
+    }
+    _getPaneName() {
+        return this._gridOptions.pane || 'overlayPane';
+    }
+    _layerRedraw(offset) {
+        // const now = new Date();
+        // if (this._lastUpdate.getTime() > (now.getTime() - 500)) {
+        //     console.log('_layerRedraw already refreshed');
+        //     return;
+        // }
+        // this._lastUpdate = now;
+        //  console.log('_layerRedraw', offset, this._gridWgsOrigin);
+        this.renderFn(this._pixiContainer);
+    }
+}
+exports.PixiGridLayer = PixiGridLayer;
+//# sourceMappingURL=data:application/json;base64,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

package/layers/PolarLayer.d.ts

@@ -0,0 +1,26 @@
+import { LatLng, Map } from 'leaflet';
+import { Container } from 'pixi.js';
+import { PolarMapValue } from '../tools/PolarMapValue';
+import { PolarLayerConfig } from './PolarLayerConfig';
+import { IPixiUniqueLayer } from './IPixiUniqueLayer';
+export declare class PolarLayer implements IPixiUniqueLayer {
+    protected id: string;
+    protected type: string;
+    protected gridMap: Map;
+    protected addSomeDebugInfos: boolean;
+    private readonly mapGraph;
+    private polarDrawer;
+    private center;
+    private readonly config;
+    private addedInContainer;
+    constructor(id: string, type: string, gridMap: Map, addSomeDebugInfos?: boolean);
+    getId(): string;
+    hide(): void;
+    show(): void;
+    isVisible(): boolean;
+    setPolarValues(center: LatLng | {
+        lat: number;
+        lng: number;
+    }, geoValues: PolarMapValue[], config: PolarLayerConfig, version: string): void;
+    render(pixiContainer: Container): number;
+}

package/layers/PolarLayer.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolarLayer = void 0;
+const leaflet_1 = require("leaflet");
+const pixi_js_1 = require("pixi.js");
+const PolarDrawer_1 = require("../drawers/PolarDrawer");
+const PolarLayerConfig_1 = require("./PolarLayerConfig");
+const PolarDrawerOptimization_1 = require("../drawers/PolarDrawerOptimization");
+const MapTools_1 = require("../tools/MapTools");
+class PolarLayer {
+    constructor(id, type, gridMap, addSomeDebugInfos = false) {
+        this.id = id;
+        this.type = type;
+        this.gridMap = gridMap;
+        this.addSomeDebugInfos = addSomeDebugInfos;
+        this.mapGraph = new pixi_js_1.Graphics();
+        this.config = new PolarLayerConfig_1.PolarLayerConfig();
+    }
+    getId() {
+        return this.id;
+    }
+    hide() {
+        this.mapGraph.alpha = 0;
+        // console.log('hide ', this.getId());
+    }
+    show() {
+        this.mapGraph.alpha = 1;
+        // console.log('show ', this.getId());
+    }
+    isVisible() {
+        return this.mapGraph.alpha === 1;
+    }
+    setPolarValues(center, geoValues, config, version) {
+        this.center = new leaflet_1.LatLng(center.lat, center.lng);
+        this.config.copy(config);
+        this.polarDrawer = new PolarDrawer_1.PolarDrawer((polar) => {
+            polar.setCenter({ latitude: center.lat, longitude: center.lng });
+            const latLng = new leaflet_1.LatLng(polar.getLatitude(), polar.getLongitude());
+            return this.gridMap.latLngToContainerPoint(latLng);
+        }, (polar) => {
+            if (this.config.minValueToDisplay > polar.value) {
+                return false;
+            }
+            polar.setCenter({ latitude: center.lat, longitude: center.lng });
+            const latLng = new leaflet_1.LatLng(polar.getLatitude(), polar.getLongitude());
+            return this.gridMap.getBounds().contains(latLng);
+        }, () => {
+            return this.gridMap.getZoom();
+        }, this.type);
+        const optimizations = PolarDrawerOptimization_1.PolarDrawerOptimization.Defaults();
+        this.polarDrawer.setConfiguration(this.config.theme, this.config.range, optimizations);
+        this.polarDrawer.updateValues(geoValues, version);
+    }
+    render(pixiContainer) {
+        const centerPoint = this.gridMap.latLngToContainerPoint(this.center);
+        // console.log('Polar render ', this.polarDrawer.hasChanged(this.center, centerPoint), this.getId());
+        if (!this.polarDrawer || !this.polarDrawer.hasChanged(this.center, centerPoint)) {
+            return 0;
+        }
+        this.mapGraph.removeChildren();
+        const polar2radians = (polar) => {
+            let degrees = polar.polarAzimuthInDegrees - 90;
+            if (degrees < 0) {
+                degrees += 360;
+            }
+            return degrees * (Math.PI / 180);
+        };
+        const drawPolarSharp = (polar1, polar2) => {
+            const pixiGraphic = new pixi_js_1.Graphics();
+            if (!polar2) {
+                const point1 = polar1.getPositionFrom(centerPoint);
+                const polar1alpha = 1 - polar1.getTransparency(this.config.opacity);
+                pixiGraphic.lineStyle(10, polar1.getColor(), polar1alpha);
+                pixiGraphic.drawCircle(point1.x, point1.y, 1);
+                this.mapGraph.addChild(pixiGraphic);
+                return true;
+            }
+            // TODO pixi arc is not working as expected
+            const polar1Distance = polar1.getPolarDistanceRelative();
+            const polar2Distance = polar2.getPolarDistanceRelative();
+            const width = Math.abs(polar2Distance - polar1Distance);
+            if (width <= 0) {
+                return false;
+            }
+            const alpha = 1 - polar1.getTransparency(this.config.opacity);
+            // pixiGraphic.lineStyle(width, polar1.getColor(), alpha);
+            pixiGraphic.lineStyle(1, polar1.getColor(), alpha);
+            let rad1 = polar2radians(polar1);
+            let rad2 = polar2radians(polar2);
+            if (rad1 === rad2 || rad1 === rad2 + 2 * Math.PI) {
+                rad1 = 0;
+                rad2 = 2 * Math.PI;
+            }
+            pixiGraphic.arc(0, 0, width / 2, rad1, rad2);
+            pixiGraphic.position.x = centerPoint.x;
+            pixiGraphic.position.y = centerPoint.y;
+            // console.log('polar:', centerPoint, point1, point2);
+            this.mapGraph.addChild(pixiGraphic);
+            return true;
+        };
+        const drawCount = this.polarDrawer.renderPolarMapValues(this.center, centerPoint, drawPolarSharp);
+        // console.log(this.id, ' drawCount : ', drawCount);
+        if (!this.addedInContainer) {
+            // console.log(this.id, ' addedInContainer.');
+            pixiContainer.addChild(this.mapGraph);
+            this.addedInContainer = true;
+        }
+        // Debug purpose :
+        if (this.addSomeDebugInfos) {
+            const optimization = this.polarDrawer.getOptimization();
+            const pixiText = new pixi_js_1.Text('Pol-' + (optimization === null || optimization === void 0 ? void 0 : optimization.type) + '-' + this.polarDrawer.getVersion(), {
+                fontFamily: 'Arial',
+                fontSize: 16,
+                // fontWeight: 'bold',
+                fill: MapTools_1.MapTools.hexStringToNumber('#3cff10'),
+                align: 'center',
+            });
+            this.mapGraph.addChild(pixiText);
+        }
+        return drawCount;
+    }
+}
+exports.PolarLayer = PolarLayer;
+//# sourceMappingURL=data:application/json;base64,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

package/layers/PolarLayerConfig.d.ts

@@ -0,0 +1,9 @@
+export declare class PolarLayerConfig {
+    optimization?: number;
+    theme?: number;
+    range?: number;
+    opacity?: number;
+    minValueToDisplay?: number;
+    constructor(optimization?: number, theme?: number, range?: number, opacity?: number, minValueToDisplay?: number);
+    copy(from: PolarLayerConfig): PolarLayerConfig;
+}

package/layers/PolarLayerConfig.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolarLayerConfig = void 0;
+class PolarLayerConfig {
+    constructor(optimization, theme, range, opacity, minValueToDisplay) {
+        this.optimization = optimization;
+        this.theme = theme;
+        this.range = range;
+        this.opacity = opacity;
+        this.minValueToDisplay = minValueToDisplay;
+    }
+    copy(from) {
+        if (typeof from.optimization !== 'undefined') {
+            this.optimization = from.optimization;
+        }
+        if (typeof from.theme !== 'undefined') {
+            this.theme = from.theme;
+        }
+        if (typeof from.range !== 'undefined') {
+            this.range = from.range;
+        }
+        if (typeof from.opacity !== 'undefined') {
+            this.opacity = from.opacity;
+        }
+        if (typeof from.minValueToDisplay !== 'undefined') {
+            this.minValueToDisplay = from.minValueToDisplay;
+        }
+        return this;
+    }
+}
+exports.PolarLayerConfig = PolarLayerConfig;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUG9sYXJMYXllckNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sYXllcnMvUG9sYXJMYXllckNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxNQUFhLGdCQUFnQjtJQUN6QixZQUNXLFlBQXFCLEVBQ3JCLEtBQWMsRUFDZCxLQUFjLEVBQ2QsT0FBZ0IsRUFDaEIsaUJBQTBCO1FBSjFCLGlCQUFZLEdBQVosWUFBWSxDQUFTO1FBQ3JCLFVBQUssR0FBTCxLQUFLLENBQVM7UUFDZCxVQUFLLEdBQUwsS0FBSyxDQUFTO1FBQ2QsWUFBTyxHQUFQLE9BQU8sQ0FBUztRQUNoQixzQkFBaUIsR0FBakIsaUJBQWlCLENBQVM7SUFFckMsQ0FBQztJQUVELElBQUksQ0FBQyxJQUFzQjtRQUN2QixJQUFJLE9BQU8sSUFBSSxDQUFDLFlBQVksS0FBSyxXQUFXLEVBQUU7WUFDMUMsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDO1NBQ3pDO1FBQ0QsSUFBSSxPQUFPLElBQUksQ0FBQyxLQUFLLEtBQUssV0FBVyxFQUFFO1lBQ25DLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQztTQUMzQjtRQUNELElBQUksT0FBTyxJQUFJLENBQUMsS0FBSyxLQUFLLFdBQVcsRUFBRTtZQUNuQyxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUM7U0FDM0I7UUFDRCxJQUFJLE9BQU8sSUFBSSxDQUFDLE9BQU8sS0FBSyxXQUFXLEVBQUU7WUFDckMsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDO1NBQy9CO1FBQ0QsSUFBSSxPQUFPLElBQUksQ0FBQyxpQkFBaUIsS0FBSyxXQUFXLEVBQUU7WUFDL0MsSUFBSSxDQUFDLGlCQUFpQixHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQztTQUNuRDtRQUNELE9BQU8sSUFBSSxDQUFDO0lBQ2hCLENBQUM7Q0FDSjtBQTVCRCw0Q0E0QkMifQ==

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "raain-ui",
+  "version": "1.0.15",
+  "author": "contact@raain.io",
+  "homepage": "https://github.com/raainio/raain-ui",
+  "description": "raain.io ui layers",
+  "keywords": [
+    "raain.io",
+    "pixi"
+  ],
+  "private": false,
+  "license": "MIT",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "dependencies": {
+    "chart.js": "^4.2.1",
+    "chartjs-plugin-dragdata": "^2.2.5",
+    "geolib": "^3.3.3",
+    "leaflet": "^1.9.3",
+    "pixi.js": "^5.3.12",
+    "raain-model": "file:../raain-model/dist"
+  },
+  "peerDependencies": {
+    "chart.js": "^4.2.1",
+    "chartjs-plugin-dragdata": "^2.2.5",
+    "leaflet": "^1.9.3",
+    "pixi.js": "^5.3.12"
+  },
+  "devDependencies": {
+    "@testdeck/mocha": "^0.3.3",
+    "@types/leaflet": "^1.9.3",
+    "@types/mocha": "^10.0.1",
+    "assert": "^2.0.0",
+    "chai": "4.3.4",
+    "chai-as-promised": "^7.1.1",
+    "chai-spies": "^1.0.0",
+    "mocha": "^10.2.0",
+    "mock-browser": "^0.92.14",
+    "nyc": "^15.1.0",
+    "ts-mockito": "^2.6.1",
+    "ts-node": "^8.3.0",
+    "tslint": "^5.20.1",
+    "typescript": "^5.0.3"
+  },
+  "scripts": {
+    "build": "rm -rf dist/ && npm version patch --no-git-tag-version && tsc --project tsconfig.json && cp *.md dist/ && cp package.json dist/",
+    "test": "nyc ./node_modules/.bin/_mocha --require ./tools/register.js 'specs/**/**.spec.ts'"
+  }
+}

package/timeframes/FrameContainer.d.ts

@@ -0,0 +1,9 @@
+import { PolarMapValue } from '../tools/PolarMapValue';
+import { CartesianMapValue } from '../tools/CartesianMapValue';
+export declare class FrameContainer {
+    date: Date;
+    values: PolarMapValue[] | CartesianMapValue[];
+    isPolar: boolean;
+    isCartesian: boolean;
+    constructor(date: Date, values: PolarMapValue[] | CartesianMapValue[], isPolar?: boolean, isCartesian?: boolean);
+}

package/timeframes/FrameContainer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameContainer = void 0;
+class FrameContainer {
+    constructor(date, values, isPolar = false, isCartesian = false) {
+        this.date = date;
+        this.values = values;
+        this.isPolar = isPolar;
+        this.isCartesian = isCartesian;
+    }
+}
+exports.FrameContainer = FrameContainer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRnJhbWVDb250YWluZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGltZWZyYW1lcy9GcmFtZUNvbnRhaW5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFHQSxNQUFhLGNBQWM7SUFFdkIsWUFBbUIsSUFBVSxFQUNWLE1BQTZDLEVBQzdDLFVBQW1CLEtBQUssRUFDeEIsY0FBdUIsS0FBSztRQUg1QixTQUFJLEdBQUosSUFBSSxDQUFNO1FBQ1YsV0FBTSxHQUFOLE1BQU0sQ0FBdUM7UUFDN0MsWUFBTyxHQUFQLE9BQU8sQ0FBaUI7UUFDeEIsZ0JBQVcsR0FBWCxXQUFXLENBQWlCO0lBQy9DLENBQUM7Q0FFSjtBQVJELHdDQVFDIn0=

package/timeframes/TimeframeContainer.d.ts

@@ -0,0 +1,12 @@
+import { FrameContainer } from './FrameContainer';
+import { CompositeLayer } from '../layers/CompositeLayer';
+export declare class TimeframeContainer {
+    name: string;
+    timeframe: FrameContainer[];
+    version: string;
+    protected compositeLayer: CompositeLayer;
+    constructor(name: string, timeframe: FrameContainer[], version: string);
+    setCompositeLayer(compositeLayer: any): void;
+    showTimeframe(date?: Date): void;
+    getFrameId(frameContainer: FrameContainer): string;
+}

package/timeframes/TimeframeContainer.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeframeContainer = void 0;
+class TimeframeContainer {
+    constructor(name, timeframe, version) {
+        this.name = name;
+        this.timeframe = timeframe;
+        this.version = version;
+    }
+    setCompositeLayer(compositeLayer) {
+        this.compositeLayer = compositeLayer;
+    }
+    showTimeframe(date) {
+        if (!this.compositeLayer) {
+            return;
+        }
+        let index = 0;
+        let frameContainerFound = this.timeframe.length ? this.timeframe[0] : null;
+        this.timeframe.forEach(c => {
+            index++;
+            if (new Date(c.date).getTime() === (date === null || date === void 0 ? void 0 : date.getTime())) {
+                frameContainerFound = c;
+            }
+        });
+        if (!!frameContainerFound) {
+            this.compositeLayer.showTheFistMatchingId(this.getFrameId(frameContainerFound));
+        }
+    }
+    getFrameId(frameContainer) {
+        return this.name + new Date(frameContainer.date).toISOString();
+    }
+}
+exports.TimeframeContainer = TimeframeContainer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVGltZWZyYW1lQ29udGFpbmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RpbWVmcmFtZXMvVGltZWZyYW1lQ29udGFpbmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUdBLE1BQWEsa0JBQWtCO0lBSTNCLFlBQW1CLElBQVksRUFDWixTQUEyQixFQUMzQixPQUFlO1FBRmYsU0FBSSxHQUFKLElBQUksQ0FBUTtRQUNaLGNBQVMsR0FBVCxTQUFTLENBQWtCO1FBQzNCLFlBQU8sR0FBUCxPQUFPLENBQVE7SUFDbEMsQ0FBQztJQUVELGlCQUFpQixDQUFDLGNBQWM7UUFDNUIsSUFBSSxDQUFDLGNBQWMsR0FBRyxjQUFjLENBQUM7SUFDekMsQ0FBQztJQUVELGFBQWEsQ0FBQyxJQUFXO1FBRXJCLElBQUksQ0FBQyxJQUFJLENBQUMsY0FBYyxFQUFFO1lBQ3RCLE9BQU87U0FDVjtRQUVELElBQUksS0FBSyxHQUFHLENBQUMsQ0FBQztRQUNkLElBQUksbUJBQW1CLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztRQUMzRSxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRTtZQUN2QixLQUFLLEVBQUUsQ0FBQztZQUNSLElBQUksSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLE9BQU8sRUFBRSxNQUFLLElBQUksYUFBSixJQUFJLHVCQUFKLElBQUksQ0FBRSxPQUFPLEVBQUUsQ0FBQSxFQUFFO2dCQUNoRCxtQkFBbUIsR0FBRyxDQUFDLENBQUM7YUFDM0I7UUFDTCxDQUFDLENBQUMsQ0FBQztRQUVILElBQUksQ0FBQyxDQUFDLG1CQUFtQixFQUFFO1lBQ3ZCLElBQUksQ0FBQyxjQUFjLENBQUMscUJBQXFCLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDLENBQUM7U0FDbkY7SUFDTCxDQUFDO0lBRUQsVUFBVSxDQUFDLGNBQThCO1FBQ3JDLE9BQU8sSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDbkUsQ0FBQztDQUNKO0FBcENELGdEQW9DQyJ9

package/timeframes/TimeframeContainers.d.ts

@@ -0,0 +1,9 @@
+import { TimeframeContainer } from './TimeframeContainer';
+import { RadarNodeMap, RainComputationMap } from 'raain-model';
+export declare class TimeframeContainers {
+    containers: TimeframeContainer[];
+    constructor(containers: TimeframeContainer[]);
+    addFromRadarNodeMap(radarNodeMap: RadarNodeMap, isPolar: boolean): void;
+    addFromRainComputationMap(rainComputationMap: RainComputationMap, isPolar: boolean): void;
+    showTimeframe(name: string, date?: Date): boolean;
+}

package/timeframes/TimeframeContainers.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeframeContainers = void 0;
+const TimeframeContainer_1 = require("./TimeframeContainer");
+const raain_model_1 = require("raain-model");
+const FrameContainer_1 = require("./FrameContainer");
+const PolarMapValue_1 = require("../tools/PolarMapValue");
+const CartesianMapValue_1 = require("../tools/CartesianMapValue");
+class TimeframeContainers {
+    constructor(containers) {
+        this.containers = containers;
+    }
+    addFromRadarNodeMap(radarNodeMap, isPolar) {
+        const radarMeasures = radarNodeMap.getMapData();
+        let frames;
+        if (isPolar) {
+            frames = radarMeasures.map(rm => {
+                let values = [];
+                rm.values.forEach(v => {
+                    const polars = typeof v.polars === 'string' ? JSON.parse(v.polars) : v.polars;
+                    values = values.concat(PolarMapValue_1.PolarMapValue.from(polars));
+                });
+                return new FrameContainer_1.FrameContainer(rm.date, values, true, false);
+            });
+        }
+        else {
+            frames = radarMeasures.map(rm => {
+                let values = [];
+                rm.values.forEach(v => {
+                    const cartesianValues = typeof v.cartesianValues === 'string' ? JSON.parse(v.cartesianValues) : v.cartesianValues;
+                    const cartesianPixelWidth = typeof v.cartesianPixelWidth === 'string' ?
+                        JSON.parse(v.cartesianPixelWidth) : v.cartesianPixelWidth;
+                    values = values.concat(CartesianMapValue_1.CartesianMapValue.From(cartesianValues, cartesianPixelWidth));
+                });
+                return new FrameContainer_1.FrameContainer(rm.date, values, false, true);
+            });
+        }
+        this.containers.push(new TimeframeContainer_1.TimeframeContainer(radarNodeMap.name, frames, radarNodeMap.getVersion()));
+    }
+    addFromRainComputationMap(rainComputationMap, isPolar) {
+        const rainMeasures = rainComputationMap.getMapData();
+        let frames;
+        if (isPolar) {
+            frames = rainMeasures.map(rm => {
+                let values = [];
+                rm.values.forEach(v => {
+                    let polars = v.polars;
+                    if (typeof polars === 'string') {
+                        polars = JSON.parse(polars);
+                    }
+                    polars = polars.map(p => new raain_model_1.MeasureValuePolarContainer(p));
+                    values = values.concat(PolarMapValue_1.PolarMapValue.from(polars));
+                });
+                return new FrameContainer_1.FrameContainer(rm.date, values, true, false);
+            });
+        }
+        else {
+            frames = rainMeasures.map(rm => {
+                let values = [];
+                rm.values.forEach(v => {
+                    let cartesianValues = v.cartesianValues;
+                    if (typeof cartesianValues === 'string') {
+                        cartesianValues = JSON.parse(cartesianValues);
+                    }
+                    cartesianValues = cartesianValues.map(cv => new raain_model_1.CartesianValue(cv.value, cv.lat, cv.lng));
+                    values = values.concat(CartesianMapValue_1.CartesianMapValue.From(cartesianValues, v.cartesianPixelWidth));
+                });
+                return new FrameContainer_1.FrameContainer(rm.date, values, false, true);
+            });
+        }
+        this.containers.push(new TimeframeContainer_1.TimeframeContainer(rainComputationMap.name, frames, rainComputationMap.getVersion()));
+    }
+    showTimeframe(name, date) {
+        for (const container of this.containers) {
+            if (container.name === name) {
+                container.showTimeframe(date);
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.TimeframeContainers = TimeframeContainers;
+//# sourceMappingURL=data:application/json;base64,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

package/tools/CartesianMapValue.d.ts

@@ -0,0 +1,12 @@
+import { CartesianValue } from 'raain-model';
+import { LatLng } from 'raain-quality';
+import { MapLatLng } from './MapLatLng';
+export declare class CartesianMapValue extends MapLatLng {
+    readonly latitude: number;
+    readonly longitude: number;
+    readonly latitude2?: number;
+    readonly longitude2?: number;
+    constructor(value: number, latitude: number, longitude: number, latitude2?: number, longitude2?: number, id?: string, name?: string);
+    static Duplicate(src: CartesianMapValue): CartesianMapValue;
+    static From(cartesianValues: CartesianValue[], widthForMap: LatLng): CartesianMapValue[];
+}