expo-gaode-map-web-api 2.0.3 → 2.0.5-next.0

package/build/v3/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebRuntime = exports.createWebDataRuntime = exports.createWebDataCapabilityAdapter = exports.createWebCapabilityAdapter = exports.createWebSearchProvider = exports.createWebRouteProvider = exports.createWebGeocodeProvider = void 0;
+__exportStar(require("./domain"), exports);
+__exportStar(require("./contracts"), exports);
+__exportStar(require("./runtime"), exports);
+__exportStar(require("./map-camera"), exports);
+__exportStar(require("./capability-selection"), exports);
+__exportStar(require("./runtime-assembly"), exports);
+var web_geocode_provider_1 = require("./web-geocode-provider");
+Object.defineProperty(exports, "createWebGeocodeProvider", { enumerable: true, get: function () { return web_geocode_provider_1.createWebGeocodeProvider; } });
+var web_route_provider_1 = require("./web-route-provider");
+Object.defineProperty(exports, "createWebRouteProvider", { enumerable: true, get: function () { return web_route_provider_1.createWebRouteProvider; } });
+var web_search_provider_1 = require("./web-search-provider");
+Object.defineProperty(exports, "createWebSearchProvider", { enumerable: true, get: function () { return web_search_provider_1.createWebSearchProvider; } });
+var runtime_factories_1 = require("./runtime-factories");
+Object.defineProperty(exports, "createWebCapabilityAdapter", { enumerable: true, get: function () { return runtime_factories_1.createWebCapabilityAdapter; } });
+Object.defineProperty(exports, "createWebDataCapabilityAdapter", { enumerable: true, get: function () { return runtime_factories_1.createWebDataCapabilityAdapter; } });
+Object.defineProperty(exports, "createWebDataRuntime", { enumerable: true, get: function () { return runtime_factories_1.createWebDataRuntime; } });
+Object.defineProperty(exports, "createWebRuntime", { enumerable: true, get: function () { return runtime_factories_1.createWebRuntime; } });

package/build/v3/map-camera.d.ts

@@ -0,0 +1,50 @@
+export interface CameraLatLng {
+    latitude: number;
+    longitude: number;
+}
+export type CameraLatLngPoint = CameraLatLng | [number, number] | number[];
+export interface CameraUpdateShape {
+    target?: CameraLatLng;
+    zoom?: number;
+    bearing?: number;
+    tilt?: number;
+}
+export interface CameraPositionShape extends CameraUpdateShape {
+}
+export interface CameraBoundsShape {
+    southwest: CameraLatLng;
+    northeast: CameraLatLng;
+}
+export interface FitCameraOptions {
+    duration?: number;
+    paddingFactor?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    singlePointZoom?: number;
+    bearing?: number;
+    tilt?: number;
+    preserveBearing?: boolean;
+    preserveTilt?: boolean;
+}
+export interface RouteBoundsShape {
+    center: CameraLatLng;
+    bounds: {
+        north: number;
+        south: number;
+        east: number;
+        west: number;
+    };
+    span: {
+        latitudeDelta: number;
+        longitudeDelta: number;
+    };
+    recommendedZoom: number;
+}
+export interface FitCameraTarget {
+    moveCamera(position: CameraUpdateShape, duration?: number): Promise<void>;
+    getCameraPosition(): Promise<CameraPositionShape>;
+}
+export declare function estimateCameraZoom(latitudeDelta: number, longitudeDelta: number, options?: Pick<FitCameraOptions, 'minZoom' | 'maxZoom'>): number;
+export declare function getCameraRouteBounds(points: CameraLatLngPoint[], options?: Pick<FitCameraOptions, 'paddingFactor' | 'minZoom' | 'maxZoom'>): RouteBoundsShape | null;
+export declare function fitCameraFromPoints(map: FitCameraTarget, points: CameraLatLngPoint[], options?: FitCameraOptions): Promise<void>;
+export declare function buildCameraBounds(points: CameraLatLngPoint[]): CameraBoundsShape | null;

