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

package/ol/controls/CopyrightControl.d.ts

@@ -0,0 +1,31 @@
+import { MapEvent } from 'ol';
+import Control, { Options } from 'ol/control/Control';
+export type CopyrightControlOptions = Options & {
+    className?: 'string';
+    format?: (copyrights: string[]) => string;
+};
+/**
+ * Display layer's copyrights.
+ *
+ * @example
+ * import { Map } from 'ol';
+ * import { CopyrightControl } from 'mobility-toolbox-js/ol';
+ *
+ * const map = new Map({
+ *   target: 'map',
+ * });
+ *
+ * const control = new CopyrightControl();
+ * map.addControl(control);
+ *
+ *
+ * @see <a href="/example/ol-copyright">Openlayers copyright example</a>
+ *
+ * @extends {ol/control/Control}
+ */
+declare class CopyrightControl extends Control {
+    format: (copyrights: string[]) => string;
+    constructor(options?: CopyrightControlOptions);
+    render({ frameState }: MapEvent): void;
+}
+export default CopyrightControl;

package/ol/controls/RoutingControl.d.ts

@@ -0,0 +1,209 @@
+import { Feature } from 'ol';
+import type { Map, MapBrowserEvent } from 'ol';
+import { Geometry, LineString, Point } from 'ol/geom';
+import { Modify } from 'ol/interaction';
+import { GeoJSON } from 'ol/format';
+import type { Coordinate } from 'ol/coordinate';
+import type { StyleLike } from 'ol/style/Style';
+import { EventsKey } from 'ol/events';
+import { ModifyEvent } from 'ol/interaction/Modify';
+import VectorLayer from 'ol/layer/Vector';
+import VectorSource from 'ol/source/Vector';
+import Control, { Options } from 'ol/control/Control';
+import { RoutingAPI } from '../../api';
+import type { RoutingGraph, RoutingMot, RoutingParameters, RoutingViaPoint } from '../../types';
+export type RoutingControlOptions = Options & {
+    apiKey?: string;
+    active?: boolean;
+    stopsApiKey?: string;
+    stopsApiUrl?: string;
+    routingLayer?: VectorLayer<VectorSource<Feature<Geometry>>>;
+    graphs?: RoutingGraph[];
+    mot?: string;
+    modify?: boolean;
+    routingApiParams?: RoutingParameters;
+    useRawViaPoints?: boolean;
+    snapToClosestStation?: boolean;
+    style?: StyleLike;
+    onRouteError?: () => void;
+};
+export type AbotControllersByGraph = {
+    [key: string]: AbortController;
+};
+/**
+ * Display a route of a specified mean of transport.
+ *
+ * @example
+ * import { Map } from 'ol';
+ * import { RoutingControl } from 'mobility-toolbox-js/ol';
+ *
+ * const map = new Map({
+ *   target: 'map'
+ * });
+ *
+ * const control = new RoutingControl();
+ *
+ * control.attachToMap(map)
+ *
+ * @classproperty {string} apiKey - Key used for RoutingApi requests.
+ * @classproperty {string} stopsApiKey - Key used for Stop lookup requests (defaults to apiKey).
+ * @classproperty {string} stopsApiUrl - Url used for Stop lookup requests (defaults to https://api.geops.io/stops/v1/lookup/).
+ * @classproperty {Array.<Array<graph="osm", minZoom=0, maxZoom=99>>} graphs - Array of routing graphs and min/max zoom levels. If you use the control in combination with the [geOps Maps API](https://developer.geops.io/apis/maps/), you may want to use the optimal level of generalizations: "[['gen4', 0, 8], ['gen3', 8, 9], ['gen2', 9, 11], ['gen1', 11, 13], ['osm', 13, 99]]"
+ * @classproperty {string} mot - Mean of transport to be used for routing.
+ * @classproperty {object} routingApiParams - object of additional parameters to pass to the routing api request.
+ * @classproperty {object} snapToClosestStation - If true, the routing will snap the coordinate to the closest station. Default to false.
+ * @classproperty {boolean} useRawViaPoints - Experimental property. Wen true, it allows the user to add via points using different kind of string. See "via" parameter defined by the [geOps Routing API](https://developer.geops.io/apis/routing/). Default to false, only array of coordinates and station's id are supported as via points.
+ * @classproperty {VectorLayer} routingLayer - Layer for adding route features.
+ * @classproperty {function} onRouteError - Callback on error.
+ * @classproperty {boolean} loading - True if the control is requesting the backend.
+ * @see <a href="/example/ol-routing">Openlayers routing example</a>
+ *
+ * @extends {Control}
+ * @implements {RoutingInterface}
+ * @public
+ */
+declare class RoutingControl extends Control {
+    map?: Map;
+    viaPoints: RoutingViaPoint[];
+    routingLayer?: VectorLayer<VectorSource<Feature<Geometry>>>;
+    graphs: RoutingGraph[];
+    routingApiParams?: RoutingParameters;
+    useRawViaPoints: boolean;
+    snapToClosestStation: boolean;
+    cacheStationData: {
+        [key: string]: Coordinate;
+    };
+    abortControllers: {
+        [key: string]: AbortController;
+    };
+    apiKey?: string;
+    stopsApiKey?: string;
+    segments: Feature<LineString>[];
+    stopsApiUrl?: string;
+    api?: RoutingAPI;
+    format: GeoJSON;
+    graphsResolutions?: [number, number][];
+    onRouteError: (error?: Error, control?: RoutingControl) => void;
+    onMapClickKey?: EventsKey;
+    modifyInteraction?: Modify;
+    initialRouteDrag?: {
+        viaPoint?: Feature<Point>;
+        oldRoute?: Feature<LineString>;
+        segmentIndex?: number;
+    };
+    get active(): boolean;
+    set active(newValue: boolean);
+    get loading(): boolean;
+    set loading(newValue: boolean);
+    get modify(): any;
+    set modify(newValue: any);
+    get mot(): RoutingMot;
+    set mot(newValue: RoutingMot);
+    constructor(options?: RoutingControlOptions);
+    /**
+     * Calculate at which resolutions corresponds each generalizations.
+     *
+     * @private
+     */
+    static getGraphsResolutions(graphs: RoutingGraph[], map: Map): [number, number][];
+    /**
+     * Activet7deactivate the control when activ eproperty changes
+     * @private
+     */
+    onActiveChange(): void;
+    /**
+     * Adds/Replaces a viaPoint to the viaPoints array and redraws route:
+     *   Adds a viaPoint at end of array by default.
+     *   If an index is passed a viaPoint is added at the specified index.
+     *   If an index is passed and overwrite x is > 0, x viaPoints at the specified
+     *     index are replaced with a single new viaPoint.
+     * @param {number[]|string} coordinates Array of coordinates
+     * @param {number} [index=-1] Integer representing the index of the added viaPoint. If not specified, the viaPoint is added at the end of the array.
+     * @param {number} [overwrite=0] Marks the number of viaPoints that are removed at the specified index on add.
+     * @public
+     */
+    addViaPoint(coordinatesOrString: RoutingViaPoint, index?: number, overwrite?: number): void;
+    /**
+     * Removes a viaPoint at the passed array index and redraws route
+     * By default the last viaPoint is removed.
+     * @param {number} index Integer representing the index of the viaPoint to delete.
+     * @public
+     */
+    removeViaPoint(index?: number): void;
+    /**
+     * Replaces the current viaPoints with a new coordinate array.
+     * @param {Array<Array<number>>} coordinateArray Array of nested coordinates
+     * @public
+     */
+    setViaPoints(coordinateArray: Coordinate[]): void;
+    /**
+     * Removes all viaPoints, clears the source and triggers a change event
+     * @public
+     */
+    reset(): void;
+    /**
+     * Aborts viapoint and route requests
+     * @private
+     */
+    abortRequests(): void;
+    /**
+     * Draws route on map using an array of coordinates:
+     *   If a single coordinate is passed a single point feature is added to map.
+     *   If two or more coordinates are passed a request to the RoutingAPI fetches
+     *       the route using the passed coordinates and the current mot.
+     * @private
+     */
+    drawRoute(): Promise<void | Feature<Geometry>> | Promise<Feature<Geometry> | null> | Promise<(void | never[])[]> | null;
+    /**
+     * Draw a via point. This function can parse all the possibilitiies
+     *
+     * @private
+     */
+    drawViaPoint(viaPoint: RoutingViaPoint, idx: number, abortController: AbortController): Promise<void | Feature<Geometry>> | Promise<Feature<Geometry> | null>;
+    /**
+     * Used on click on map while control is active:
+     *   By default adds a viaPoint to the end of array.
+     *   If an existing viaPoint is clicked removes the clicked viaPoint.
+     * @private
+     */
+    onMapClick(evt: MapBrowserEvent<MouseEvent>): void;
+    /**
+     * Used on start of the modify interaction. Stores relevant data
+     * in this.initialRouteDrag object
+     * @private
+     */
+    onModifyStart(evt: ModifyEvent): void;
+    /**
+     * Used on end of the modify interaction. Resolves feature modification:
+     *   Line drag creates new viaPoint at the final coordinate of drag.
+     *   Point drag replaces old viaPoint.
+     * @private
+     */
+    onModifyEnd(evt: ModifyEvent): void | Promise<never>;
+    /**
+     * Define a default element.
+     *
+     * @private
+     */
+    createDefaultElement(): void;
+    /**
+     * Create the interaction used to modify vertexes of features.
+     * @private
+     */
+    createModifyInteraction(): void;
+    /**
+     * Add click listener to map.
+     * @private
+     */
+    addListeners(): void;
+    /**
+     * Remove click listener from map.
+     * @private
+     */
+    removeListeners(): void;
+    setMap(map: Map): void;
+    activate(): void;
+    deactivate(): void;
+    render(): void;
+}
+export default RoutingControl;

