@yappkit/front-module-map 0.1.8 → 0.2.0

package/lib/types/main.d.ts

@@ -0,0 +1,27 @@
+import Mapbox from './providers/Mapbox.js';
+import Maplibre from './providers/Maplibre.js';
+import GoogleMaps from './providers/GoogleMaps.js';
+import DeckGL from './providers/DeckGL.js';
+import getAirRoute from './utils/getAirRoute.js';
+import getWaterRoute from './utils/getWaterRoute.js';
+import normalizeRoute from './utils/normalizeRoute.js';
+export declare const utils: {
+    getAirRoute: typeof getAirRoute;
+    getWaterRoute: typeof getWaterRoute;
+    normalizeRoute: typeof normalizeRoute;
+};
+export declare const mapProviders: {
+    mapbox: typeof Mapbox;
+    maplibre: typeof Maplibre;
+    'maplibre-gl': typeof Maplibre;
+    google: typeof GoogleMaps;
+    'google-maps': typeof GoogleMaps;
+    deckgl: typeof DeckGL;
+    'deck-gl': typeof DeckGL;
+};
+export default class MapModule {
+    install(yAppKit: any): {
+        onAfterSetup: () => void;
+    };
+}
+export declare const loadMapModule: () => MapModule;

package/lib/types/providers/DeckGL.d.ts

@@ -0,0 +1,10 @@
+export default class DeckGL {
+    deckgl: {
+        Deck: typeof import("@deck.gl/core").Deck;
+    } | null;
+    _MapComponent: any;
+    constructor();
+    get Map(): any;
+    loadDeckGL(): Promise<void>;
+    createMap(elemRef: any, options?: {}): Promise<any>;
+}