package/build/v3/map-camera.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateCameraZoom = estimateCameraZoom;
+exports.getCameraRouteBounds = getCameraRouteBounds;
+exports.fitCameraFromPoints = fitCameraFromPoints;
+exports.buildCameraBounds = buildCameraBounds;
+const MIN_ZOOM = 3;
+const MAX_ZOOM = 20;
+const DEFAULT_SINGLE_POINT_ZOOM = 16;
+const DEFAULT_PADDING_FACTOR = 1.2;
+function normalizeLatLng(point) {
+    if (Array.isArray(point)) {
+        return {
+            longitude: Number(point[0]),
+            latitude: Number(point[1]),
+        };
+    }
+    return {
+        latitude: Number(point.latitude),
+        longitude: Number(point.longitude),
+    };
+}
+function normalizeLatLngList(points) {
+    return points.map(normalizeLatLng);
+}
+function estimateCameraZoom(latitudeDelta, longitudeDelta, options = {}) {
+    const span = Math.max(latitudeDelta, longitudeDelta, 0.0001);
+    const rawZoom = Math.log2(360 / span);
+    const minZoom = options.minZoom ?? MIN_ZOOM;
+    const maxZoom = options.maxZoom ?? MAX_ZOOM;
+    return Math.max(minZoom, Math.min(maxZoom, Number(rawZoom.toFixed(2))));
+}
+function getCameraRouteBounds(points, options = {}) {
+    const normalized = normalizeLatLngList(points);
+    if (normalized.length === 0) {
+        return null;
+    }
+    const latitudes = normalized.map((point) => point.latitude);
+    const longitudes = normalized.map((point) => point.longitude);
+    const north = Math.max(...latitudes);
+    const south = Math.min(...latitudes);
+    const east = Math.max(...longitudes);
+    const west = Math.min(...longitudes);
+    const paddingFactor = options.paddingFactor ?? DEFAULT_PADDING_FACTOR;
+    const latitudeDelta = Math.max((north - south) * paddingFactor, 0.0001);
+    const longitudeDelta = Math.max((east - west) * paddingFactor, 0.0001);
+    return {
+        center: {
+            latitude: (north + south) / 2,
+            longitude: (east + west) / 2,
+        },
+        bounds: {
+            north,
+            south,
+            east,
+            west,
+        },
+        span: {
+            latitudeDelta,
+            longitudeDelta,
+        },
+        recommendedZoom: estimateCameraZoom(latitudeDelta, longitudeDelta, options),
+    };
+}
+async function fitCameraFromPoints(map, points, options = {}) {
+    const normalized = normalizeLatLngList(points);
+    if (normalized.length === 0) {
+        return;
+    }
+    const currentCamera = await map.getCameraPosition().catch(() => ({}));
+    if (normalized.length === 1) {
+        await map.moveCamera({
+            target: normalized[0],
+            zoom: options.singlePointZoom ?? currentCamera.zoom ?? DEFAULT_SINGLE_POINT_ZOOM,
+            bearing: options.preserveBearing === false
+                ? options.bearing
+                : currentCamera.bearing ?? options.bearing,
+            tilt: options.preserveTilt === false
+                ? options.tilt
+                : currentCamera.tilt ?? options.tilt,
+        }, options.duration ?? 0);
+        return;
+    }
+    const routeBounds = getCameraRouteBounds(normalized, options);
+    if (!routeBounds) {
+        return;
+    }
+    await map.moveCamera({
+        target: routeBounds.center,
+        zoom: routeBounds.recommendedZoom,
+        bearing: options.preserveBearing === false
+            ? options.bearing
+            : currentCamera.bearing ?? options.bearing,
+        tilt: options.preserveTilt === false
+            ? options.tilt
+            : currentCamera.tilt ?? options.tilt,
+    }, options.duration ?? 0);
+}
+function buildCameraBounds(points) {
+    const routeBounds = getCameraRouteBounds(points);
+    if (!routeBounds) {
+        return null;
+    }
+    return {
+        southwest: {
+            latitude: routeBounds.bounds.south,
+            longitude: routeBounds.bounds.west,
+        },
+        northeast: {
+            latitude: routeBounds.bounds.north,
+            longitude: routeBounds.bounds.east,
+        },
+    };
+}

