mobility-toolbox-js 3.0.0-beta.7 → 3.0.0-beta.9

package/ol/mixins/MobilityLayerMixin.d.ts

@@ -0,0 +1,98 @@
+import { Layer } from 'ol/layer';
+import { PropertiesLayerMixinOptions } from './PropertiesLayerMixin';
+export type MobilityLayerOptions = PropertiesLayerMixinOptions & {
+    [x: string]: any;
+};
+type GConstructor<T = {}> = new (...args: any[]) => T;
+export type Layerable = GConstructor<Omit<Layer, keyof string>>;
+declare function MobilityLayerMixin<TBase extends Layerable>(Base: TBase): {
+    new (...args: any[]): {
+        options?: PropertiesLayerMixinOptions | undefined;
+        olListenersKeys: import("ol/events").EventsKey[];
+        children: Layer<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>[];
+        get copyrights(): string;
+        set copyrights(newCopyrights: string | string[]);
+        disabled: boolean;
+        readonly group: string;
+        readonly hitTolerance: boolean;
+        readonly key: string;
+        readonly map: import("ol/Map").default;
+        readonly name: string;
+        olLayer: Layer<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>;
+        parent: Layer<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>;
+        visible: boolean;
+        setMapInternal: ((map: import("ol/Map").default) => void) & ((map: import("ol/Map").default | null) => void);
+        onChildrenChange(oldValue: Layer<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>[]): void;
+        attachToMap(map: import("ol/Map").default): void;
+        detachFromMap(): void;
+        flat(): any[];
+        addEventListener: (type: string, listener: import("ol/events").Listener) => void;
+        removeEventListener: (type: string, listener: import("ol/events").Listener) => void;
+        on: import("ol/layer/Layer").LayerOnSignature<import("ol/events").EventsKey>;
+        render: (frameState: import("ol/Map").FrameState | null, target: HTMLElement) => HTMLElement | null;
+        once: import("ol/layer/Layer").LayerOnSignature<import("ol/events").EventsKey>;
+        un: import("ol/layer/Layer").LayerOnSignature<void>;
+        getSource: () => import("ol/source/Source").default | null;
+        getRenderSource: () => import("ol/source/Source").default | null;
+        getFeatures: (pixel: import("ol/pixel").Pixel) => Promise<import("ol/Feature").FeatureLike[]>;
+        getData: (pixel: import("ol/pixel").Pixel) => Float32Array | Uint8ClampedArray | Uint8Array | DataView | null;
+        isVisible: (view?: import("ol/View").default | import("ol/View").ViewStateLayerStateExtent | undefined) => boolean;
+        getAttributions: (view?: import("ol/View").default | import("ol/View").ViewStateLayerStateExtent | undefined) => string[];
+        unrender: () => void;
+        getDeclutter: () => string;
+        renderDeclutter: (frameState: import("ol/Map").FrameState, layerState: import("ol/layer/Layer").State) => void;
+        renderDeferred: (frameState: import("ol/Map").FrameState) => void;
+        getMapInternal: () => import("ol/Map").default | null;
+        setMap: (map: import("ol/Map").default | null) => void;
+        setSource: (source: import("ol/source/Source").default | null) => void;
+        getRenderer: () => import("ol/renderer/Layer").default<any> | null;
+        hasRenderer: () => boolean;
+        getBackground: () => false | import("ol/layer/Base").BackgroundColor;
+        getClassName: () => string;
+        getLayerState: (managed?: boolean | undefined) => import("ol/layer/Layer").State;
+        getLayersArray: (array?: Layer<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>[] | undefined) => Layer<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>[];
+        getLayerStatesArray: (states?: import("ol/layer/Layer").State[] | undefined) => import("ol/layer/Layer").State[];
+        getExtent: () => import("ol/extent").Extent | undefined;
+        getMaxResolution: () => number;
+        getMinResolution: () => number;
+        getMinZoom: () => number;
+        getMaxZoom: () => number;
+        getOpacity: () => number;
+        getSourceState: () => import("ol/source/Source").State;
+        getVisible: () => boolean;
+        getZIndex: () => number | undefined;
+        setBackground: (background?: import("ol/layer/Base").BackgroundColor | undefined) => void;
+        setExtent: (extent: import("ol/extent").Extent | undefined) => void;
+        setMaxResolution: (maxResolution: number) => void;
+        setMinResolution: (minResolution: number) => void;
+        setMaxZoom: (maxZoom: number) => void;
+        setMinZoom: (minZoom: number) => void;
+        setOpacity: (opacity: number) => void;
+        setVisible: (visible: boolean) => void;
+        setZIndex: (zindex: number) => void;
+        get: (key: string) => any;
+        getKeys: () => string[];
+        getProperties: () => {
+            [x: string]: any;
+        };
+        getPropertiesInternal: () => {
+            [x: string]: any;
+        } | null;
+        hasProperties: () => boolean;
+        notify: (key: string, oldValue: any) => void;
+        addChangeListener: (key: string, listener: import("ol/events").Listener) => void;
+        removeChangeListener: (key: string, listener: import("ol/events").Listener) => void;
+        set: (key: string, value: any, silent?: boolean | undefined) => void;
+        setProperties: (values: {
+            [x: string]: any;
+        }, silent?: boolean | undefined) => void;
+        unset: (key: string, silent?: boolean | undefined) => void;
+        changed: () => void;
+        getRevision: () => number;
+        dispatchEvent: (event: string | import("ol/events/Event").default) => boolean | undefined;
+        getListeners: (type: string) => import("ol/events").Listener[] | undefined;
+        hasListener: (type?: string | undefined) => boolean;
+        dispose: () => void;
+    };
+} & TBase;
+export default MobilityLayerMixin;