package/lib/types/providers/DeckGLOverlay.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared deck.gl overlay wiring (#174): the class and the component below used to be duplicated
+ * verbatim in Mapbox.js and GoogleMaps.js — every fix (#151, #156, #165) had to be applied twice.
+ * Providers subclass DeckGLOverlay with their `_detach()` and build their component through
+ * makeDeckGLOverlayComponent with their inject key.
+ */
+export declare class DeckGLOverlay {
+    overlay: any;
+    watching: {
+        options: boolean;
+        layers: boolean;
+    };
+    unwatchFn: any;
+    trackedIn: any;
+    constructor({ unwatchFn, trackedIn }: {
+        trackedIn?: null | undefined;
+        unwatchFn: any;
+    });
+    /** Stop the watchers, leave the map's tracking list and detach the overlay from the map (#151).
+     * @returns {void}
+     */
+    destroy(): void;
+    watchOptions(opts: any, options?: {}): void;
+    watchLayers(layers: any, options?: {}): void;
+}
+/** Build the provider's DeckGLOverlay component, bound to its injected map key (#174).
+ * @param {string} mapInjectKey - The provide/inject key of the provider's map ref.
+ * @returns {import('vue').Component} The overlay component definition.
+ */
+export declare const makeDeckGLOverlayComponent: (mapInjectKey: string) => import('vue').Component;

package/lib/types/providers/GoogleMaps.d.ts

@@ -0,0 +1,41 @@
+export default class GoogleMaps {
+    apiKey: any;
+    libraries: any[];
+    version: any;
+    _mapsApiConfigured: boolean;
+    authFailed: boolean;
+    sdk: {};
+    deckgl: {
+        Tile3DLayer: typeof import("@deck.gl/geo-layers").Tile3DLayer;
+    } | null;
+    _MapComponent: any;
+    _Map3DComponent: any;
+    _DeckGLOverlayComponent: any;
+    _DeckGL3DTileLayerComponent: any;
+    ready: Promise<any>;
+    constructor(mapConfig: any);
+    get Map(): any;
+    get Map3D(): any;
+    get DeckGLOverlay(): any;
+    get DeckGL3DTileLayer(): any;
+    loadGoogleMapsSDK({ libraries }?: {
+        libraries?: never[] | undefined;
+    }): Promise<void>;
+    getSDK(options: any): Promise<any>;
+    createMap(elemRef: any, options?: {}): Promise<any>;
+    createMap3D(elemRef: any, options?: {}): Promise<any>;
+    loadDeckGL(): Promise<void>;
+    createDeckGL3DTileLayer(credits: any, options?: {}): Promise<import("@deck.gl/geo-layers").Tile3DLayer<any, {
+        id: "google-3d-tiles";
+        data: "https://tile.googleapis.com/v1/3dtiles/root.json";
+        loadOptions: {
+            fetch: {
+                headers: {
+                    'X-GOOG-API-KEY': any;
+                };
+            };
+        };
+        onTilesetLoad: (tileset3d: import("@loaders.gl/tiles").Tileset3D) => void;
+        operation: "terrain+draw";
+    }>>;
+}

package/lib/types/providers/Mapbox.d.ts

@@ -0,0 +1,114 @@
+export default class Mapbox {
+    apiKey: any;
+    services: any[];
+    sdk: {};
+    mapboxgl: {
+        AttributionControl: typeof import("mapbox-gl/esm").AttributionControl;
+        CanvasSource: typeof import("mapbox-gl/esm").CanvasSource;
+        CustomSource: typeof import("mapbox-gl/esm").CustomSource;
+        ErrorEvent: typeof import("mapbox-gl/esm").ErrorEvent;
+        Event: typeof import("mapbox-gl/esm").Event;
+        Evented: typeof import("mapbox-gl/esm").Evented;
+        FreeCameraOptions: typeof import("mapbox-gl/esm").FreeCameraOptions;
+        FullscreenControl: typeof import("mapbox-gl/esm").FullscreenControl;
+        GeoJSONSource: typeof import("mapbox-gl/esm").GeoJSONSource;
+        GeolocateControl: typeof import("mapbox-gl/esm").GeolocateControl;
+        ImageSource: typeof import("mapbox-gl/esm").ImageSource;
+        IndoorControl: typeof import("mapbox-gl/esm").IndoorControl;
+        InteractionEvent: typeof import("mapbox-gl/esm").InteractionEvent;
+        LngLat: typeof import("mapbox-gl/esm").LngLat;
+        LngLatBounds: typeof import("mapbox-gl/esm").LngLatBounds;
+        Map: typeof import("mapbox-gl/esm").Map;
+        MapMouseEvent: typeof import("mapbox-gl/esm").MapMouseEvent;
+        MapTouchEvent: typeof import("mapbox-gl/esm").MapTouchEvent;
+        MapWheelEvent: typeof import("mapbox-gl/esm").MapWheelEvent;
+        Marker: typeof import("mapbox-gl/esm").Marker;
+        MercatorCoordinate: typeof import("mapbox-gl/esm").MercatorCoordinate;
+        ModelSource: typeof import("mapbox-gl/esm").ModelSource;
+        NavigationControl: typeof import("mapbox-gl/esm").NavigationControl;
+        Point: typeof import("mapbox-gl/esm").Point;
+        Popup: typeof import("mapbox-gl/esm").Popup;
+        RasterArrayTileSource: typeof import("mapbox-gl/esm").RasterArrayTileSource;
+        RasterDemTileSource: typeof import("mapbox-gl/esm").RasterDemTileSource;
+        RasterTileSource: typeof import("mapbox-gl/esm").RasterTileSource;
+        ResourceType: {
+            readonly Unknown: "Unknown";
+            readonly Style: "Style";
+            readonly Source: "Source";
+            readonly Tile: "Tile";
+            readonly Glyphs: "Glyphs";
+            readonly SpriteImage: "SpriteImage";
+            readonly SpriteJSON: "SpriteJSON";
+            readonly Iconset: "Iconset";
+            readonly Image: "Image";
+            readonly Model: "Model";
+        };
+        ScaleControl: typeof import("mapbox-gl/esm").ScaleControl;
+        Style: typeof import("mapbox-gl/esm").Style;
+        TargetFeature: typeof import("mapbox-gl/esm").TargetFeature;
+        Tiled3DModelSource: typeof import("mapbox-gl/esm").Tiled3DModelSource;
+        VectorTileSource: typeof import("mapbox-gl/esm").VectorTileSource;
+        VideoSource: typeof import("mapbox-gl/esm").VideoSource;
+        addTileProvider: typeof import("mapbox-gl/esm").addTileProvider;
+        clearPrewarmedResources: typeof import("mapbox-gl/esm").clearPrewarmedResources;
+        clearStorage: typeof import("mapbox-gl/esm").clearStorage;
+        getBuildingGenUrl: typeof import("mapbox-gl/esm").getBuildingGenUrl;
+        getDracoUrl: typeof import("mapbox-gl/esm").getDracoUrl;
+        getMeshoptUrl: typeof import("mapbox-gl/esm").getMeshoptUrl;
+        getRTLTextPluginStatus: () => import("mapbox-gl/esm").PluginStatus;
+        getWorkerCount: typeof import("mapbox-gl/esm").getWorkerCount;
+        prewarm: typeof import("mapbox-gl/esm").prewarm;
+        restoreNow: () => void;
+        setAccessToken: typeof import("mapbox-gl/esm").setAccessToken;
+        setBaseApiUrl: typeof import("mapbox-gl/esm").setBaseApiUrl;
+        setBuildingGenUrl: typeof import("mapbox-gl/esm").setBuildingGenUrl;
+        setDracoUrl: typeof import("mapbox-gl/esm").setDracoUrl;
+        setMaxParallelImageRequests: typeof import("mapbox-gl/esm").setMaxParallelImageRequests;
+        setMeshoptUrl: typeof import("mapbox-gl/esm").setMeshoptUrl;
+        setNow: (time: number) => void;
+        setRTLTextPlugin: (url: string, callback?: ((error?: Error | null, result?: {
+            err: Error | null | undefined;
+        } | null | undefined) => void) | null, deferred?: boolean) => void;
+        setSdkInfo: typeof import("mapbox-gl/esm").setSdkInfo;
+        setWorkerCount: typeof import("mapbox-gl/esm").setWorkerCount;
+        setWorkerUrl: typeof import("mapbox-gl/esm").setWorkerUrl;
+        supported: typeof import("mapbox-gl/esm").supported;
+        version: string;
+        default: typeof import("mapbox-gl/esm");
+    } | null;
+    _MapComponent: any;
+    _DeckGLOverlayComponent: any;
+    ready: Promise<any>;
+    get requiresApiKey(): boolean;
+    constructor(mapConfig: any);
+    get Map(): any;
+    get DeckGLOverlay(): any;
+    loadMapbox(): Promise<void>;
+    get servicesLoader(): {
+        datasets: () => Promise<any>;
+        directions: () => Promise<any>;
+        geocoding: () => Promise<any>;
+        geocodingV6: () => Promise<any>;
+        mapMatching: () => Promise<any>;
+        matrix: () => Promise<any>;
+        optimization: () => Promise<any>;
+        static: () => Promise<any>;
+        styles: () => Promise<any>;
+        tilequery: () => Promise<any>;
+        tilesets: () => Promise<any>;
+        tokens: () => Promise<any>;
+        uploads: () => Promise<any>;
+        isochrone: () => Promise<any>;
+    };
+    loadMapboxSDK({ services }?: {
+        services?: never[] | undefined;
+    }): Promise<void>;
+    getSDK(options: any): Promise<any>;
+    /** Map constructor options, overridable per subclass (maplibre-gl has no accessToken option, #154).
+     * @param {HTMLElement} container - The map container element.
+     * @param {object} options - Consumer-provided map options.
+     * @returns {object} The options passed to `new mapboxgl.Map()`.
+     */
+    _getMapOptions(container: HTMLElement, options: object): object;
+    createMap(elemRef: any, options?: {}): Promise<any>;
+}

package/lib/types/providers/Maplibre.d.ts

@@ -0,0 +1,13 @@
+import Mapbox from './Mapbox.js';
+export default class Maplibre extends Mapbox {
+    get requiresApiKey(): boolean;
+    loadMapbox(): Promise<void>;
+    /** No Mapbox REST SDK on maplibre (#154): the constructor preload resolves to an empty sdk,
+     * and requesting a service (argument or configured `services`) is a consumer error.
+     * @param {string|object} [options] - Service name or `{ services }` object, like Mapbox's getSDK.
+     * @returns {Promise<object>} The (empty) sdk registry.
+     * @throws {Error} When a service is requested.
+     */
+    getSDK(options?: string | object): Promise<object>;
+    _getMapOptions(container: any, options: any): any;
+}

package/lib/types/searoute/searoute.d.ts

@@ -0,0 +1 @@
+export default function searoute(origin: any, destination: any, units?: string): import("geojson").Feature<import("geojson").LineString, import("geojson").GeoJsonProperties> | null;

package/lib/types/utils/getAirRoute.d.ts

@@ -0,0 +1,6 @@
+export default function getAirRoute({ origin, destination, step, units }: {
+    destination: any;
+    origin: any;
+    step?: number | undefined;
+    units?: string | undefined;
+}): import("geojson").Feature<import("geojson").LineString, import("geojson").GeoJsonProperties>;

package/lib/types/utils/getWaterRoute.d.ts

@@ -0,0 +1,6 @@
+export default function getWaterRoute({ origin, destination, includeBoundaries, units }: {
+    destination: any;
+    includeBoundaries?: boolean | undefined;
+    origin: any;
+    units?: string | undefined;
+}): Promise<import("geojson").Feature<import("geojson").LineString, import("geojson").GeoJsonProperties> | null>;

package/lib/types/utils/normalizeRoute.d.ts

@@ -0,0 +1 @@
+export default function normalizeRoute(coords: any): any;