package/ol/controls/StopFinderControl.d.ts

@@ -0,0 +1,37 @@
+import { Feature } from 'geojson';
+import Control, { Options } from 'ol/control/Control';
+import StopFinderControlCommon from '../../common/controls/StopFinderControlCommon';
+export type StopFinderControlOptions = Options & StopFinderControlCommon & {
+    className?: string;
+};
+/**
+ * Search stations.
+ *
+ * @example
+ * import { Map } from 'ol';
+ * import { StopFinderControl } from 'mobility-toolbox-js/ol';
+ *
+ * const map = new Map({
+ *   target: 'map',
+ * });
+ *
+ * const control = new StopFinderControl({
+ *   apiKey: [yourApiKey]
+ * });
+ *
+ * map.addControl(control);
+ *
+ *
+ * @see <a href="/example/ol-search">Openlayers search example</a>
+ * @public
+ */
+declare class StopFinderControl extends Control {
+    controller: StopFinderControlCommon;
+    constructor(options: StopFinderControlOptions);
+    /**
+     * @private
+     */
+    onSuggestionClick(suggestion: Feature): void;
+    search(q: string, abortController: AbortController): Promise<void>;
+}
+export default StopFinderControl;

package/ol/controls/index.d.ts

@@ -0,0 +1,3 @@
+export { default as CopyrightControl } from "./CopyrightControl";
+export { default as RoutingControl } from "./RoutingControl";
+export { default as StopFinderControl } from "./StopFinderControl";

