mobility-toolbox-js 3.0.0-beta.9 → 3.0.1-beta.0

package/ol/mixins/PropertiesLayerMixin.d.ts

@@ -1,46 +1,27 @@
-import { Layer } from 'ol/layer';
-import { EventsKey } from 'ol/events';
 import { Map } from 'ol';
+import { EventsKey } from 'ol/events';
+import { Layer } from 'ol/layer';
 import type { Options } from 'ol/layer/Layer';
 import type { Layerable } from './MobilityLayerMixin';
-export type PropertiesLayerMixinOptions = Options & {
-    key?: string;
-    name?: string;
-    group?: string;
-    copyrights?: string[];
+export type PropertiesLayerMixinOptions = {
     children?: any[];
-    visible?: boolean;
+    copyrights?: string[];
     disabled?: boolean;
+    group?: string;
     hitTolerance?: number;
-    properties?: {
-        [x: string]: any;
-    };
+    key?: string;
     map?: Map;
-} & {
-    [x: string]: any;
-};
+    name?: string;
+    properties?: Record<string, any>;
+    visible?: boolean;
+} & Options & Record<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;
+        olEventsKeys: EventsKey[];
+        options?: PropertiesLayerMixinOptions;
         /**
          * Initialize the layer with the map passed in parameters.
          *
@@ -53,34 +34,60 @@ declare function PropertiesLayerMixin<TBase extends Layerable>(Base: TBase): {
         detachFromMap(): void;
         /**
          * Return the an array containing all the descendants of the layer in a flat array. Including the current layer.
+         * @deprecated
          */
         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>;
+        /** @private */
+        onChildrenChange(oldValue: Layer[]): void;
+        setMapInternal(map: Map): void;
+        /** @deprecated */
+        children: Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>[];
+        /** @deprecated */
+        get copyrights(): string;
+        /** @deprecated */
+        set copyrights(newCopyrights: string | string[]);
+        /** @deprecated */
+        disabled: boolean;
+        /** @deprecated */
+        /** @deprecated */
+        readonly group: string;
+        /** @deprecated */
+        readonly hitTolerance: number;
+        readonly key: string;
+        readonly map: Map;
+        /** @deprecated */
+        readonly name: string;
+        /** @deprecated */
+        olLayer: Layer;
+        /** @deprecated */
+        /** @deprecated */
+        parent: Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>;
+        /** @deprecated */
+        visible: boolean;
+        on: import("ol/layer/Layer").LayerOnSignature<import("ol/events").EventsKey>;
+        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[];
+        render: (frameState: import("ol/Map").FrameState | null, target: HTMLElement) => HTMLElement | null;
+        getSource: () => import("ol/source").Source | null;
+        getRenderSource: () => import("ol/source").Source | null;
+        getFeatures: (pixel: import("ol/pixel").Pixel) => Promise<Array<import("ol/Feature").FeatureLike>>;
+        getData: (pixel: import("ol/pixel").Pixel) => Uint8ClampedArray | Uint8Array | Float32Array | DataView | null;
+        isVisible: (view?: import("ol").View | import("ol/View").ViewStateLayerStateExtent | undefined) => boolean;
+        getAttributions: (view?: import("ol").View | import("ol/View").ViewStateLayerStateExtent | undefined) => Array<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;
+        getMapInternal: () => import("ol/Map").default | null;
+        setMap: (map: import("ol/Map").default | null) => void;
+        setSource: (source: import("ol/source").Source | null) => void;
         getRenderer: () => import("ol/renderer/Layer").default<any> | null;
         hasRenderer: () => boolean;
-        getBackground: () => false | import("ol/layer/Base").BackgroundColor;
+        getBackground: () => import("ol/layer/Base").BackgroundColor | false;
         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[];
+        getLayersArray: (array?: import("ol/layer/Layer").default<import("ol/source").default, import("ol/renderer/Layer").default<any>>[] | undefined) => Array<import("ol/layer/Layer").default>;
+        getLayerStatesArray: (states?: import("ol/layer/Layer").State[] | undefined) => Array<import("ol/layer/Layer").State>;
         getExtent: () => import("ol/extent").Extent | undefined;
         getMaxResolution: () => number;
         getMinResolution: () => number;
@@ -100,7 +107,7 @@ declare function PropertiesLayerMixin<TBase extends Layerable>(Base: TBase): {
         setVisible: (visible: boolean) => void;
         setZIndex: (zindex: number) => void;
         get: (key: string) => any;
-        getKeys: () => string[];
+        getKeys: () => Array<string>;
         getProperties: () => {
             [x: string]: any;
         };
@@ -118,9 +125,11 @@ declare function PropertiesLayerMixin<TBase extends Layerable>(Base: TBase): {
         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;
+        addEventListener: (type: string, listener: import("ol/events").Listener) => void;
+        dispatchEvent: (event: import("ol/events/Event").default | string) => boolean | undefined;
+        getListeners: (type: string) => Array<import("ol/events").Listener> | undefined;
         hasListener: (type?: string | undefined) => boolean;
+        removeEventListener: (type: string, listener: import("ol/events").Listener) => void;
         dispose: () => void;
     };
 } & TBase;