package/build/v3/runtime-assembly.d.ts

@@ -0,0 +1,23 @@
+import type { GeocodeProvider, RouteProvider, SearchProvider } from './contracts';
+import type { GaodeRuntime, RuntimeClientOptions } from './runtime';
+export interface RuntimeCapabilityAdapter {
+    source: string;
+    priority?: number;
+    enabled?: boolean;
+    searchProviders?: SearchProvider[];
+    geocodeProviders?: GeocodeProvider[];
+    routeProviders?: RouteProvider[];
+}
+export interface RuntimeProviderSet {
+    searchProviders: SearchProvider[];
+    geocodeProviders: GeocodeProvider[];
+    routeProviders: RouteProvider[];
+}
+export interface AssembleRuntimeProvidersOptions {
+    adapters: RuntimeCapabilityAdapter[];
+    dedupeByKind?: boolean;
+}
+export interface CapabilityRuntimeOptions extends RuntimeClientOptions, AssembleRuntimeProvidersOptions {
+}
+export declare function assembleRuntimeProviders(options: AssembleRuntimeProvidersOptions): RuntimeProviderSet;
+export declare function createCapabilityRuntime(options: CapabilityRuntimeOptions): GaodeRuntime;

package/build/v3/runtime-assembly.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assembleRuntimeProviders = assembleRuntimeProviders;
+exports.createCapabilityRuntime = createCapabilityRuntime;
+const runtime_1 = require("./runtime");
+function dedupeProvidersByKind(providers, dedupeByKind) {
+    if (!dedupeByKind) {
+        return providers;
+    }
+    const seenKinds = new Set();
+    return providers.filter((provider) => {
+        if (seenKinds.has(provider.kind)) {
+            return false;
+        }
+        seenKinds.add(provider.kind);
+        return true;
+    });
+}
+function assembleRuntimeProviders(options) {
+    const sortedAdapters = (options.adapters ?? [])
+        .filter((adapter) => adapter.enabled !== false)
+        .map((adapter, index) => ({ ...adapter, index }))
+        .sort((left, right) => {
+        const leftPriority = left.priority ?? 0;
+        const rightPriority = right.priority ?? 0;
+        if (leftPriority !== rightPriority) {
+            return leftPriority - rightPriority;
+        }
+        return left.index - right.index;
+    });
+    const searchProviders = sortedAdapters.flatMap((adapter) => adapter.searchProviders ?? []);
+    const geocodeProviders = sortedAdapters.flatMap((adapter) => adapter.geocodeProviders ?? []);
+    const routeProviders = sortedAdapters.flatMap((adapter) => adapter.routeProviders ?? []);
+    const dedupeByKind = options.dedupeByKind ?? true;
+    return {
+        searchProviders: dedupeProvidersByKind(searchProviders, dedupeByKind),
+        geocodeProviders: dedupeProvidersByKind(geocodeProviders, dedupeByKind),
+        routeProviders: dedupeProvidersByKind(routeProviders, dedupeByKind),
+    };
+}
+function createCapabilityRuntime(options) {
+    const providers = assembleRuntimeProviders(options);
+    return (0, runtime_1.createGaodeRuntime)({
+        continueOnError: options.continueOnError,
+        onProviderError: options.onProviderError,
+        searchProviders: providers.searchProviders,
+        geocodeProviders: providers.geocodeProviders,
+        routeProviders: providers.routeProviders,
+    });
+}

package/build/v3/runtime-factories.d.ts