package/ol/index.d.ts

@@ -0,0 +1,6 @@
+export * from "../api";
+export * from "../common";
+export * from "./controls";
+export * from "./layers";
+export * from "./styles";
+export * from "./utils";

package/ol/layers/MapGlLayer.d.ts

@@ -0,0 +1,144 @@
+import Source from 'ol/source/Source';
+import OlMap from 'ol/Map';
+import BaseEvent from 'ol/events/Event';
+import Layer from 'ol/layer/Layer';
+import { AnyMapGlMap } from '../../types';
+import { MobilityLayerOptions } from '../mixins/MobilityLayerMixin';
+export type MapGlLayerOptions = MobilityLayerOptions & {
+    apiKey?: string;
+    apiKeyName?: string;
+    style?: string | maplibregl.StyleSpecification;
+    url?: string;
+    mapOptions: maplibregl.MapOptions;
+    queryRenderedFeaturesOptions: maplibregl.QueryRenderedFeaturesOptions;
+};
+declare const MapGlLayer_base: {
+    new (...args: any[]): {
+        options?: import("../mixins/PropertiesLayerMixin").PropertiesLayerMixinOptions | undefined;
+        olListenersKeys: import("ol/events").EventsKey[];
+        children: Layer<Source, 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: OlMap;
+        readonly name: string;
+        olLayer: Layer<Source, import("ol/renderer/Layer").default<any>>;
+        parent: Layer<Source, import("ol/renderer/Layer").default<any>>;
+        visible: boolean;
+        setMapInternal: ((map: OlMap) => void) & ((map: OlMap | null) => void);
+        onChildrenChange(oldValue: Layer<Source, import("ol/renderer/Layer").default<any>>[]): void;
+        attachToMap(map: OlMap): 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: () => Source | null;
+        getRenderSource: () => Source | 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: () => OlMap | null;
+        setMap: (map: OlMap | null) => void;
+        setSource: (source: Source | 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<Source, import("ol/renderer/Layer").default<any>>[] | undefined) => Layer<Source, 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 | BaseEvent) => boolean | undefined;
+        getListeners: (type: string) => import("ol/events").Listener[] | undefined;
+        hasListener: (type?: string | undefined) => boolean;
+        dispose: () => void;
+    };
+} & typeof Layer;
+/**
+ * Common class for Maplibre and Maplibre and potential other fork from Maplibre.
+ * It's used to share code between Maplibre and Maplibre layers without importing both libs.
+ * @private
+ */
+declare class MapGlLayer extends MapGlLayer_base {
+    loaded: boolean;
+    mbMap?: AnyMapGlMap;
+    get apiKey(): string;
+    set apiKey(newValue: string);
+    get apiKeyName(): string;
+    set apiKeyName(newValue: string);
+    get style(): string;
+    set style(newValue: string);
+    get url(): string;
+    set url(newValue: string);
+    get queryRenderedFeaturesOptions(): maplibregl.QueryRenderedFeaturesOptions;
+    set queryRenderedFeaturesOptions(newValue: maplibregl.QueryRenderedFeaturesOptions);
+    constructor(options: MapGlLayerOptions);
+    /**
+     * Initialize the layer and listen to feature clicks.
+     * @param {ol/Map~Map} map
+     */
+    attachToMap(map: OlMap): void;
+    /**
+     * Terminate what was initialized in init function. Remove layer, events...
+     */
+    detachFromMap(): void;
+    /**
+     * Create the Maplibre map.
+     * @private
+     */
+    loadMbMap(): void;
+    getStyle(): string;
+    createMap(options: {
+        [id: string]: any;
+    }): AnyMapGlMap;
+    updateMbMap(): void;
+}
+export default MapGlLayer;