package/ol/mixins/MobilityLayerMixin.js

@@ -1,9 +1,6 @@
 import PropertiesLayerMixin from './PropertiesLayerMixin';
 function MobilityLayerMixin(Base) {
-    return class extends PropertiesLayerMixin(Base) {
-        constructor(options = {}) {
-            super(options);
-        }
+    return class MobilityLayer extends PropertiesLayerMixin(Base) {
     };
 }
 export default MobilityLayerMixin;

package/ol/mixins/PropertiesLayerMixin.d.ts

@@ -0,0 +1,127 @@
+import { Layer } from 'ol/layer';
+import { EventsKey } from 'ol/events';
+import { Map } from 'ol';
+import type { Options } from 'ol/layer/Layer';
+import type { Layerable } from './MobilityLayerMixin';
+export type PropertiesLayerMixinOptions = Options & {
+    key?: string;
+    name?: string;
+    group?: string;
+    copyrights?: string[];
+    children?: any[];
+    visible?: boolean;
+    disabled?: boolean;
+    hitTolerance?: number;
+    properties?: {
+        [x: string]: any;
+    };
+    map?: Map;
+} & {
+    [x: string]: any;
+};
+/**
+ * This mixin adds some properties to access ol custom properties easily.
+ */
+declare function PropertiesLayerMixin<TBase extends Layerable>(Base: TBase): {
+    new (...args: any[]): {
+        options?: PropertiesLayerMixinOptions | undefined;
+        olListenersKeys: EventsKey[];
+        children: Layer<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>[];
+        get copyrights(): string;
+        set copyrights(newCopyrights: string | string[]);
+        disabled: boolean;
+        readonly group: string;
+        readonly hitTolerance: boolean;
+        readonly key: string;
+        readonly map: Map;
+        readonly name: string;
+        olLayer: Layer<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>;
+        parent: Layer<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>;
+        visible: boolean;
+        setMapInternal(map: Map): void;
+        /** @private */
+        onChildrenChange(oldValue: Layer[]): void;
+        /**
+         * Initialize the layer with the map passed in parameters.
+         *
+         * @param {ol/Map~Map} map A map.
+         */
+        attachToMap(map: Map): void;
+        /**
+         * Terminate what was initialized in init function. Remove layer, events...
+         */
+        detachFromMap(): void;
+        /**
+         * Return the an array containing all the descendants of the layer in a flat array. Including the current layer.
+         */
+        flat(): any[];
+        addEventListener: (type: string, listener: import("ol/events").Listener) => void;
+        removeEventListener: (type: string, listener: import("ol/events").Listener) => void;
+        on: import("ol/layer/Layer").LayerOnSignature<EventsKey>;
+        render: (frameState: import("ol/Map").FrameState | null, target: HTMLElement) => HTMLElement | null;
+        once: import("ol/layer/Layer").LayerOnSignature<EventsKey>;
+        un: import("ol/layer/Layer").LayerOnSignature<void>;
+        getSource: () => import("ol/source/Source").default | null;
+        getRenderSource: () => import("ol/source/Source").default | null;
+        getFeatures: (pixel: import("ol/pixel").Pixel) => Promise<import("ol/Feature").FeatureLike[]>;
+        getData: (pixel: import("ol/pixel").Pixel) => Float32Array | Uint8ClampedArray | Uint8Array | DataView | null;
+        isVisible: (view?: import("ol/View").default | import("ol/View").ViewStateLayerStateExtent | undefined) => boolean;
+        getAttributions: (view?: import("ol/View").default | import("ol/View").ViewStateLayerStateExtent | undefined) => string[];
+        unrender: () => void;
+        getDeclutter: () => string;
+        renderDeclutter: (frameState: import("ol/Map").FrameState, layerState: import("ol/layer/Layer").State) => void;
+        renderDeferred: (frameState: import("ol/Map").FrameState) => void;
+        getMapInternal: () => Map | null;
+        setMap: (map: Map | null) => void;
+        setSource: (source: import("ol/source/Source").default | null) => void;
+        getRenderer: () => import("ol/renderer/Layer").default<any> | null;
+        hasRenderer: () => boolean;
+        getBackground: () => false | import("ol/layer/Base").BackgroundColor;
+        getClassName: () => string;
+        getLayerState: (managed?: boolean | undefined) => import("ol/layer/Layer").State;
+        getLayersArray: (array?: Layer<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>[] | undefined) => Layer<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>[];
+        getLayerStatesArray: (states?: import("ol/layer/Layer").State[] | undefined) => import("ol/layer/Layer").State[];
+        getExtent: () => import("ol/extent").Extent | undefined;
+        getMaxResolution: () => number;
+        getMinResolution: () => number;
+        getMinZoom: () => number;
+        getMaxZoom: () => number;
+        getOpacity: () => number;
+        getSourceState: () => import("ol/source/Source").State;
+        getVisible: () => boolean;
+        getZIndex: () => number | undefined;
+        setBackground: (background?: import("ol/layer/Base").BackgroundColor | undefined) => void;
+        setExtent: (extent: import("ol/extent").Extent | undefined) => void;
+        setMaxResolution: (maxResolution: number) => void;
+        setMinResolution: (minResolution: number) => void;
+        setMaxZoom: (maxZoom: number) => void;
+        setMinZoom: (minZoom: number) => void;
+        setOpacity: (opacity: number) => void;
+        setVisible: (visible: boolean) => void;
+        setZIndex: (zindex: number) => void;
+        get: (key: string) => any;
+        getKeys: () => string[];
+        getProperties: () => {
+            [x: string]: any;
+        };
+        getPropertiesInternal: () => {
+            [x: string]: any;
+        } | null;
+        hasProperties: () => boolean;
+        notify: (key: string, oldValue: any) => void;
+        addChangeListener: (key: string, listener: import("ol/events").Listener) => void;
+        removeChangeListener: (key: string, listener: import("ol/events").Listener) => void;
+        set: (key: string, value: any, silent?: boolean | undefined) => void;
+        setProperties: (values: {
+            [x: string]: any;
+        }, silent?: boolean | undefined) => void;
+        unset: (key: string, silent?: boolean | undefined) => void;
+        changed: () => void;
+        getRevision: () => number;
+        dispatchEvent: (event: string | import("ol/events/Event").default) => boolean | undefined;
+        getListeners: (type: string) => import("ol/events").Listener[] | undefined;
+        hasListener: (type?: string | undefined) => boolean;
+        dispose: () => void;
+    };
+} & TBase;
+export default PropertiesLayerMixin;

package/ol/mixins/PropertiesLayerMixin.js

@@ -1,11 +1,10 @@
 import { getUid } from 'ol';
 import getLayersAsFlatArray from '../../common/utils/getLayersAsFlatArray';
 /**
- * This mixin adds some properties to access some ol properties easily ansd also
- * the management of a hierarchy of layers using children, parent and group property.
+ * This mixin adds some properties to access ol custom properties easily.
  */
 function PropertiesLayerMixin(Base) {
-    return class extends Base {
+    return class PropertiesLayer extends Base {
         get children() {
             return this.get('children') || [];
         }
@@ -70,8 +69,9 @@ function PropertiesLayerMixin(Base) {
         set visible(newValue) {
             this.setVisible(newValue);
         }
-        constructor(options) {
+        constructor(...args) {
             var _a;
+            const options = args[0];
             super(options);
             this.options = {};
             this.olListenersKeys = [];
@@ -90,6 +90,7 @@ function PropertiesLayerMixin(Base) {
             this.options = options;
             this.children = options.children || []; // Trigger the on children change event
         }
+        // @ts-expect-error - this is a mixin
         setMapInternal(map) {
             super.setMapInternal(map);
             if (map) {

package/ol/renderers/MaplibreLayerRenderer.d.ts

@@ -0,0 +1,20 @@
+import { FrameState } from 'ol/Map';
+import LayerRenderer from 'ol/renderer/Layer';
+import { Coordinate } from 'ol/coordinate';
+import { FeatureCallback } from 'ol/renderer/vector';
+import { Feature } from 'ol';
+import { Geometry } from 'ol/geom';
+import { Pixel } from 'ol/pixel';
+import type MaplibreLayer from '../layers/MaplibreLayer';
+/**
+ * This class is a renderer for Maplibre Layer to be able to use the native ol
+ * functionnalities like map.getFeaturesAtPixel or map.hasFeatureAtPixel.
+ * @private
+ */
+export default class MaplibreLayerRenderer extends LayerRenderer<MaplibreLayer> {
+    getFeaturesAtCoordinate(coordinate: Coordinate | undefined, hitTolerance?: number): Feature<Geometry>[];
+    prepareFrame(): boolean;
+    renderFrame(frameState: FrameState): HTMLElement | null;
+    getFeatures(pixel: Pixel): Promise<Feature<Geometry>[]>;
+    forEachFeatureAtCoordinate<Feature>(coordinate: Coordinate, frameState: FrameState, hitTolerance: number, callback: FeatureCallback<Feature>): Feature | undefined;
+}

package/ol/renderers/MaplibreStyleLayerRenderer.d.ts

@@ -0,0 +1,20 @@
+import { FrameState } from 'ol/Map';
+import LayerRenderer from 'ol/renderer/Layer';
+import { Coordinate } from 'ol/coordinate';
+import { FeatureCallback } from 'ol/renderer/vector';
+import { Feature } from 'ol';
+import { Geometry } from 'ol/geom';
+import { Pixel } from 'ol/pixel';
+import type { MaplibreStyleLayer } from '../layers';
+/**
+ * This class is a renderer for Maplibre Layer to be able to use the native ol
+ * functionnalities like map.getFeaturesAtPixel or map.hasFeatureAtPixel.
+ * @private
+ */
+export default class MaplibreStyleLayerRenderer extends LayerRenderer<MaplibreStyleLayer> {
+    getFeaturesAtCoordinate(coordinate: Coordinate | undefined, hitTolerance?: number): Feature<Geometry>[];
+    prepareFrame(): boolean;
+    renderFrame(): null;
+    getFeatures(pixel: Pixel): Promise<Feature<Geometry>[]>;
+    forEachFeatureAtCoordinate<Feature>(coordinate: Coordinate, frameState: FrameState, hitTolerance: number, callback: FeatureCallback<Feature>): Feature | undefined;
+}

package/ol/renderers/RealtimeLayerRenderer.d.ts

@@ -0,0 +1,22 @@
+import { FrameState } from 'ol/Map';
+import { Coordinate } from 'ol/coordinate';
+import { FeatureCallback } from 'ol/renderer/vector';
+import { Feature } from 'ol';
+import { Geometry } from 'ol/geom';
+import { Pixel } from 'ol/pixel';
+import CanvasLayerRenderer from 'ol/renderer/canvas/Layer';
+import type RealtimeLayer from '../layers/RealtimeLayer';
+/**
+ * This class is a renderer for Maplibre Layer to be able to use the native ol
+ * functionnalities like map.getFeaturesAtPixel or map.hasFeatureAtPixel.
+ * @private
+ */
+export default class RealtimeLayerRenderer extends CanvasLayerRenderer<RealtimeLayer> {
+    private canvas;
+    prepareFrame(): boolean;
+    renderFrame(frameState: FrameState): HTMLElement;
+    getData(pixel: Pixel): Uint8ClampedArray | null;
+    getFeatures(pixel: Pixel): Promise<Feature<Geometry>[]>;
+    forEachFeatureAtCoordinate<Feature>(coordinate: Coordinate, frameState: FrameState, hitTolerance: number, callback: FeatureCallback<Feature>): Feature | undefined;
+    getFeaturesAtCoordinate(coordinate: Coordinate | undefined, hitTolerance?: number): Feature<Geometry>[];
+}

package/ol/renderers/RealtimeLayerRenderer.js

@@ -16,7 +16,6 @@ export default class RealtimeLayerRenderer extends CanvasLayerRenderer {
         return true;
     }
     renderFrame(frameState) {
-        var _a;
         const { canvas, renderedViewState } = this.getLayer();
         if (!this.container) {
             this.container = document.createElement('div');
@@ -24,7 +23,7 @@ export default class RealtimeLayerRenderer extends CanvasLayerRenderer {
             this.container.style.position = 'absolute';
             this.container.style.width = '100%';
             this.container.style.height = '100%';
-            if (canvas) {
+            if (canvas instanceof HTMLCanvasElement) {
                 canvas.style.position = 'absolute';
                 canvas.style.top = '0';
                 canvas.style.left = '0';
@@ -41,12 +40,12 @@ export default class RealtimeLayerRenderer extends CanvasLayerRenderer {
                 context === null || context === void 0 ? void 0 : context.clearRect(0, 0, canvas === null || canvas === void 0 ? void 0 : canvas.width, canvas === null || canvas === void 0 ? void 0 : canvas.height);
             }
             else {
-                const pixelCenterRendered = (_a = this.getLayer()
-                    .getMapInternal()) === null || _a === void 0 ? void 0 : _a.getPixelFromCoordinate(renderedCenter);
-                const pixelCenter = this.getLayer()
-                    .getMapInternal()
-                    .getPixelFromCoordinate(center);
-                this.container.style.transform = composeCssTransform(pixelCenterRendered[0] - pixelCenter[0], pixelCenterRendered[1] - pixelCenter[1], renderedResolution / resolution, renderedResolution / resolution, rotation - renderedRotation, 0, 0);
+                const map = this.getLayer().getMapInternal();
+                const pixelCenterRendered = map === null || map === void 0 ? void 0 : map.getPixelFromCoordinate(renderedCenter);
+                const pixelCenter = map === null || map === void 0 ? void 0 : map.getPixelFromCoordinate(center);
+                if (pixelCenterRendered && pixelCenter) {
+                    this.container.style.transform = composeCssTransform(pixelCenterRendered[0] - pixelCenter[0], pixelCenterRendered[1] - pixelCenter[1], renderedResolution / resolution, renderedResolution / resolution, rotation - renderedRotation, 0, 0);
+                }
             }
         }
         return this.container;
@@ -83,12 +82,13 @@ export default class RealtimeLayerRenderer extends CanvasLayerRenderer {
         return features === null || features === void 0 ? void 0 : features[0];
     }
     getFeaturesAtCoordinate(coordinate, hitTolerance = 5) {
+        var _a;
         if (!coordinate) {
             return [];
         }
         const layer = this.getLayer();
         const map = layer.getMapInternal();
-        const resolution = map.getView().getResolution();
+        const resolution = ((_a = map === null || map === void 0 ? void 0 : map.getView()) === null || _a === void 0 ? void 0 : _a.getResolution()) || 1;
         const nb = 10;
         const ext = buffer([...coordinate, ...coordinate], hitTolerance * resolution);
         let features = [];

package/ol/styles/fullTrajectoryDelayStyle.d.ts

@@ -0,0 +1,6 @@
+import { Style } from 'ol/style';
+/**
+ * @private
+ */
+declare const fullTrajectoryDelaystyle: () => Style[];
+export default fullTrajectoryDelaystyle;

package/ol/styles/fullTrajectoryStyle.d.ts

@@ -0,0 +1,5 @@
+import type { FeatureLike } from 'ol/Feature';
+import { Style } from 'ol/style';
+/** @private */
+declare const fullTrajectorystyle: (feature: FeatureLike, resolution: number, options: any) => Style[];
+export default fullTrajectorystyle;

package/ol/styles/index.d.ts

@@ -0,0 +1,3 @@
+export { default as fullTrajectoryStyle } from "./fullTrajectoryStyle";
+export { default as fullTrajectoryDelayStyle } from "./fullTrajectoryDelayStyle";
+export { default as routingStyle } from "./routingStyle";

package/ol/styles/routingStyle.d.ts

@@ -0,0 +1,4 @@
+import { StyleFunction } from 'ol/style/Style';
+/** @private */
+declare const routingStyle: StyleFunction;
+export default routingStyle;

package/ol/utils/getFeatureInfoAtCoordinate.d.ts

@@ -0,0 +1,8 @@
+import type { Coordinate } from 'ol/coordinate';
+import type { Layer } from 'ol/layer';
+import { LayerGetFeatureInfoResponse } from '../../types';
+/**
+ * @private
+ */
+declare const getFeatureInfoAtCoordinate: (coordinate: Coordinate, layers: Layer[], hitTolerance?: number) => Promise<LayerGetFeatureInfoResponse[]>;
+export default getFeatureInfoAtCoordinate;

package/ol/utils/getFeatureInfoAtCoordinate.js

@@ -63,7 +63,7 @@ const getFeatureInfoAtCoordinate = (coordinate, layers, hitTolerance = 5) => __a
         const source = layer === null || layer === void 0 ? void 0 : layer.getSource();
         // @ts-ignore
         if (source === null || source === void 0 ? void 0 : source.getFeatureInfoUrl) {
-            const id = getUid(this);
+            const id = getUid(layer);
             // Abort and recreates one controller per layer
             (_c = abortControllers[id]) === null || _c === void 0 ? void 0 : _c.abort();
             abortControllers[id] = new AbortController();

package/ol/utils/index.d.ts

@@ -0,0 +1 @@
+export { default as getFeatureInfoAtCoordinate } from "./getFeatureInfoAtCoordinate";

package/package.json

@@ -2,7 +2,7 @@
   "name": "mobility-toolbox-js",
   "license": "MIT",
   "description": "Toolbox for JavaScript applications in the domains of mobility and logistics.",
-  "version": "3.0.0-beta.7",
+  "version": "3.0.0-beta.9",
   "homepage": "https://mobility-toolbox-js.geops.io/",
   "module": "index.js",
   "exports": {

package/setupTests.d.ts

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