@@ -0,0 +1,33 @@
+import type { GaodeRuntime, RuntimeClientOptions } from './runtime';
+import type { RuntimeCapabilityAdapter } from './runtime-assembly';
+import type { WebGeocodeProviderFactoryOptions } from './web-geocode-provider';
+import type { WebRouteProviderFactoryOptions } from './web-route-provider';
+import type { WebProviderFactoryOptions } from './web-search-provider';
+export interface WebRuntimeFactoryOptions extends RuntimeClientOptions {
+    search?: WebProviderFactoryOptions;
+    geocode?: WebGeocodeProviderFactoryOptions;
+    route?: WebRouteProviderFactoryOptions;
+}
+export interface WebDataRuntimeFactoryOptions extends RuntimeClientOptions {
+    search?: WebProviderFactoryOptions;
+    geocode?: WebGeocodeProviderFactoryOptions;
+}
+export interface WebCapabilityAdapterOptions {
+    source?: string;
+    priority?: number;
+    enabled?: boolean;
+    search?: WebProviderFactoryOptions;
+    geocode?: WebGeocodeProviderFactoryOptions;
+    route?: WebRouteProviderFactoryOptions;
+}
+export interface WebDataCapabilityAdapterOptions {
+    source?: string;
+    priority?: number;
+    enabled?: boolean;
+    search?: WebProviderFactoryOptions;
+    geocode?: WebGeocodeProviderFactoryOptions;
+}
+export declare function createWebCapabilityAdapter(options?: WebCapabilityAdapterOptions): RuntimeCapabilityAdapter;
+export declare function createWebDataCapabilityAdapter(options?: WebDataCapabilityAdapterOptions): RuntimeCapabilityAdapter;
+export declare function createWebRuntime(options?: WebRuntimeFactoryOptions): GaodeRuntime;
+export declare function createWebDataRuntime(options?: WebDataRuntimeFactoryOptions): GaodeRuntime;

package/build/v3/runtime-factories.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebCapabilityAdapter = createWebCapabilityAdapter;
+exports.createWebDataCapabilityAdapter = createWebDataCapabilityAdapter;
+exports.createWebRuntime = createWebRuntime;
+exports.createWebDataRuntime = createWebDataRuntime;
+const web_geocode_provider_1 = require("./web-geocode-provider");
+const web_route_provider_1 = require("./web-route-provider");
+const web_search_provider_1 = require("./web-search-provider");
+const runtime_assembly_1 = require("./runtime-assembly");
+function createWebCapabilityAdapter(options = {}) {
+    return {
+        source: options.source ?? 'web-api',
+        priority: options.priority,
+        enabled: options.enabled,
+        searchProviders: [(0, web_search_provider_1.createWebSearchProvider)(options.search)],
+        geocodeProviders: [(0, web_geocode_provider_1.createWebGeocodeProvider)(options.geocode)],
+        routeProviders: [(0, web_route_provider_1.createWebRouteProvider)(options.route)],
+    };
+}
+function createWebDataCapabilityAdapter(options = {}) {
+    return {
+        source: options.source ?? 'web-data',
+        priority: options.priority,
+        enabled: options.enabled,
+        searchProviders: [(0, web_search_provider_1.createWebSearchProvider)(options.search)],
+        geocodeProviders: [(0, web_geocode_provider_1.createWebGeocodeProvider)(options.geocode)],
+        routeProviders: [],
+    };
+}
+function createWebRuntime(options = {}) {
+    return (0, runtime_assembly_1.createCapabilityRuntime)({
+        ...options,
+        adapters: [createWebCapabilityAdapter(options)],
+    });
+}
+function createWebDataRuntime(options = {}) {
+    return (0, runtime_assembly_1.createCapabilityRuntime)({
+        ...options,
+        adapters: [createWebDataCapabilityAdapter(options)],
+    });
+}

package/build/v3/runtime.d.ts