package/ol/mixins/PropertiesLayerMixin.js

@@ -1,41 +1,132 @@
+// eslint-disable-next-line max-classes-per-file
+import debounce from 'lodash.debounce';
 import { getUid } from 'ol';
 import getLayersAsFlatArray from '../../common/utils/getLayersAsFlatArray';
+let deprecated = () => { };
+if (typeof window !== 'undefined' &&
+    new URLSearchParams(window.location.search).get('deprecated')) {
+    deprecated = debounce((message) => {
+        // eslint-disable-next-line no-console
+        console.warn(message);
+    }, 1000);
+}
 /**
  * This mixin adds some properties to access ol custom properties easily.
  */
 function PropertiesLayerMixin(Base) {
     return class PropertiesLayer extends Base {
+        constructor(...args) {
+            var _a;
+            const options = args[0];
+            super(options);
+            this.olEventsKeys = [];
+            this.options = {};
+            if (options.properties) {
+                deprecated("Deprecated. Don't use properties options. Pass the values directly in options object.");
+                this.setProperties(options.properties);
+            }
+            (_a = this.olEventsKeys) === null || _a === void 0 ? void 0 : _a.push(
+            // Update parent property
+            this.on('propertychange', (evt) => {
+                if (evt.key === 'children') {
+                    this.onChildrenChange(evt.oldValue);
+                }
+            }));
+            this.options = options;
+            this.set('children', options.children || []); // Trigger the on children change event
+        }
+        /**
+         * Initialize the layer with the map passed in parameters.
+         *
+         * @param {ol/Map~Map} map A map.
+         */
+        attachToMap(map) {
+            // @ts-expect-error attachToMap not necessarily exists
+            (super.attachToMap || (() => { }))(map);
+            (this.get('children') || []).forEach((child) => {
+                map.addLayer(child);
+            });
+        }
+        /**
+         * Terminate what was initialized in init function. Remove layer, events...
+         */
+        detachFromMap() {
+            (this.get('children') || []).forEach((child) => {
+                this.map.removeLayer(child);
+            });
+            // @ts-expect-error detachToMap not necessarily exists
+            (super.detachFromMap || (() => { }))();
+        }
+        /**
+         * Return the an array containing all the descendants of the layer in a flat array. Including the current layer.
+         * @deprecated
+         */
+        flat() {
+            deprecated('Layer.flat is deprecated. Use getLayersAsFlatArray utils method instead.');
+            return getLayersAsFlatArray(this);
+        }
+        /** @private */
+        onChildrenChange(oldValue) {
+            // Set the parent property
+            (oldValue || []).forEach((child) => {
+                child.set('parent', undefined);
+            });
+            (this.get('children') || []).forEach((child) => {
+                child.set('parent', this);
+            });
+        }
+        // @ts-expect-error  - this is a mixin
+        setMapInternal(map) {
+            super.setMapInternal(map);
+            if (map) {
+                this.attachToMap(map);
+            }
+            else {
+                this.detachFromMap();
+            }
+        }
+        /** @deprecated */
         get children() {
+            deprecated("Layer.children is deprecated. Use the Layer.get('children') method instead.");
             return this.get('children') || [];
         }
+        /** @deprecated */
         set children(newValue) {
+            deprecated("Layer.children is deprecated. Use the Layer.set('children', children) method instead.");
             this.set('children', newValue || []);
         }
+        /** @deprecated */
         get copyrights() {
-            // eslint-disable-next-line no-console
-            console.warn('Deprecated. Use the source object to get the attributions');
+            deprecated('Layer.copyrights is deprecated. Get the attributions from the source object');
             return this.get('copyrights');
         }
+        /** @deprecated */
         set copyrights(newCopyrights) {
-            // eslint-disable-next-line no-console
-            console.warn('Deprecated. Use the source object to set the attributions');
+            deprecated('Layer.copyrights is deprecated. Set the attributions to the source object.');
             const arrValue = newCopyrights && !Array.isArray(newCopyrights)
                 ? [newCopyrights]
                 : newCopyrights;
             this.set('copyrights', arrValue || []);
         }
+        /** @deprecated */
         get disabled() {
+            deprecated("Layer.disabled is deprecated. Use the Layer.get('disabled') method instead.");
             return this.get('disabled');
         }
+        /** @deprecated */
         set disabled(newValue) {
+            deprecated("Layer.disabled is deprecated. Use the Layer.set('disabled', newValue) method instead.");
             this.set('disabled', newValue);
         }
+        /** @deprecated */
+        /** @deprecated */
         get group() {
+            deprecated("Layer.group is deprecated. Use the Layer.get('group') method instead.");
             return this.get('group');
         }
+        /** @deprecated */
         get hitTolerance() {
-            // eslint-disable-next-line no-console
-            console.warn('Deprecated. Pass the pixelTolerance when you request the features.');
+            deprecated('Layer.hitTolerance is deprecated.Pass the hitTolerance when you request the features.');
             return this.get('hitTolerance') || 5;
         }
         get key() {
@@ -44,100 +135,44 @@ function PropertiesLayerMixin(Base) {
         get map() {
             return this.getMapInternal();
         }
+        /** @deprecated */
         get name() {
+            deprecated("Layer.name is deprecated. Use the Layer.get('name') method instead.");
             return this.get('name');
         }
+        /** @deprecated */
         get olLayer() {
-            // eslint-disable-next-line no-console
-            console.warn("Deprecated property: mobility-toolbox-js/ol layers inherits now from ol/layer/Layer class. This getter is only a redirect to the current 'this' object.");
+            deprecated("Layer.olLayer is deprecated. mobility-toolbox-js/ol layers inherits now from ol/layer/Layer class. This getter is only a redirect to the current 'this' object.");
             return this;
         }
         // eslint-disable-next-line class-methods-use-this
         set olLayer(newValue) {
-            // eslint-disable-next-line no-console
-            console.log('Deprecated property: mobility-toolbox-js/ol layers inherits now from ol/layer/Layer class. This setter has no effect.');
+            deprecated('Layer.olLayer is deprecated. mobility-toolbox-js/ol layers inherits now from ol/layer/Layer class. This setter has no effect.');
         }
+        /** @deprecated */
+        // get olListenersKeys(): EventsKey[] {
+        //   return this.olEventsKeys;
+        // }
+        /** @deprecated */
         get parent() {
+            deprecated("Layer.parent is deprecated. Use the Layer.get('parent') method instead.");
             return this.get('parent');
         }
+        /** @deprecated */
         set parent(newValue) {
+            deprecated("Layer.parent is deprecated. Use the Layer.set('parent', parent) method instead.");
             this.set('parent', newValue);
         }
+        /** @deprecated */
         get visible() {
+            deprecated('Layer.visible is deprecated. Use the Layer.getVisible() method instead.');
             return this.getVisible();
         }
+        /** @deprecated */
         set visible(newValue) {
+            deprecated('Layer.visible is deprecated. Use the Layer.setVisible(newValue) method instead.');
             this.setVisible(newValue);
         }
-        constructor(...args) {
-            var _a;
-            const options = args[0];
-            super(options);
-            this.options = {};
-            this.olListenersKeys = [];
-            if (options.properties) {
-                // eslint-disable-next-line no-console
-                console.warn("Deprecated. Don't use properties options. Pass the values directly in options object.");
-                this.setProperties(options.properties);
-            }
-            (_a = this.olListenersKeys) === null || _a === void 0 ? void 0 : _a.push(
-            // Update parent property
-            this.on('propertychange', (evt) => {
-                if (evt.key === 'children') {
-                    this.onChildrenChange(evt.oldValue);
-                }
-            }));
-            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) {
-                this.attachToMap(map);
-            }
-            else {
-                this.detachFromMap();
-            }
-        }
-        /** @private */
-        onChildrenChange(oldValue) {
-            // Set the parent property
-            (oldValue || []).forEach((child) => {
-                child.set('parent', undefined);
-            });
-            (this.children || []).forEach((child) => {
-                child.set('parent', this);
-            });
-        }
-        /**
-         * Initialize the layer with the map passed in parameters.
-         *
-         * @param {ol/Map~Map} map A map.
-         */
-        attachToMap(map) {
-            // @ts-ignore
-            (super.attachToMap || (() => { }))(map);
-            (this.get('children') || []).forEach((child) => {
-                map.addLayer(child);
-            });
-        }
-        /**
-         * Terminate what was initialized in init function. Remove layer, events...
-         */
-        detachFromMap() {
-            (this.get('children') || []).forEach((child) => {
-                this.map.removeLayer(child);
-            });
-            // @ts-ignore
-            (super.detachFromMap || (() => { }))();
-        }
-        /**
-         * Return the an array containing all the descendants of the layer in a flat array. Including the current layer.
-         */
-        flat() {
-            return getLayersAsFlatArray(this);
-        }
     };
 }
 export default PropertiesLayerMixin;

package/ol/mixins/index.d.ts

@@ -0,0 +1 @@
+export { default as MobilityLayerMixin } from './MobilityLayerMixin';

package/ol/mixins/index.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/prefer-default-export
+export { default as MobilityLayerMixin } from './MobilityLayerMixin';

package/ol/renderers/MaplibreLayerRenderer.d.ts

@@ -1,20 +0,0 @@
-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;
-}