@opengeoweb/webmap 2.0.1

package/README.md

@@ -0,0 +1,11 @@
+![current version](https://img.shields.io/badge/dynamic/json?color=blue&label=version&query=version&url=https://gitlab.com/opengeoweb/opengeoweb/raw/master/libs/webmap/package.json)
+![coverage](https://gitlab.com/opengeoweb/opengeoweb/badges/master/coverage.svg?job=test-webmap)
+
+# webmap
+
+Library with webmap components for the opengeoweb project.
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test webmap` to execute the unit tests via [Jest](https://jestjs.io).

package/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/components';

package/lib/components/WMAnimate.d.ts

@@ -0,0 +1,14 @@
+import type WMJSMap from './WMJSMap';
+export default class WMJSAnimate {
+    private _map;
+    private _divAnimationInfo;
+    private _callBack;
+    private _imageStore;
+    private isNextTimeCloseToWallClockTime;
+    constructor(_map: WMJSMap);
+    _isCurrentAnimationTimeCloseToWallClockTime(): boolean;
+    _animate(): void;
+    _animateLoop(): void;
+    checkAnimation(): void;
+    stopAnimating(): void;
+}

package/lib/components/WMBBOX.d.ts

@@ -0,0 +1,31 @@
+export declare type Bbox = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+export default class WMBBOX {
+    left: number;
+    bottom: number;
+    right: number;
+    top: number;
+    constructor(left?: number | string | Bbox, bottom?: number, right?: number, top?: number);
+    /**
+     * Clone an existing BBOX
+     */
+    clone(): WMBBOX;
+    copy(bbox: WMBBOX): void;
+    /**
+     * setBBOX method
+     * Creates a WebMapJS bounding box based on 4 numeric values
+     * Creates a WebMapJS bounding box based on 1 string with commaseparated numeric values
+     * Creates a WebMapJS bounding box based on an exisiting WebMapJS bounding box.
+     * When no parameters are given, a global latlon bbox is generated.
+     */
+    setBBOX(left?: number | string | Bbox, bottom?: number, right?: number, top?: number): void;
+    equals(left: number | string | WMBBOX, bottom: number, right: number, top: number): boolean;
+    /**
+     * Returns the current BBOX as a string, useful for generating WMS requests.
+     */
+    toString(): string;
+}

package/lib/components/WMBBOX.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/WMCanvasBuffer.d.ts

@@ -0,0 +1,116 @@
+import WMImage from './WMImage';
+import WMImageStore from './WMImageStore';
+import WMBBOX from './WMBBOX';
+import WMListener from './WMListener';
+import { LinkedInfo, LinkedInfoContent, WMPosition } from './types';
+declare type InternalCallback = {
+    beforecanvasstartdraw?: (context: CanvasRenderingContext2D) => void;
+    beforecanvasdisplay?: (context: CanvasRenderingContext2D) => void;
+    canvasonerror?: (e: LinkedInfo[]) => void;
+    aftercanvasdisplay?: (c: CanvasRenderingContext2D) => void;
+};
+interface CanvasBBOX {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export interface CanvasGeoLayer {
+    bbox: CanvasBBOX;
+    opacity: number;
+    imageSource: string;
+}
+/**
+ * Function to find image url's which are similar to other images, without taking width, height and bbox into account
+ * @param imageSource The source / url of the image to check
+ * @returns A signature for this image, which is the same for images with different bbox and or width/height
+ */
+export declare const makeQueryStringWithoutGeoInfo: (imageSource: string) => string;
+/**
+ * Add an image to the sharedimages list
+ * @param newLayer A canvaslayer object to add.
+ */
+export declare const addAlternativeImage: (newLayer: CanvasGeoLayer) => void;
+/**
+ * Removes the image from the alternative imageslist (in case imagestore cache gets cleaned), this used when the imagestore triggers a delete event for an image
+ * @param imageUrl The url for the image to remove
+ */
+export declare const removeAlternativeImage: (imageUrl: string) => void;
+/**
+ * Made accessible for testing purposes
+ * @returns
+ */
+export declare const getSharedImagesList: () => Record<string, CanvasGeoLayer[]>;
+/**
+ * Algorithm two determine how much two bboxes are similar
+ * @param rect1
+ * @param rect2
+ * @returns
+ */
+export declare const geClosestBBox: (rect1: CanvasBBOX, rect2: CanvasBBOX) => number;
+/**
+ * Sort the imageslist by overlapping area, highest area first
+ * @param imagesList
+ * @param bbox
+ * @returns
+ */
+export declare const sortByOverlappingArea: (imagesList: CanvasGeoLayer[], bbox: CanvasBBOX) => CanvasGeoLayer[];
+/**
+ * Function to find the an alternative available image for an image url that is not yet loaded
+ * @param imageUrl The image source / url to find an alternative for
+ * @param imageStore The imagestore where the other images are located
+ * @param bbox The boundingbox to search this image for
+ * @returns A canvasLayer, containing the new image source with its geo properties
+ */
+export declare const getAlternativeImage: (imageUrl: string, imageStore: WMImageStore, bbox: CanvasBBOX) => CanvasGeoLayer;
+export default class WMCanvasBuffer {
+    canvas: HTMLCanvasElement;
+    _ctx: CanvasRenderingContext2D;
+    _imageStore: WMImageStore;
+    ready: boolean;
+    layers: CanvasGeoLayer[];
+    _defaultImage: WMImage;
+    _currentbbox: WMBBOX;
+    _currentnewbbox: WMBBOX;
+    _width: number;
+    _height: number;
+    _webmapJSCallback: WMListener;
+    nrLoading: number;
+    onLoadReadyFunction: (param: any) => void;
+    _internalCallbacks: InternalCallback;
+    srs: string;
+    bbox: WMBBOX;
+    _errorList: LinkedInfo[];
+    constructor(webmapJSCallback: WMListener, _imageStore: WMImageStore, w: number, h: number, internalCallbacks: InternalCallback);
+    getCanvasContext(): CanvasRenderingContext2D;
+    /**
+     * Triggered by the WMImageStore when an image completes loading
+     * @param image
+     */
+    imageLoadComplete(image: WMImage): void;
+    /**
+     * Checks if all images are loaded, if so it will call finishedLoading
+     * @returns
+     */
+    _statDivBufferImageLoaded(): void;
+    reset(): void;
+    _drawImage(canvasLayer: CanvasGeoLayer): void;
+    display(): void;
+    finishedLoading(): void;
+    resize(w: string, h: string): void;
+    /**
+     * Set's a layer inside the canvasbuffer with given index and imagesource.
+     * The image is directly loaded, but if loading is not complete when drawing, an alternative image is search in the alternative images list
+     * @param layerIndex The layer index, similar to z-Index, 0 drawn on the bottom, higher numbers on top
+     * @param imageSource The url of the image, usually a GetMap url
+     * @param linkedInfo A linkedinfo object to track properties for the image and layer, like errors
+     * @param opacity Opacity of this layer
+     * @param bbox The boundingbox for this layer
+     * @returns Void
+     */
+    setSrc(layerIndex: number, imageSource: string, linkedInfo: LinkedInfoContent, opacity: number, bbox: WMBBOX): void;
+    _getPixelCoordFromGeoCoord(coordinates: WMPosition, b: WMBBOX): WMPosition;
+    setBBOX(newbbox: WMBBOX, loadedbbox: WMBBOX): void;
+    getBuffer(): HTMLCanvasElement;
+}
+export {};

package/lib/components/WMCanvasBuffer.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/WMConstants.d.ts

@@ -0,0 +1,28 @@
+export declare const WMEmptyLayerName = "empty_layer";
+export declare const WMEmptyLayerTitle = "empty layer";
+export declare const WMDateOutSideRange = "outside range";
+export declare const WMDateTooEarlyString = "date too early";
+export declare const WMDateTooLateString = "date too late";
+export declare const WMSVersion: {
+    version100: string;
+    version111: string;
+    version130: string;
+};
+export declare const WMProj4Defs: string[][];
+export declare const epsgDescriptionLookup: {
+    'EPSG:3411': string;
+    'EPSG:3412': string;
+    'EPSG:3575': string;
+    'EPSG:3785': string;
+    'EPSG:3857': string;
+    'EPSG:4258': string;
+    'EPSG:4326': string;
+    'CRS:84': string;
+    'EPSG:25831': string;
+    'EPSG:25832': string;
+    'EPSG:28992': string;
+    'EPSG:32661': string;
+};
+export declare const mapImageStoreLength = 1000;
+export declare const bgImageStoreLength = 360;
+export declare const legendImageStoreLength = 500;

package/lib/components/WMDrawMarker.d.ts

@@ -0,0 +1,2 @@
+declare const WMDrawMarker: (context: CanvasRenderingContext2D, coordx: number, coordy: number, fillColor?: string, outlineColor?: string) => void;
+export default WMDrawMarker;

package/lib/components/WMDrawMarker.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/WMFlyToBBox.d.ts

@@ -0,0 +1,22 @@
+import WMBBOX from './WMBBOX';
+import type WMJSMap from './WMJSMap';
+export default class WMFlyToBBox {
+    private wmMap;
+    private flyZoomToBBOXTimerStart;
+    private flyZoomToBBOXTimerSteps;
+    private flyZoomToBBOXTimerLoop;
+    private flyZoomToBBOXDebounced;
+    private flyZoomToBBOXScaler;
+    private flyZoomToBBOXCurrent;
+    flyZoomToBBOXFly: WMBBOX;
+    private flyZoomToBBOXNew;
+    private flyZoomToBBOXContinueNew;
+    private flyZoomToBBOXTimerFuncBusy;
+    private flyZoomToBBOXTimerFuncBusyAndContinue;
+    constructor(wmMap: WMJSMap);
+    flyZoomToBBOXTimerFuncReadyDebounced: () => void;
+    flyZoomToBBOXTimerFunc: () => void;
+    resetBBoxTimer: () => void;
+    flyZoomToBBOXStop: () => void;
+    flyZoomToBBOXStartZoom: (currentbox: WMBBOX, newbox: WMBBOX) => void;
+}

package/lib/components/WMFlyToBBox.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/WMGetServiceFromStore.d.ts

@@ -0,0 +1,3 @@
+import { WMJSService } from './WMJSService';
+declare const WMGetServiceFromStore: (serviceName: string, xml2jsonrequestURL?: string) => WMJSService;
+export default WMGetServiceFromStore;

package/lib/components/WMGlobals.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Global service store for re-use of services
+ */
+export declare const WMServiceStore: any[];
+export declare const WMServiceStoreXML2JSONRequest: {
+    proxy: string;
+};

package/lib/components/WMImage.d.ts

@@ -0,0 +1,72 @@
+export interface WMImageOptions {
+    randomizer?: boolean;
+    headers: Headers[];
+}
+/**
+ * WMImage provides an API to the HTML image element. It is used for caching and easier access to images.
+ */
+export default class WMImage {
+    imageLife: number;
+    randomize: boolean;
+    _srcLoaded: string;
+    _isLoaded: boolean;
+    _isLoading: boolean;
+    _hasError: boolean;
+    srcToLoad: string;
+    loadEventCallback: (image: WMImage) => void;
+    el: HTMLImageElement;
+    headers: Headers[];
+    /**
+     *
+     * @param src Optionally set the source URL to load
+     * @param callback Optionally set the callback function to trigger once image has loaded
+     * @param options Additional options to the image. You can set { randomizer: true } to force unique url's and prevent caching.
+     */
+    constructor(src: string, callback?: (image: WMImage) => void, options?: WMImageOptions);
+    private init;
+    /**
+     * Returns true if the image has been loaded
+     */
+    isLoaded(): boolean;
+    /**
+     * Returns true if the image is still loading
+     */
+    isLoading(): boolean;
+    /**
+     * Set source of image, but it will not load the image yet.
+     * @param src URL of the image to load
+     * @param options WMImageOptions to give to the image
+     */
+    setSource(src: string, options: WMImageOptions): void;
+    /**
+     * Re-intialize the image
+     */
+    clear(): void;
+    /**
+     * Get the URL of the image
+     */
+    getSrc(): string;
+    /**
+     * Check if the image has an error
+     */
+    hasError(): boolean;
+    /**
+     * Start loading the image
+     */
+    load(): void;
+    private _getImageWithHeaders;
+    private _load;
+    private _loadEvent;
+    /**
+     * Get the width of the current image
+     */
+    getWidth(): number;
+    /**
+     * Get the height of the current image
+     */
+    getHeight(): number;
+    /**
+     * Get the HTMLImageElement behind the WMImage
+     */
+    getElement(): HTMLImageElement;
+}

package/lib/components/WMImage.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/WMImageStore.d.ts

@@ -0,0 +1,45 @@
+import WMImage, { WMImageOptions } from './WMImage';
+export declare enum WMImageEventType {
+    Loaded = 0,
+    Deleted = 1
+}
+export default class WMImageStore {
+    imagesbysrc: Record<string, WMImage>;
+    imageLife: number;
+    _imageLifeCounter: number;
+    _loadEventCallbackList: Array<{
+        id: string;
+        callback: (image: WMImage, id: string, imageEventType: WMImageEventType) => void;
+    }>;
+    _maxNumberOfImages: number;
+    _options: {
+        id: string;
+    };
+    emptyImage: WMImage;
+    /**
+     * Constructs a new WMImageStore with given amount of image cache.
+     * @param {*} maxNumberOfImages
+     * @param {*} options
+     */
+    constructor(maxNumberOfImages: number, options: {
+        id: string;
+    });
+    load(imageUrl: string): void;
+    imageLoadEventCallback(_img: WMImage, imageEventType: WMImageEventType): void;
+    /**
+     * Check if we have similar images with the same source in the pipeline
+     */
+    getImageForSrc(src: string): WMImage;
+    clear(): void;
+    addImageEventCallback(callback: (image: WMImage, id: string, imageEventType: WMImageEventType) => void, id: string): void;
+    removeAllEventCallbacks(): void;
+    removeEventCallback(id: string): void;
+    getNumImagesLoading(): number;
+    /**
+     * Get an WMImage object for given URL
+     * @param {*} src The url for the image
+     * @returns WMImage object
+     */
+    getImage(src: string, loadOptions?: WMImageOptions): WMImage;
+}
+export declare const getMapImageStore: WMImageStore;

package/lib/components/WMImageStore.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/WMJSDimension.d.ts

@@ -0,0 +1,89 @@
+interface WMJSDimensionConfig {
+    name?: string;
+    units?: string;
+    values?: string;
+    currentValue?: string;
+    defaultValue?: string;
+    linked?: boolean;
+    unitSymbol?: string;
+    synced?: boolean;
+}
+/**
+ * WMJSDimension Class
+ * Keep all information for a single dimension, like time.
+ * Author : MaartenPlieger (plieger at knmi.nl)
+ * Copyright KNMI
+ */
+export default class WMJSDimension {
+    currentValue: string;
+    defaultValue: string;
+    name: string;
+    units: string;
+    unitSymbol: string;
+    linked: boolean;
+    synced: boolean;
+    used?: boolean;
+    values?: string;
+    timeRangeDuration?: any;
+    private _initialized;
+    private _timeRangeDurationDate;
+    private _allDates;
+    private _type;
+    private _allValues;
+    dimMinValue: string;
+    dimMaxValue: string;
+    dimTimeInterval: any;
+    constructor(config?: WMJSDimensionConfig);
+    generateAllValues(): number[];
+    setTimeValuesForReferenceTime(referenceTimeValueToSet: string, referenceTimeDim: WMJSDimension): void;
+    reInitializeValues(values: string, forceReferenceTimeValue?: boolean): void;
+    initialize(forceothervalues?: any, forceReferenceTimeValue?: boolean): void;
+    /**
+     * Returns the current value of this dimensions.
+     * If a ISO8601 period is set, the getValue will return a timeRange using addTimeRangeDurationToValue instead of a single value
+     */
+    getValue(): string;
+    /**
+     * Set current value of this dimension
+     * @param value The new value for this dimension (string)
+     * @param forceValue When set to false,check if the given value is outside range, and do nothing if this is the case
+     */
+    setValue(value: string, forceValue?: boolean): void;
+    setClosestValue(newValue?: any, evenWhenOutsideRange?: boolean): void;
+    addTimeRangeDurationToValue(value: string): string;
+    setTimeRangeDuration(duration: string): void;
+    getClosestValue(_newValue: string, evenWhenOutsideRange?: boolean): string;
+    /**
+     * Get dimension value for specified index
+     */
+    getValueForIndex(index: number): string;
+    /**
+     * Shorthand functionf or getValueForIndex
+     */
+    get(index: number): string;
+    /**
+     * Returns the first dimension value
+     */
+    getFirstValue(): string;
+    /**
+     * Returns the last dimension value
+     */
+    getLastValue(): string;
+    /**
+     * Get index value for specified value. Returns the index in the store for the given time value, either a date or a iso8601 string can be passes as input.
+     * @param value Either a JS Date object or an ISO8601 String
+     * @return The index of the value.  If outSideOfRangeFlag is false, a valid index will
+     * always be returned. If outSideOfRangeFlag is true: -1 if the index is not in the store,
+     * but is lower than available values, -2 if the index is not in store, but is higher than available values
+     */
+    getIndexForValue(value: string, outSideOfRangeFlag?: boolean): number;
+    /**
+     * Get number of values
+     */
+    size(): number;
+    /**
+     * Clone this dimension
+     */
+    clone(): WMJSDimension;
+}
+export {};

package/lib/components/WMJSDimension.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/WMJSExternalDependencies.d.ts

@@ -0,0 +1,3 @@
+import * as moment from 'moment';
+import proj4 from 'proj4';
+export { moment, proj4 };