@@ -0,0 +1,80 @@
+import type { DrivingRouteParams, GeocodeProvider, InputTipsParams, KeywordSearchParams, NearbySearchParams, PolygonSearchParams, ReverseGeocodeParams, RouteProvider, SearchProvider, TransitRouteParams } from './contracts';
+import type { ReverseGeocodeResult, RoutePlan, SearchPOI, SearchPage, SearchSuggestion } from './domain';
+export type RuntimeClientKind = 'search' | 'geocode' | 'route';
+export type GaodeRuntimeErrorType = 'provider' | 'runtime' | 'config' | 'validation' | 'network' | 'unknown';
+export interface GaodeUnifiedError {
+    code: string;
+    type: GaodeRuntimeErrorType | string;
+    message: string;
+    retryable: boolean;
+    cause?: unknown;
+}
+export interface ProviderErrorContext {
+    client: RuntimeClientKind;
+    method: string;
+    providerKind: string;
+    providerIndex: number;
+}
+export interface RuntimeClientOptions {
+    continueOnError?: boolean;
+    onProviderError?: (context: ProviderErrorContext, error: unknown) => void;
+}
+export declare class GaodeProviderError extends Error implements GaodeUnifiedError {
+    readonly code: string;
+    readonly type: GaodeRuntimeErrorType;
+    readonly retryable: boolean;
+    readonly cause?: unknown;
+    readonly client: RuntimeClientKind;
+    readonly method: string;
+    readonly attemptedProviders: string[];
+    readonly causes: unknown[];
+    constructor(options: {
+        client: RuntimeClientKind;
+        method: string;
+        attemptedProviders: string[];
+        causes: unknown[];
+        message?: string;
+    });
+    toJSON(): GaodeUnifiedError & {
+        client: RuntimeClientKind;
+        method: string;
+        attemptedProviders: string[];
+    };
+}
+export interface SearchClient {
+    searchKeyword(params: KeywordSearchParams): Promise<SearchPage<SearchPOI>>;
+    searchNearby(params: NearbySearchParams): Promise<SearchPage<SearchPOI>>;
+    searchAlong(params: import('./contracts').AlongSearchParams): Promise<SearchPage<SearchPOI>>;
+    searchPolygon(params: PolygonSearchParams): Promise<SearchPage<SearchPOI>>;
+    getInputTips(params: InputTipsParams): Promise<SearchPage<SearchSuggestion>>;
+    getPoiDetail(id: string): Promise<SearchPOI | null>;
+}
+export interface GeocodeClient {
+    reverseGeocode(params: ReverseGeocodeParams): Promise<ReverseGeocodeResult>;
+}
+export interface RouteClient {
+    calculateDrivingRoute(params: DrivingRouteParams): Promise<RoutePlan>;
+    calculateWalkingRoute(params: DrivingRouteParams): Promise<RoutePlan>;
+    calculateBicyclingRoute(params: DrivingRouteParams): Promise<RoutePlan>;
+    calculateElectricBikeRoute(params: DrivingRouteParams): Promise<RoutePlan>;
+    calculateTransitRoutes(params: TransitRouteParams): Promise<RoutePlan[]>;
+}
+export interface GaodeRuntimeOptions extends RuntimeClientOptions {
+    searchProviders?: SearchProvider[];
+    geocodeProviders?: GeocodeProvider[];
+    routeProviders?: RouteProvider[];
+}
+export interface GaodeRuntime {
+    search: SearchClient;
+    geocode: GeocodeClient;
+    route: RouteClient;
+    providers: {
+        search: SearchProvider[];
+        geocode: GeocodeProvider[];
+        route: RouteProvider[];
+    };
+}
+export declare function createSearchClient(providers: SearchProvider[], options?: RuntimeClientOptions): SearchClient;
+export declare function createGeocodeClient(providers: GeocodeProvider[], options?: RuntimeClientOptions): GeocodeClient;
+export declare function createRouteClient(providers: RouteProvider[], options?: RuntimeClientOptions): RouteClient;
+export declare function createGaodeRuntime(options?: GaodeRuntimeOptions): GaodeRuntime;