package/ol/layers/MapGlLayer.js

@@ -45,7 +45,9 @@ class MapGlLayer extends MobilityLayerMixin(Layer) {
                 attributions: () => {
                     return (this.mbMap && getMapGlCopyrights(this.mbMap)) || [];
                 },
-            }), apiKeyName: 'key', style: 'travic_v2', url: 'https://maps.geops.io' }, (options || {})), { mapOptions: Object.assign({ interactive: false, trackResize: false, attributionControl: false }, ((options === null || options === void 0 ? void 0 : options.mapOptions) || {})), queryRenderedFeaturesOptions: Object.assign({}, ((options === null || options === void 0 ? void 0 : options.queryRenderedFeaturesOptions) || {})) }));
+            }), apiKeyName: 'key', style: 'travic_v2', url: 'https://maps.geops.io' }, (options || {})), { 
+            // @ts-expect-error mapOptions must be saved by the mixin in this.options
+            mapOptions: Object.assign({ interactive: false, trackResize: false, attributionControl: false }, ((options === null || options === void 0 ? void 0 : options.mapOptions) || {})), queryRenderedFeaturesOptions: Object.assign({}, ((options === null || options === void 0 ? void 0 : options.queryRenderedFeaturesOptions) || {})) }));
     }
     /**
      * Initialize the layer and listen to feature clicks.

package/ol/layers/MaplibreLayer.d.ts

@@ -0,0 +1,63 @@
+import { Map, MapOptions } from 'maplibre-gl';
+import MapGlLayer, { MapGlLayerOptions } from './MapGlLayer';
+import MaplibreLayerRenderer from '../renderers/MaplibreLayerRenderer';
+export type MaplibreLayerOptions = MapGlLayerOptions & {
+    mapOptions?: MapOptions;
+};
+/**
+ * This layer is meant to facilitate the use of the geOps Maps api in an OpenLayers map using Maplibre.
+ *
+ * @example
+ * import { MaplibreLayer } from 'mobility-toolbox-js/ol';
+ *
+ * const layer = new MaplibreLayer({
+ *   apiKey: 'yourApiKey',
+ *   // apiKeyName: 'key',
+ *   // mapOptions: {
+ *   //   interactive: false,
+ *   //   trackResize: false,
+ *   //   attributionControl: false,
+ *   // }
+ *   // queryRenderedFeaturesOptions: {
+ *   //   layers: ['waters_lakes'], // map.getFeaturesAtPixel will only return lakes.
+ *   // },
+ *   // style: 'travic_v2',
+ *   // url: 'https://maps.geops.io',
+ * });
+ *
+ * @classproperty {maplibregl.Map} maplibreMap - The Maplibre map object. Readonly.
+ * @classproperty {maplibregl.QueryRenderedFeaturesOptions} queryRenderedFeaturesOptions - Options used when we query features using map.getFeaturesAtPixel().
+ * @classproperty {string} style - geOps Maps api style.
+ * @extends {ol/layer/Layer~Layer}
+ * @public
+ */
+export default class MaplibreLayer extends MapGlLayer {
+    options?: MaplibreLayerOptions;
+    /** @private */
+    get maplibreMap(): maplibregl.Map | undefined;
+    /**
+     * Constructor.
+     *
+     * @param {MaplibreLayerOptions} options
+     * @param {string} options.apiKey Access key for [geOps apis](https://developer.geops.io/).
+     * @param {string} [options.apiKeyName="key"] The geOps Maps api key name.
+     * @param {maplibregl.MapOptions} [options.mapOptions={ interactive: false, trackResize: false, attributionControl: false }] Maplibre map options.
+     * @param {string} [options.style="travic_v2"] The geOps Maps api style.
+     * @param {string} [options.url="https://maps.geops.io"] The geOps Maps api url.
+     */
+    constructor(options: MaplibreLayerOptions);
+    /**
+     * @private
+     */
+    createRenderer(): MaplibreLayerRenderer;
+    /**
+     * @private
+     */
+    createMap(options: MapOptions): Map;
+    /**
+     * Create a copy of the MaplibreLayer.
+     * @param {MaplibreLayerOptions} newOptions Options to override
+     * @return {MaplibreLayer} A MaplibreLayer layer
+     */
+    clone(newOptions: MaplibreLayerOptions): MaplibreLayer;
+}