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

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebRouteProvider = createWebRouteProvider;
+const normalizers_1 = require("../utils/normalizers");
+const web_service_adapter_1 = require("./web-service-adapter");
+function getApi(options = {}) {
+    if (options.api) {
+        return options.api;
+    }
+    return (0, web_service_adapter_1.createWebRouteApiAdapter)(options.config);
+}
+function normalizeSinglePlan(response) {
+    const firstPath = response.route?.paths?.[0];
+    return {
+        distanceMeters: Number(firstPath?.distance ?? 0),
+        durationSeconds: Number(firstPath?.cost?.duration ?? firstPath?.duration ?? 0),
+        path: (0, normalizers_1.extractRoutePoints)(response),
+        source: 'web',
+        raw: response,
+    };
+}
+function normalizeTransitPlans(response) {
+    const paths = (0, normalizers_1.extractTransitRoutePoints)(response);
+    const transits = response.route?.transits ?? [];
+    return paths.map((path, index) => ({
+        distanceMeters: Number(transits[index]?.distance ?? 0),
+        durationSeconds: Number(transits[index]?.cost?.duration ?? 0),
+        path,
+        source: 'web',
+        raw: transits[index] ?? response,
+    }));
+}
+function toCoordinateString(point) {
+    return `${point.longitude},${point.latitude}`;
+}
+function createWebRouteProvider(options = {}) {
+    const api = getApi(options);
+    return {
+        kind: 'web-route',
+        async calculateDrivingRoute(params) {
+            const response = await api.route.driving(params.origin, params.destination, {
+                show_fields: 'cost,polyline',
+                strategy: typeof params.strategy === 'number' ? params.strategy : undefined,
+                waypoints: params.waypoints?.map(toCoordinateString),
+            });
+            return normalizeSinglePlan(response);
+        },
+        async calculateWalkingRoute(params) {
+            const response = await api.route.walking(params.origin, params.destination, {
+                show_fields: 'cost,polyline',
+            });
+            return normalizeSinglePlan(response);
+        },
+        async calculateBicyclingRoute(params) {
+            const response = await api.route.bicycling(params.origin, params.destination, {
+                show_fields: 'cost,polyline',
+            });
+            return normalizeSinglePlan(response);
+        },
+        async calculateElectricBikeRoute(params) {
+            const response = await api.route.electricBike(params.origin, params.destination, {
+                show_fields: 'cost,polyline',
+            });
+            return normalizeSinglePlan(response);
+        },
+        async calculateTransitRoutes(params) {
+            const response = await api.route.transit(params.origin, params.destination, params.city1, params.city2, {
+                strategy: typeof params.strategy === 'number' ? params.strategy : undefined,
+                AlternativeRoute: params.alternativeRoute,
+                show_fields: 'cost,polyline',
+            });
+            return normalizeTransitPlans(response);
+        },
+    };
+}

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

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

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

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebSearchProvider = createWebSearchProvider;
+const web_service_adapter_1 = require("./web-service-adapter");
+function getApi(options = {}) {
+    if (options.api) {
+        return options.api;
+    }
+    return (0, web_service_adapter_1.createWebSearchApiAdapter)(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 toSearchPoi(poi) {
+    return {
+        id: poi.id,
+        name: poi.name,
+        address: poi.address,
+        location: parseLocation(poi.location),
+        typeCode: poi.typecode,
+        typeName: poi.type,
+        distanceMeters: poi.distance ? Number(poi.distance) : undefined,
+        cityCode: poi.citycode,
+        cityName: poi.cityname,
+        districtCode: poi.adcode,
+        districtName: poi.adname,
+        provinceName: poi.pname,
+        source: 'web',
+    };
+}
+function toSearchSuggestion(tip) {
+    return {
+        id: tip.id,
+        name: tip.name,
+        address: tip.address,
+        location: parseLocation(tip.location),
+        districtName: tip.district,
+        typeCode: tip.typecode,
+        source: 'web',
+    };
+}
+function toSearchPage(response) {
+    return {
+        items: response.pois.map(toSearchPoi),
+        total: Number(response.count),
+        page: null,
+        pageSize: null,
+        raw: response,
+    };
+}
+function toInputTipsPage(response) {
+    return {
+        items: response.tips.map(toSearchSuggestion),
+        total: Number(response.count),
+        page: null,
+        pageSize: null,
+        raw: response,
+    };
+}
+function createWebSearchProvider(options = {}) {
+    const api = getApi(options);
+    return {
+        kind: 'web-search',
+        async searchKeyword(params) {
+            const response = await api.poi.search(params.keyword, {
+                region: params.city,
+                city_limit: params.cityLimit,
+                types: params.types,
+                page_num: params.page,
+                page_size: params.pageSize,
+            });
+            return toSearchPage(response);
+        },
+        async searchNearby(params) {
+            const response = await api.poi.searchAround(params.center, {
+                keywords: params.keyword,
+                radius: params.radius,
+                types: params.types,
+                page_num: params.page,
+                page_size: params.pageSize,
+                sortrule: 'distance',
+            });
+            return toSearchPage(response);
+        },
+        async searchPolygon(params) {
+            const polygon = params.polygon
+                .map((point) => `${point.longitude},${point.latitude}`)
+                .join('|');
+            const response = await api.poi.searchPolygon(polygon, {
+                keywords: params.keyword,
+                types: params.types,
+                page_num: params.page,
+                page_size: params.pageSize,
+            });
+            return toSearchPage(response);
+        },
+        async getInputTips(params) {
+            const response = await api.inputTips.getTips(params.keyword, {
+                city: params.city,
+                type: params.types,
+                datatype: params.datatype,
+                citylimit: params.cityLimit,
+                location: params.location
+                    ? `${params.location.longitude},${params.location.latitude}`
+                    : undefined,
+            });
+            return toInputTipsPage(response);
+        },
+        async getPoiDetail(id) {
+            const response = await api.poi.getDetail(id);
+            const [poi] = response.pois ?? [];
+            return poi ? toSearchPoi(poi) : null;
+        },
+    };
+}

package/build/v3/web-service-adapter.d.ts

@@ -0,0 +1,18 @@
+import type { ClientConfig } from '../utils/client';
+import { GeocodeService } from '../services/GeocodeService';
+import { InputTipsService } from '../services/InputTipsService';
+import { POIService } from '../services/POIService';
+import { RouteService } from '../services/RouteService';
+export interface WebSearchApiAdapter {
+    poi: Pick<POIService, 'search' | 'searchAround' | 'searchPolygon' | 'getDetail'>;
+    inputTips: Pick<InputTipsService, 'getTips'>;
+}
+export interface WebGeocodeApiAdapter {
+    geocode: Pick<GeocodeService, 'regeocode'>;
+}
+export interface WebRouteApiAdapter {
+    route: Pick<RouteService, 'driving' | 'walking' | 'bicycling' | 'electricBike' | 'transit'>;
+}
+export declare function createWebSearchApiAdapter(config?: ClientConfig): WebSearchApiAdapter;
+export declare function createWebGeocodeApiAdapter(config?: ClientConfig): WebGeocodeApiAdapter;
+export declare function createWebRouteApiAdapter(config?: ClientConfig): WebRouteApiAdapter;

package/build/v3/web-service-adapter.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebSearchApiAdapter = createWebSearchApiAdapter;
+exports.createWebGeocodeApiAdapter = createWebGeocodeApiAdapter;
+exports.createWebRouteApiAdapter = createWebRouteApiAdapter;
+const client_1 = require("../utils/client");
+const GeocodeService_1 = require("../services/GeocodeService");
+const InputTipsService_1 = require("../services/InputTipsService");
+const POIService_1 = require("../services/POIService");
+const RouteService_1 = require("../services/RouteService");
+function createClient(config) {
+    return new client_1.GaodeWebAPIClient(config ?? {});
+}
+function createWebSearchApiAdapter(config) {
+    const client = createClient(config);
+    return {
+        poi: new POIService_1.POIService(client),
+        inputTips: new InputTipsService_1.InputTipsService(client),
+    };
+}
+function createWebGeocodeApiAdapter(config) {
+    const client = createClient(config);
+    return {
+        geocode: new GeocodeService_1.GeocodeService(client),
+    };
+}
+function createWebRouteApiAdapter(config) {
+    const client = createClient(config);
+    return {
+        route: new RouteService_1.RouteService(client),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-gaode-map-web-api",
-  "version": "2.0.3",
+  "version": "2.0.5-next.0",
   "description": "高德地图 Web API 服务 - 搜索、路径规划、地理编码（纯 JavaScript 实现），配合 expo-gaode-map或者 expo-gaode-map-navigation 使用",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -27,13 +27,17 @@
     "route",
     "高德地图"
   ],
-  "repository": "https://github.com/TomWq/expo-gaode-map",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TomWq/expo-gaode-map",
+    "directory": "packages/web-api"
+  },
   "bugs": {
     "url": "https://github.com/TomWq/expo-gaode-map/issues"
   },
-  "author": "(https://github.com/TomWq)",
+  "author": "TomWq <582752848@qq.com> (https://github.com/TomWq)",
   "license": "MIT",
-  "homepage": "https://github.com/TomWq/expo-gaode-map#readme",
+  "homepage": "https://tomwq.github.io/expo-gaode-map/",
   "devDependencies": {
     "@types/react": "~19.1.0",
     "bun-types": "^1.3.6",