package/build/v3/runtime.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GaodeProviderError = void 0;
+exports.createSearchClient = createSearchClient;
+exports.createGeocodeClient = createGeocodeClient;
+exports.createRouteClient = createRouteClient;
+exports.createGaodeRuntime = createGaodeRuntime;
+class GaodeProviderError extends Error {
+    constructor(options) {
+        const hasProviders = options.attemptedProviders.length > 0;
+        super(options.message ??
+            `[v3:${options.client}] ${options.method} failed after trying ${options.attemptedProviders.join(', ')}`);
+        this.name = 'GaodeProviderError';
+        this.code = hasProviders ? 'PROVIDER_CALL_FAILED' : 'PROVIDER_NOT_REGISTERED';
+        this.type = hasProviders ? 'provider' : 'config';
+        this.retryable = hasProviders;
+        this.cause = options.causes[0];
+        this.client = options.client;
+        this.method = options.method;
+        this.attemptedProviders = options.attemptedProviders;
+        this.causes = options.causes;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            type: this.type,
+            message: this.message,
+            retryable: this.retryable,
+            cause: this.cause,
+            client: this.client,
+            method: this.method,
+            attemptedProviders: this.attemptedProviders,
+        };
+    }
+}
+exports.GaodeProviderError = GaodeProviderError;
+async function callProviders(providers, client, method, runner, options = {}) {
+    const attemptedProviders = [];
+    const causes = [];
+    for (let index = 0; index < providers.length; index += 1) {
+        const provider = providers[index];
+        attemptedProviders.push(provider.kind);
+        try {
+            return await runner(provider);
+        }
+        catch (error) {
+            causes.push(error);
+            options.onProviderError?.({
+                client,
+                method,
+                providerKind: provider.kind,
+                providerIndex: index,
+            }, error);
+            if (!options.continueOnError) {
+                break;
+            }
+        }
+    }
+    throw new GaodeProviderError({
+        client,
+        method,
+        attemptedProviders,
+        causes,
+        message: attemptedProviders.length === 0
+            ? `[v3:${client}] ${method} has no registered providers`
+            : undefined,
+    });
+}
+function getSupportedProviders(providers, predicate) {
+    return providers.filter(predicate);
+}
+function createSearchClient(providers, options = {}) {
+    return {
+        searchKeyword(params) {
+            return callProviders(providers, 'search', 'searchKeyword', (provider) => provider.searchKeyword(params), options);
+        },
+        searchNearby(params) {
+            return callProviders(providers, 'search', 'searchNearby', (provider) => provider.searchNearby(params), options);
+        },
+        searchAlong(params) {
+            const supportedProviders = getSupportedProviders(providers, (provider) => typeof provider.searchAlong === 'function');
+            return callProviders(supportedProviders, 'search', 'searchAlong', (provider) => provider.searchAlong(params), options);
+        },
+        searchPolygon(params) {
+            const supportedProviders = getSupportedProviders(providers, (provider) => typeof provider.searchPolygon === 'function');
+            return callProviders(supportedProviders, 'search', 'searchPolygon', (provider) => provider.searchPolygon(params), options);
+        },
+        getInputTips(params) {
+            return callProviders(providers, 'search', 'getInputTips', (provider) => provider.getInputTips(params), options);
+        },
+        getPoiDetail(id) {
+            const supportedProviders = getSupportedProviders(providers, (provider) => typeof provider.getPoiDetail === 'function');
+            return callProviders(supportedProviders, 'search', 'getPoiDetail', (provider) => provider.getPoiDetail(id), options);
+        },
+    };
+}
+function createGeocodeClient(providers, options = {}) {
+    return {
+        reverseGeocode(params) {
+            return callProviders(providers, 'geocode', 'reverseGeocode', (provider) => provider.reverseGeocode(params), options);
+        },
+    };
+}
+function createRouteClient(providers, options = {}) {
+    return {
+        calculateDrivingRoute(params) {
+            return callProviders(providers, 'route', 'calculateDrivingRoute', (provider) => provider.calculateDrivingRoute(params), options);
+        },
+        calculateWalkingRoute(params) {
+            const supportedProviders = getSupportedProviders(providers, (provider) => typeof provider.calculateWalkingRoute === 'function');
+            return callProviders(supportedProviders, 'route', 'calculateWalkingRoute', (provider) => provider.calculateWalkingRoute(params), options);
+        },
+        calculateBicyclingRoute(params) {
+            const supportedProviders = getSupportedProviders(providers, (provider) => typeof provider.calculateBicyclingRoute === 'function');
+            return callProviders(supportedProviders, 'route', 'calculateBicyclingRoute', (provider) => provider.calculateBicyclingRoute(params), options);
+        },
+        calculateElectricBikeRoute(params) {
+            const supportedProviders = getSupportedProviders(providers, (provider) => typeof provider.calculateElectricBikeRoute === 'function');
+            return callProviders(supportedProviders, 'route', 'calculateElectricBikeRoute', (provider) => provider.calculateElectricBikeRoute(params), options);
+        },
+        calculateTransitRoutes(params) {
+            const supportedProviders = getSupportedProviders(providers, (provider) => typeof provider.calculateTransitRoutes === 'function');
+            return callProviders(supportedProviders, 'route', 'calculateTransitRoutes', (provider) => provider.calculateTransitRoutes(params), options);
+        },
+    };
+}
+function createGaodeRuntime(options = {}) {
+    const searchProviders = options.searchProviders ?? [];
+    const geocodeProviders = options.geocodeProviders ?? [];
+    const routeProviders = options.routeProviders ?? [];
+    return {
+        search: createSearchClient(searchProviders, options),
+        geocode: createGeocodeClient(geocodeProviders, options),
+        route: createRouteClient(routeProviders, options),
+        providers: {
+            search: searchProviders,
+            geocode: geocodeProviders,
+            route: routeProviders,
+        },
+    };
+}

