@opengeoweb/webmap 9.14.0 → 9.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeoweb/webmap",
-  "version": "9.14.0",
+  "version": "9.16.0",
   "description": "GeoWeb webmap library for the opengeoweb project",
   "license": "Apache-2.0",
   "repository": {

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

@@ -1,23 +1,26 @@
-/// <reference types="node" />
-import WMImage from './WMImage';
-import WMImageStore from './WMImageStore';
 import WMBBOX from './WMBBOX';
-import { LinkedInfo, LinkedInfoContent, WMPosition } from './types';
+import { LinkedInfo, LinkedInfoContent } from './types';
 import type WMJSMap from './WMJSMap';
-interface InternalCallback {
+export type SharedImageListType = Record<string, CanvasGeoLayer[]>;
+interface CanvasBufferCallbacks {
     beforecanvasstartdraw?: (context: CanvasRenderingContext2D) => void;
     beforecanvasdisplay?: (context: CanvasRenderingContext2D) => void;
     canvasonerror?: (e: LinkedInfo[]) => void;
     aftercanvasdisplay?: (c: CanvasRenderingContext2D) => void;
 }
-interface CanvasBBOX {
+export interface CanvasBBOX {
     left: number;
     right: number;
     top: number;
     bottom: number;
 }
 export interface CanvasGeoLayer {
+    intersect: number;
+    areaFractionClosest: number;
+    areaFraction: number;
     bbox: CanvasBBOX;
+    width: number;
+    height: number;
     opacity: number;
     imageAge: number;
     imageSource: string;
@@ -29,79 +32,75 @@ export interface CanvasGeoLayer {
  */
 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 imagedate, newewst image first.
+ * Sort the imageslist
  * @param imagesList
  * @returns
  */
-export declare const sortByImageDate: (imagesList: CanvasGeoLayer[]) => 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 | undefined;
+export declare const getSortedListOfImages: (imagesList: CanvasGeoLayer[], bbox: CanvasBBOX) => void;
 export default class WMCanvasBuffer {
-    canvas: HTMLCanvasElement;
-    _ctx: CanvasRenderingContext2D;
-    _imageStore: WMImageStore;
-    ready: boolean;
-    layers: CanvasGeoLayer[];
-    _currentbbox: WMBBOX;
-    _currentnewbbox: WMBBOX;
-    _width: number;
-    _height: number;
-    _webMapJS: WMJSMap;
-    nrLoading: number;
-    onLoadReadyFunction: (param: unknown) => void;
-    _internalCallbacks: InternalCallback;
-    srs: string;
-    bbox: WMBBOX;
-    animationFrameRequest: number;
-    timerHandle: NodeJS.Timeout;
-    _errorList: LinkedInfo[];
-    _isBufferLoading: boolean;
-    constructor(webMapJS: WMJSMap, w: number, h: number, internalCallbacks: InternalCallback);
-    getCanvasContext(): CanvasRenderingContext2D;
+    private canvas;
+    private _ctx;
+    private _imageStore;
+    private _ready;
+    private _canvasLayers;
+    private _currentnewbbox;
+    private _width;
+    private _height;
+    private _webMapJS;
+    private _internalCallbacks;
+    private _animationFrameRequest;
+    private _timerHandle;
+    private _errorList;
+    private _isBufferLoading;
+    private _onLoadReadyFunction;
+    private sharedImagesList;
+    constructor(webMapJS: WMJSMap, w: number, h: number, internalCallbacks: CanvasBufferCallbacks);
     /**
      * Triggered by the WMImageStore when an image completes loading
      * @param image
      */
-    imageLoadComplete(image: WMImage): void;
+    private _imageLoadComplete;
+    private _drawCanvasGeoLayer;
+    private _display;
+    private _finishedLoading;
+    private _checkIfLoading;
+    private _isImageStoreLoading;
+    private _getPixelCoordFromGeoCoord;
     /**
-     * Checks if all images are loaded, if so it will call finishedLoading
+     * Made accessible for testing purposes
+     * @returns
+     */
+    getSharedImagesList(): SharedImageListType;
+    /**
+     * 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
+     * @param filterUnsuitableAlternatives When true, images which have an overlap or ratio less then given threshold will be discarded as alternative
+     * @returns A canvasLayer, containing the new image source with its geo properties
+     */
+    getAlternativeImage(imageUrl: string, bbox: CanvasBBOX, filterUnsuitableAlternatives?: boolean): CanvasGeoLayer[];
+    /**
+     * 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
+     */
+    removeAlternativeImage(imageUrl: string): void;
+    /**
+     * Add an image to the sharedimages list
+     * @param newLayer A canvaslayer object to add.
+     */
+    addAlternativeImage(newLayer: CanvasGeoLayer): void;
+    /**
+     * Used to tell the canvas that the map is resized,
+     * @param w
+     * @param h
      * @returns
      */
-    _statDivBufferImageLoaded(): void;
-    reset(): void;
-    _drawImage(canvasLayer: CanvasGeoLayer): void;
-    display(): void;
-    _display(): void;
-    finishedLoading(): void;
     resize(w: string, h: string): void;
+    /**
+     * Reset when a new set of layers have been added
+     */
+    initCanvasLayers(): 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
@@ -112,12 +111,13 @@ export default class WMCanvasBuffer {
      * @param bbox The boundingbox for this layer
      * @returns Void
      */
-    setSrc(layerIndex: number, imageSource: string, linkedInfo: LinkedInfoContent, opacity: number, bbox: WMBBOX): void;
-    checkIfLoading(): void;
-    isImageStoreLoading(): boolean;
-    _getPixelCoordFromGeoCoord(coordinates: WMPosition, b: WMBBOX): WMPosition;
-    setBBOX(newbbox: WMBBOX, loadedbbox: WMBBOX): void;
+    addLayerToCanvas(layerIndex: number, imageSource: string, linkedInfo: LinkedInfoContent, opacity: number, bbox: WMBBOX): void;
+    display(): void;
+    setBBOX(newbbox: WMBBOX): void;
+    /**
+     * Used when the map is destroyed
+     */
     destroy(): void;
-    getBuffer(): HTMLCanvasElement;
+    getHTMLCanvasElement(): HTMLCanvasElement;
 }
 export {};

package/src/lib/components/WMJSMap.d.ts

@@ -1,12 +1,14 @@
 import WMImageStore from './WMImageStore';
 import WMBBOX from './WMBBOX';
 import WMListener from './WMListener';
+import { CanvasBBOX, CanvasGeoLayer } from './WMCanvasBuffer';
 import { proj4 } from './WMJSExternalDependencies';
 import WMJSDimension from './WMJSDimension';
 import MapPin from './WMMapPin';
 import WMLayer from './WMLayer';
 import { AnimationStep, Dimension, LinkedInfo } from './types';
 import { WMMemo } from './WMMemo';
+import type { TileServerDefinition, TileServerSettings } from '../utils';
 export declare const detectLeftButton: (evt: MouseEvent) => boolean;
 export declare const detectRightButton: (evt: MouseEvent) => boolean;
 export declare const getErrorsToDisplay: (canvasErrors: LinkedInfo[], getLayerByServiceAndName: (layerservice: string, layername: string) => WMLayer) => string[];
@@ -61,7 +63,7 @@ export default class WMJSMap {
     updateBBOX: WMBBOX;
     private loadedBBOX?;
     drawnBBOX: WMBBOX;
-    private divBuffer;
+    private canvasLayerBuffer;
     private mapHeader;
     private currentCursor;
     private mapIsActivated;
@@ -117,8 +119,10 @@ export default class WMJSMap {
     private buildLayerDimsBusy;
     isProjectionSupported: (srs: string) => boolean;
     getMapImageStore: WMImageStore;
+    holdShiftToScroll: boolean;
     constructor(_element: HTMLElement);
-    setWMTileRendererTileSettings(_WMTileRendererTileSettings: unknown): void;
+    setWMTileRendererTileSettings(tileRenderSettings: TileServerSettings): void;
+    addWMTileRendererTileSetting(tileRenderSetting: TileServerDefinition): void;
     /**
      * Function which make a component ID which is unique over several WebMapJS instances
      * @param the desired id
@@ -205,6 +209,7 @@ export default class WMJSMap {
         url: string;
         headers: Headers[];
     }[];
+    getAlternativeImage(imageUrl: string, bbox: CanvasBBOX, filterBad?: boolean): CanvasGeoLayer[];
     addLayersToCanvasAndDisplayThem(): void;
     _updateBoundingBox(_mapbbox: WMBBOX, triggerEvent?: boolean): void;
     redrawBuffer(): void;
@@ -287,6 +292,13 @@ export default class WMJSMap {
         x: number;
         y: number;
     };
+    getGeoCoordFromLatLong(coordinates: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
     calculateBoundingBoxAndZoom(lat: number, lng: number): void;
     getLatLongFromPixelCoord(coordinates: {
         x: number;
@@ -314,7 +326,11 @@ export default class WMJSMap {
     zoomToLayer(_layer: WMLayer): void;
     setDefaultBBOX(bbox: WMBBOX): void;
     setBBOX(left: number | WMBBOX, bottom?: number, right?: number, top?: number): boolean;
-    zoomOut(): void;
+    /**
+     *
+     * @param ratio 1.0, meanse zoomout using full boundingbox width, 0.1 means zoom out 10% of full boundingbox width
+     */
+    zoomOut(ratio?: number): void;
     zoomIn(ratio: number): void;
     displayLegendInMap(_displayLegendInMap: boolean): void;
     showBoundingBox(_bbox?: WMBBOX, _mapbbox?: WMBBOX): void;

package/src/lib/components/WMLayer.d.ts

@@ -5,13 +5,17 @@ import WMJSDimension from './WMJSDimension';
 import WMProjection from './WMProjection';
 import { GetCapabilitiesJson } from './WMJSService';
 import { Style, Dimension, LayerProps, GeographicBoundingBox } from './types';
+import type { TileServerSettings } from '../utils/tilesettings';
 export declare enum LayerType {
     mapLayer = "mapLayer",
     baseLayer = "baseLayer",
     overLayer = "overLayer",
     featureLayer = "featureLayer"
 }
-export interface LayerFoundation {
+export interface TiledLayerFoundation {
+    tileServer?: TileServerSettings;
+}
+export interface LayerFoundation extends TiledLayerFoundation {
     acceptanceTimeInMinutes?: number;
     dimensions?: Dimension[];
     enabled?: boolean;

package/src/lib/components/WMTileRenderer.d.ts

@@ -1,7 +1,6 @@
+import type { EPSGCode, TileServerMap, TileSettings } from '../utils';
 import WMBBOX from './WMBBOX';
 import WMImageStore from './WMImageStore';
 export default class WMTileRenderer {
-    render(currentBBOX: WMBBOX, newBBOX: WMBBOX, srs: string, width: number, height: number, ctx: CanvasRenderingContext2D, bgMapImageStore: WMImageStore, tileOptions: any, layerName: string): {
-        attributionText: string;
-    };
+    render(currentBBOX: WMBBOX, newBBOX: WMBBOX, srs: EPSGCode, width: number, height: number, ctx: CanvasRenderingContext2D, bgMapImageStore: WMImageStore, tileOptions: TileServerMap, layerName: string): TileSettings | undefined;
 }

package/src/lib/components/index.d.ts

@@ -7,14 +7,13 @@ import WMImage from './WMImage';
 import { getLegendGraphicURLForLayer, legendImageStore } from './WMLegend';
 import { WMImageEventType } from './WMImageStore';
 import { WMJSService, wmServiceListener } from './WMJSService';
-import { getAlternativeImage } from './WMCanvasBuffer';
 import WMListener from './WMListener';
 export { default as WMJSDimension, handleDateUtilsISOString, } from './WMJSDimension';
 export { default as WMLayer, LayerType } from './WMLayer';
 export type { LayerOptions, LayerFoundation } from './WMLayer';
 export { default as WMBBOX } from './WMBBOX';
 export type { Bbox } from './WMBBOX';
-export { WMJSMap, DateInterval, parseISO8601IntervalToDateInterval, ParseISOTimeRangeDuration, isDefined, WMGetServiceFromStore, WMJScheckURL, URLEncode, URLDecode, parseISO8601DateToDate, I18n, toArray, getLegendGraphicURLForLayer, legendImageStore, WMImage, debugLogger, DebugType, WMImageEventType, WMJSService, getUriWithParam, getAlternativeImage, wmServiceListener, WMListener, };
+export { WMJSMap, DateInterval, parseISO8601IntervalToDateInterval, ParseISOTimeRangeDuration, isDefined, WMGetServiceFromStore, WMJScheckURL, URLEncode, URLDecode, parseISO8601DateToDate, I18n, toArray, getLegendGraphicURLForLayer, legendImageStore, WMImage, debugLogger, DebugType, WMImageEventType, WMJSService, getUriWithParam, wmServiceListener, WMListener, };
 export * from './types';
 export * from './WMTimeTypes';
 export * from './WMConstants';

package/src/lib/utils/tilesettings.d.ts

@@ -9,6 +9,8 @@ export interface TileSettings {
     resolution?: number;
     title?: string;
     tileSize?: number;
+    tileServerFormat?: string;
+    tms?: boolean;
 }
 export declare enum EPSGCode {
     EPSG3857 = "EPSG:3857",
@@ -23,14 +25,14 @@ export declare enum EPSGCode {
     EPSG3575 = "EPSG:3575",
     EPSG3067 = "EPSG:3067"
 }
-type EPSGSettings = {
+export type TileSettingPerProjection = {
     [code in EPSGCode]?: TileSettings;
 };
 export interface Title {
     title?: string;
 }
-export interface MapType extends Title, EPSGSettings {
+export interface TileServerDefinition extends Title, TileSettingPerProjection {
 }
-export type TileServers = Record<string, MapType>;
-export declare const tilesettings: TileServers;
-export {};
+export type TileServerMap = Map<string, TileServerDefinition>;
+export type TileServerSettings = Record<string, TileServerDefinition>;
+export declare const tilesettings: TileServerSettings;