package/build/v3/web-geocode-provider.d.ts

@@ -0,0 +1,8 @@
+import type { ClientConfig } from '../utils/client';
+import { type WebGeocodeApiAdapter } from './web-service-adapter';
+import type { GeocodeProvider } from './contracts';
+export interface WebGeocodeProviderFactoryOptions {
+    api?: WebGeocodeApiAdapter;
+    config?: ClientConfig;
+}
+export declare function createWebGeocodeProvider(options?: WebGeocodeProviderFactoryOptions): GeocodeProvider;

package/build/v3/web-geocode-provider.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebGeocodeProvider = createWebGeocodeProvider;
+const web_service_adapter_1 = require("./web-service-adapter");
+function getApi(options = {}) {
+    if (options.api) {
+        return options.api;
+    }
+    return (0, web_service_adapter_1.createWebGeocodeApiAdapter)(options.config);
+}
+function parseLocation(location) {
+    if (!location) {
+        return null;
+    }
+    const [longitude, latitude] = location.split(',').map((value) => Number(value.trim()));
+    if (!Number.isFinite(longitude) || !Number.isFinite(latitude)) {
+        return null;
+    }
+    return {
+        latitude,
+        longitude,
+    };
+}
+function normalizePois(regeocode) {
+    return (regeocode.pois ?? []).map((poi) => ({
+        id: poi.id,
+        name: poi.name,
+        address: poi.address,
+        location: parseLocation(poi.location),
+        typeName: poi.type,
+        distanceMeters: poi.distance ? Number(poi.distance) : undefined,
+        source: 'web',
+    }));
+}
+function toReverseGeocodeResult(response, location) {
+    return {
+        formattedAddress: response.regeocode?.formatted_address ?? '',
+        location,
+        pois: response.regeocode ? normalizePois(response.regeocode) : [],
+        raw: response,
+    };
+}
+function createWebGeocodeProvider(options = {}) {
+    const api = getApi(options);
+    return {
+        kind: 'web-geocode',
+        async reverseGeocode(params) {
+            const response = await api.geocode.regeocode(params.location, {
+                radius: params.radius,
+                extensions: params.extensions ?? 'all',
+            });
+            return toReverseGeocodeResult(response, params.location);
+        },
+    };
+}

package/build/v3/web-route-provider.d.ts

@@ -0,0 +1,8 @@
+import type { ClientConfig } from '../utils/client';
+import { type WebRouteApiAdapter } from './web-service-adapter';
+import type { RouteProvider } from './contracts';
+export interface WebRouteProviderFactoryOptions {
+    api?: WebRouteApiAdapter;
+    config?: ClientConfig;
+}
+export declare function createWebRouteProvider(options?: WebRouteProviderFactoryOptions): RouteProvider;