wehub-resource-sync
1221 lines
47 KiB
JavaScript
1221 lines
47 KiB
JavaScript
#!/usr/bin/env node
|
||
/**
|
||
* Map App 的可选地理信息快照生成工具。
|
||
* 调用 Google Maps API，刷新 apps/Map/data/places.json 和 routes.json。
|
||
*
|
||
* 四个阶段独立控制：搜索 (search) → 搜索提示 (autocomplete) → 详情 (details) → 路线 (routes)
|
||
* 默认：增量（只处理缺失项）。可用 --full 指定全量重建某阶段、--skip 跳过。
|
||
*
|
||
* Usage:
|
||
* node apps/Map/scripts/fetch_geo_snapshot.mjs # 增量：补齐所有阶段
|
||
* node apps/Map/scripts/fetch_geo_snapshot.mjs --full search # 全量搜索 + 增量详情 + 增量路线
|
||
* node apps/Map/scripts/fetch_geo_snapshot.mjs --full autocomplete # 增量搜索 + 全量搜索提示 + 增量详情 + 增量路线
|
||
* node apps/Map/scripts/fetch_geo_snapshot.mjs --full details # 增量搜索 + 全量详情 + 增量路线
|
||
* node apps/Map/scripts/fetch_geo_snapshot.mjs --full routes # 增量搜索 + 增量详情 + 全量路线
|
||
* node apps/Map/scripts/fetch_geo_snapshot.mjs --full all # 全量搜索 + 全量详情 + 全量路线
|
||
* node apps/Map/scripts/fetch_geo_snapshot.mjs --skip details # 增量搜索 + 跳过详情 + 增量路线
|
||
* node apps/Map/scripts/fetch_geo_snapshot.mjs --skip details,routes # 增量搜索 + 跳过详情和路线
|
||
* node apps/Map/scripts/fetch_geo_snapshot.mjs --full search --skip routes # 全量搜索 + 增量详情 + 跳过路线
|
||
*
|
||
* 语义：
|
||
* 搜索全量 — search_index 精确重建（关键词集对齐 tasks.py，旧 key 删除，结果覆盖）。places 冗余保留。
|
||
* 搜索提示全量 — autocomplete_index 覆盖所有任务完整搜索词，结果来自 Maps JS SDK AutocompleteService（与 App 在线路径一致）。
|
||
* 详情全量 — 对 places 中所有 POI 重新拉取详情，覆盖旧值；autocomplete 中缺失的 place_id 会先补成 POI。
|
||
* 路线全量 — 对所有应存在的 route key 重新计算，覆盖旧值。冗余路线保留。
|
||
*
|
||
* 兼容旧 CLI：--patch（等价于默认增量）、--full-search、--skip-details、--skip-routes
|
||
*
|
||
* 输出: apps/Map/data/places.json, routes.json
|
||
*/
|
||
|
||
import { existsSync, readFileSync, writeFileSync, mkdirSync, mkdtempSync, rmSync } from 'fs';
|
||
import { spawn } from 'child_process';
|
||
import { createServer } from 'http';
|
||
import { tmpdir } from 'os';
|
||
import { resolve, dirname } from 'path';
|
||
import { fileURLToPath } from 'url';
|
||
|
||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||
const APP_DIR = resolve(__dirname, '..');
|
||
const ROOT = resolve(APP_DIR, '../..');
|
||
const OUT_DIR = resolve(APP_DIR, 'data');
|
||
const PLACES_PATH = resolve(OUT_DIR, 'places.json');
|
||
const ROUTES_PATH = resolve(OUT_DIR, 'routes.json');
|
||
|
||
// ─── 常量 ────────────────────────────────────────────────────────────────────
|
||
|
||
const SEARCH_RADIUS = 5000;
|
||
const CATEGORY_PAGE_SIZE = 20;
|
||
const PLACE_PAGE_SIZE = 10;
|
||
const MAX_PAGES = 3;
|
||
const MAX_POI_DISTANCE_KM = 100;
|
||
|
||
const PLACE_FIELDS = 'places.id,places.displayName,places.location,places.rating,places.userRatingCount,places.types,places.primaryType,places.formattedAddress,places.internationalPhoneNumber';
|
||
const SEARCH_FIELDS = PLACE_FIELDS + ',nextPageToken';
|
||
|
||
/**
|
||
* Places API v1 GET `places/{placeId}` 的 X-Goog-FieldMask 必须使用 **REST JSON 字段名**。
|
||
* 与 JS SDK `Place.fetchFields` 不同：REST 为 dineIn / takeout / restroom…，SDK 为 hasDineIn / hasTakeout / hasRestroom…
|
||
* 误用 SDK 字段名会导致 INVALID_ARGUMENT: Request contains an invalid argument.
|
||
* @see https://developers.google.com/maps/documentation/places/web-service/reference/rest/v1/places
|
||
*/
|
||
const PLACE_DETAIL_FIELD_MASK = [
|
||
'displayName', 'formattedAddress', 'location', 'rating', 'userRatingCount',
|
||
'businessStatus', 'types', 'primaryType', 'primaryTypeDisplayName',
|
||
'internationalPhoneNumber', 'nationalPhoneNumber', 'websiteUri',
|
||
'regularOpeningHours', 'currentOpeningHours', 'editorialSummary',
|
||
'plusCode', 'accessibilityOptions', 'paymentOptions', 'parkingOptions',
|
||
'dineIn', 'takeout', 'delivery', 'reservable',
|
||
'servesBreakfast', 'servesLunch', 'servesDinner', 'servesBrunch',
|
||
'servesBeer', 'servesWine', 'servesCocktails', 'servesCoffee',
|
||
'servesDessert', 'servesVegetarianFood',
|
||
'restroom', 'allowsDogs', 'outdoorSeating', 'liveMusic',
|
||
'menuForChildren', 'goodForChildren', 'goodForGroups', 'goodForWatchingSports',
|
||
].join(',');
|
||
|
||
const ROUTES_FIELD_MASK = [
|
||
'routes.legs.duration', 'routes.legs.distanceMeters',
|
||
'routes.legs.steps.navigationInstruction', 'routes.legs.steps.distanceMeters',
|
||
'routes.distanceMeters', 'routes.legs.localizedValues',
|
||
'routes.polyline.encodedPolyline', 'routes.legs.endLocation', 'routes.routeLabels',
|
||
].join(',');
|
||
|
||
// ─── 读取配置 ────────────────────────────────────────────────────────────────
|
||
|
||
function parseEnvValue(raw) {
|
||
const value = String(raw ?? '').trim();
|
||
if (!value) return '';
|
||
const quote = value[0];
|
||
if ((quote === '"' || quote === "'") && value.endsWith(quote)) {
|
||
return value.slice(1, -1);
|
||
}
|
||
return value.replace(/\s+#.*$/, '').trim();
|
||
}
|
||
|
||
function loadRootEnvFiles() {
|
||
const env = {};
|
||
for (const name of ['.env', '.env.local']) {
|
||
const envPath = resolve(ROOT, name);
|
||
if (!existsSync(envPath)) continue;
|
||
for (const line of readFileSync(envPath, 'utf-8').split('\n')) {
|
||
const m = line.match(/^\s*(?:export\s+)?([\w.]+)\s*=\s*(.*)$/);
|
||
if (m) env[m[1]] = parseEnvValue(m[2]);
|
||
}
|
||
}
|
||
for (const [key, value] of Object.entries(env)) {
|
||
if (process.env[key] === undefined) process.env[key] = value;
|
||
}
|
||
}
|
||
|
||
loadRootEnvFiles();
|
||
|
||
const AUTOCOMPLETE_LIMIT = 10;
|
||
const USE_CURL_FETCH = Boolean(
|
||
process.env.HTTPS_PROXY ||
|
||
process.env.HTTP_PROXY ||
|
||
process.env.ALL_PROXY ||
|
||
process.env.https_proxy ||
|
||
process.env.http_proxy ||
|
||
process.env.all_proxy,
|
||
);
|
||
|
||
function readApiKey() {
|
||
const key = process.env.VITE_GOOGLE_MAPS_API_KEY?.trim();
|
||
if (!key) {
|
||
throw new Error('未找到 VITE_GOOGLE_MAPS_API_KEY，请在 .env.local 或 .env 中设置');
|
||
}
|
||
return key;
|
||
}
|
||
|
||
function readSimulatedLocation() {
|
||
const content = readFileSync(resolve(ROOT, 'os/data/simulatorConfig.ts'), 'utf-8');
|
||
const lat = content.match(/latitude:\s*([\d.]+)/);
|
||
const lng = content.match(/longitude:\s*([\d.]+)/);
|
||
if (!lat || !lng) throw new Error('simulatorConfig.ts 中未找到 simulatedLocation');
|
||
return { latitude: parseFloat(lat[1]), longitude: parseFloat(lng[1]) };
|
||
}
|
||
|
||
// ─── 从 tasks.py 提取查询 ───────────────────────────────────────────────────
|
||
|
||
function extractQueriesFromTasks() {
|
||
const appPy = readFileSync(resolve(ROOT, 'bench_env/task/map/app.py'), 'utf-8');
|
||
const tasksPy = readFileSync(resolve(ROOT, 'bench_env/task/map/tasks.py'), 'utf-8');
|
||
|
||
const addBoth = (set, a, b) => {
|
||
if (a && String(a).trim()) set.add(String(a).trim());
|
||
if (b && String(b).trim()) set.add(String(b).trim());
|
||
};
|
||
|
||
const catBlock = appPy.match(/CATEGORY_PARAM\s*=\s*\{[\s\S]*?"values":\s*\{([\s\S]*?)\}/);
|
||
const categoryTypes = new Map();
|
||
if (catBlock) {
|
||
for (const m of catBlock[1].matchAll(/"([^"]+)":\s*"([^"]+)"/g)) {
|
||
categoryTypes.set(m[2], m[1]);
|
||
}
|
||
}
|
||
|
||
const placeBlock = appPy.match(/PLACE_PARAM\s*=\s*\{[\s\S]*?"values":\s*\{([\s\S]*?)\}/);
|
||
const placeQueries = new Set();
|
||
if (placeBlock) {
|
||
for (const m of placeBlock[1].matchAll(/"([^"]+?)":\s*"([^"]+)"/g)) {
|
||
addBoth(placeQueries, m[1], m[2]);
|
||
}
|
||
}
|
||
|
||
const restaurantBlock = appPy.match(/RESTAURANT_PARAM\s*=\s*\{[\s\S]*?"values":\s*\{([\s\S]*?)\}/);
|
||
if (restaurantBlock) {
|
||
for (const m of restaurantBlock[1].matchAll(/"([^"]+?)":\s*"([^"]+)"/g)) {
|
||
addBoth(placeQueries, m[1], m[2]);
|
||
}
|
||
}
|
||
|
||
const routePairs = [];
|
||
for (const block of tasksPy.matchAll(/parameters\s*=\s*\{([\s\S]*?)\n \}/g)) {
|
||
const text = block[1];
|
||
for (const m of text.matchAll(/"(place|restaurant)":\s*\{[^}]*?"default":\s*"([^"]+)"/g)) {
|
||
placeQueries.add(m[2]);
|
||
}
|
||
const originM = text.match(/"origin":\s*\{[^}]*?"default":\s*"([^"]+)"/);
|
||
const destM = text.match(/"destination":\s*\{[^}]*?"default":\s*"([^"]+)"/);
|
||
if (originM) placeQueries.add(originM[1]);
|
||
if (destM) placeQueries.add(destM[1]);
|
||
if (originM && destM) routePairs.push([originM[1], destM[1]]);
|
||
}
|
||
|
||
const aliasIdx = appPy.indexOf('PLACE_QUERY_ALIASES');
|
||
if (aliasIdx >= 0) {
|
||
const aliasSlice = appPy.slice(aliasIdx, appPy.indexOf('DRIVING_OD_PAIRS', aliasIdx));
|
||
for (const m of aliasSlice.matchAll(/"([^"]+)":\s*\(([^)]*)\)/g)) {
|
||
placeQueries.add(m[1]);
|
||
for (const am of m[2].matchAll(/"([^"]+)"/g)) {
|
||
placeQueries.add(am[1]);
|
||
}
|
||
}
|
||
}
|
||
|
||
const drivingPairsIdx = appPy.indexOf('DRIVING_OD_PAIRS');
|
||
if (drivingPairsIdx >= 0) {
|
||
const pairSlice = appPy.slice(drivingPairsIdx, drivingPairsIdx + 2000);
|
||
for (const m of pairSlice.matchAll(/\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g)) {
|
||
addBoth(placeQueries, m[1], m[2]);
|
||
routePairs.push([m[1], m[2]]);
|
||
}
|
||
}
|
||
|
||
// CheckRouteSuccess：_CHECK_ROUTE_OD_PAIRS（origin_id, dest_id, origin_hint, dest_hint）
|
||
const odIdx = tasksPy.indexOf('_CHECK_ROUTE_OD_PAIRS');
|
||
if (odIdx >= 0) {
|
||
const odSlice = tasksPy.slice(odIdx, odIdx + 6000);
|
||
const odRe =
|
||
/\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
|
||
for (const m of odSlice.matchAll(odRe)) {
|
||
routePairs.push([m[3], m[4]]);
|
||
}
|
||
}
|
||
|
||
const autocompleteTerms = new Set([...categoryTypes.values(), ...placeQueries]);
|
||
const autocompleteInputs = new Set(
|
||
[...autocompleteTerms]
|
||
.map((term) => String(term || '').trim())
|
||
.filter(Boolean),
|
||
);
|
||
|
||
return {
|
||
categoryTypes,
|
||
placeQueries: [...placeQueries],
|
||
routePairs,
|
||
autocompleteTerms: [...autocompleteTerms],
|
||
autocompleteInputs: [...autocompleteInputs],
|
||
};
|
||
}
|
||
|
||
// ─── 工具 ────────────────────────────────────────────────────────────────────
|
||
|
||
function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
|
||
|
||
function curlConfigQuote(value) {
|
||
return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
|
||
}
|
||
|
||
function requestJsonWithCurl(url, options = {}) {
|
||
return new Promise((resolveJson, rejectJson) => {
|
||
const dir = mkdtempSync(resolve(tmpdir(), 'map-geo-'));
|
||
const configPath = resolve(dir, 'curl.conf');
|
||
const bodyPath = resolve(dir, 'body.json');
|
||
const config = [
|
||
'silent',
|
||
'show-error',
|
||
'location',
|
||
'compressed',
|
||
'max-time = 60',
|
||
`url = "${curlConfigQuote(url)}"`,
|
||
];
|
||
|
||
const method = String(options.method || 'GET').toUpperCase();
|
||
if (method !== 'GET') {
|
||
config.push(`request = "${curlConfigQuote(method)}"`);
|
||
}
|
||
|
||
for (const [name, value] of Object.entries(options.headers || {})) {
|
||
config.push(`header = "${curlConfigQuote(`${name}: ${value}`)}"`);
|
||
}
|
||
|
||
if (options.body != null) {
|
||
writeFileSync(bodyPath, String(options.body), 'utf-8');
|
||
config.push(`data-binary = "@${curlConfigQuote(bodyPath)}"`);
|
||
}
|
||
|
||
writeFileSync(configPath, config.join('\n') + '\n', 'utf-8');
|
||
|
||
const child = spawn('curl', ['--config', configPath], {
|
||
stdio: ['ignore', 'pipe', 'pipe'],
|
||
});
|
||
|
||
let stdout = '';
|
||
let stderr = '';
|
||
child.stdout.setEncoding('utf-8');
|
||
child.stderr.setEncoding('utf-8');
|
||
child.stdout.on('data', (chunk) => { stdout += chunk; });
|
||
child.stderr.on('data', (chunk) => { stderr += chunk; });
|
||
child.on('error', (error) => {
|
||
rmSync(dir, { recursive: true, force: true });
|
||
rejectJson(error);
|
||
});
|
||
child.on('close', (code) => {
|
||
rmSync(dir, { recursive: true, force: true });
|
||
if (code !== 0) {
|
||
rejectJson(new Error(stderr.trim() || `curl exited with code ${code}`));
|
||
return;
|
||
}
|
||
try {
|
||
resolveJson(JSON.parse(stdout || '{}'));
|
||
} catch (error) {
|
||
rejectJson(new Error(`curl returned non-JSON response: ${String(error.message || error)}`));
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
async function requestJson(url, options = {}) {
|
||
if (USE_CURL_FETCH) {
|
||
return requestJsonWithCurl(url, options);
|
||
}
|
||
const res = await fetch(url, options);
|
||
return res.json();
|
||
}
|
||
|
||
const MAX_RETRIES = 3;
|
||
async function withRetry(fn, label) {
|
||
for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
|
||
const result = await fn();
|
||
if (result !== null) return result;
|
||
if (attempt < MAX_RETRIES) {
|
||
const wait = 1000 * 2 ** attempt;
|
||
console.error(` ↻ ${label} 重试 ${attempt + 1}/${MAX_RETRIES}（${wait / 1000}s 后）`);
|
||
await sleep(wait);
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
const CONCURRENCY = 5;
|
||
async function runConcurrent(tasks, concurrency = CONCURRENCY) {
|
||
let idx = 0;
|
||
let completed = 0;
|
||
const total = tasks.length;
|
||
async function worker() {
|
||
while (idx < total) {
|
||
const i = idx++;
|
||
await tasks[i]();
|
||
completed++;
|
||
if (completed % 20 === 0 || completed === total) {
|
||
process.stdout.write(` 进度: ${completed}/${total}\r`);
|
||
}
|
||
}
|
||
}
|
||
await Promise.all(Array.from({ length: Math.min(concurrency, total) }, () => worker()));
|
||
}
|
||
|
||
function haversineDistance(lat1, lng1, lat2, lng2) {
|
||
const R = 6371000;
|
||
const toRad = x => x * Math.PI / 180;
|
||
const dLat = toRad(lat2 - lat1);
|
||
const dLng = toRad(lng2 - lng1);
|
||
const a = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) ** 2;
|
||
return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
|
||
}
|
||
|
||
// ─── 数据解析 ────────────────────────────────────────────────────────────────
|
||
|
||
/** 与运行时 PlaceSearchResult 字段对齐 */
|
||
function parsePlaces(json, centerLat, centerLng) {
|
||
return (json.places || []).filter(p => p.id && p.location).map(p => ({
|
||
placeId: p.id,
|
||
name: p.displayName?.text || '',
|
||
lat: p.location.latitude,
|
||
lng: p.location.longitude,
|
||
rating: p.rating ?? undefined,
|
||
userRatingCount: p.userRatingCount ?? undefined,
|
||
types: p.types || [],
|
||
primaryType: p.primaryType || undefined,
|
||
formattedAddress: p.formattedAddress || '',
|
||
internationalPhoneNumber: p.internationalPhoneNumber ?? undefined,
|
||
distanceMeters: Math.round(haversineDistance(centerLat, centerLng, p.location.latitude, p.location.longitude)),
|
||
}));
|
||
}
|
||
|
||
function printResults(label, results) {
|
||
console.log(`\n ┌─ ${label} (${results.length} 条)`);
|
||
for (let i = 0; i < results.length; i++) {
|
||
const p = results[i];
|
||
const dist = p.distanceMeters != null
|
||
? (p.distanceMeters < 1000 ? `${p.distanceMeters}m` : `${(p.distanceMeters / 1000).toFixed(1)}km`)
|
||
: '?';
|
||
const rating = p.rating != null ? `${p.rating}★(${p.userRatingCount || 0})` : '无评分';
|
||
const type = p.primaryType || p.types?.[0] || '';
|
||
console.log(` │ ${String(i + 1).padStart(2)}. ${p.name} ${rating} ${type} ${dist}`);
|
||
}
|
||
console.log(' └─');
|
||
}
|
||
|
||
function collectAutocompletePlaceIds(snapshot) {
|
||
const ids = new Set();
|
||
for (const predictions of Object.values(snapshot.autocompleteIndex || {})) {
|
||
for (const prediction of predictions || []) {
|
||
if (prediction?.kind === 'place' && prediction.place_id) {
|
||
ids.add(String(prediction.place_id));
|
||
}
|
||
}
|
||
}
|
||
return ids;
|
||
}
|
||
|
||
function findAutocompletePrediction(snapshot, placeId) {
|
||
for (const predictions of Object.values(snapshot.autocompleteIndex || {})) {
|
||
for (const prediction of predictions || []) {
|
||
if (prediction?.kind === 'place' && prediction.place_id === placeId) {
|
||
return prediction;
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
function placeRowFromDetail(placeId, detail, loc, prediction) {
|
||
const lat = detail?.location?.latitude;
|
||
const lng = detail?.location?.longitude;
|
||
if (!Number.isFinite(lat) || !Number.isFinite(lng)) return null;
|
||
return {
|
||
placeId,
|
||
name: detail.displayName ?? prediction?.main_text ?? prediction?.description ?? placeId,
|
||
lat,
|
||
lng,
|
||
rating: detail.rating ?? undefined,
|
||
userRatingCount: detail.userRatingCount ?? undefined,
|
||
types: detail.types || [],
|
||
primaryType: detail.primaryType || undefined,
|
||
formattedAddress: detail.formattedAddress ?? prediction?.secondary_text ?? '',
|
||
internationalPhoneNumber: detail.internationalPhoneNumber ?? undefined,
|
||
distanceMeters: Math.round(haversineDistance(loc.latitude, loc.longitude, lat, lng)),
|
||
details: detail,
|
||
};
|
||
}
|
||
|
||
// ─── BiText 工具 ─────────────────────────────────────────────────────────────
|
||
|
||
/** 将 REST 详情 JSON 对齐为与 extractPlaceAboutData / 运行时一致（含 websiteURI） */
|
||
function normalizePlaceDetailForSnapshot(rest) {
|
||
if (!rest || typeof rest !== 'object') return rest;
|
||
return {
|
||
...rest,
|
||
websiteURI: rest.websiteURI ?? rest.websiteUri,
|
||
hasDineIn: rest.hasDineIn ?? rest.dineIn,
|
||
hasTakeout: rest.hasTakeout ?? rest.takeout,
|
||
hasDelivery: rest.hasDelivery ?? rest.delivery,
|
||
isReservable: rest.isReservable ?? rest.reservable,
|
||
hasRestroom: rest.hasRestroom ?? rest.restroom,
|
||
hasOutdoorSeating: rest.hasOutdoorSeating ?? rest.outdoorSeating,
|
||
hasLiveMusic: rest.hasLiveMusic ?? rest.liveMusic,
|
||
hasMenuForChildren: rest.hasMenuForChildren ?? rest.menuForChildren,
|
||
isGoodForChildren: rest.isGoodForChildren ?? rest.goodForChildren,
|
||
isGoodForGroups: rest.isGoodForGroups ?? rest.goodForGroups,
|
||
isGoodForWatchingSports: rest.isGoodForWatchingSports ?? rest.goodForWatchingSports,
|
||
};
|
||
}
|
||
|
||
/** 从 REST displayName/editorialSummary 等提取纯文本 */
|
||
function extractText(v) {
|
||
if (v == null) return undefined;
|
||
if (typeof v === 'string') return v;
|
||
if (typeof v === 'object' && 'text' in v) return v.text ?? '';
|
||
return undefined;
|
||
}
|
||
|
||
/** 构造 {zh, en} 对；单语言缺失时整个字段设为有值的那一份 */
|
||
function biText(zhVal, enVal) {
|
||
const zh = extractText(zhVal);
|
||
const en = extractText(enVal);
|
||
if (zh == null && en == null) return undefined;
|
||
if (zh == null) return en;
|
||
if (en == null) return zh;
|
||
if (zh === en) return zh;
|
||
return { zh, en };
|
||
}
|
||
|
||
function biArr(zhArr, enArr) {
|
||
if (!Array.isArray(zhArr) && !Array.isArray(enArr)) return undefined;
|
||
const zh = Array.isArray(zhArr) ? zhArr : [];
|
||
const en = Array.isArray(enArr) ? enArr : [];
|
||
if (zh.length === 0 && en.length === 0) return undefined;
|
||
if (JSON.stringify(zh) === JSON.stringify(en)) return zh;
|
||
return { zh, en };
|
||
}
|
||
|
||
// ─── Places Detail API ──────────────────────────────────────────────────────
|
||
|
||
async function fetchPlaceDetailOneLang(apiKey, placeId, lang) {
|
||
const url = `https://places.googleapis.com/v1/places/${encodeURIComponent(placeId)}?languageCode=${lang}`;
|
||
try {
|
||
const json = await requestJson(url, {
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
'X-Goog-Api-Key': apiKey,
|
||
'X-Goog-FieldMask': PLACE_DETAIL_FIELD_MASK,
|
||
},
|
||
});
|
||
if (json.error) {
|
||
console.error(` ⚠ place detail(${lang}) ${placeId.slice(0, 12)}...: ${json.error.message?.slice(0, 80)}`);
|
||
return null;
|
||
}
|
||
return json;
|
||
} catch (e) {
|
||
console.error(` ⚠ place detail(${lang}) ${placeId}: ${e.message?.slice(0, 80)}`);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 并行拉取 zh-CN + en 详情，语言相关字段合并为 BiText，其余取中文版
|
||
*/
|
||
async function fetchPlaceDetailREST(apiKey, placeId) {
|
||
const [zhRaw, enRaw] = await Promise.all([
|
||
fetchPlaceDetailOneLang(apiKey, placeId, 'zh-CN'),
|
||
fetchPlaceDetailOneLang(apiKey, placeId, 'en'),
|
||
]);
|
||
if (!zhRaw && !enRaw) return null;
|
||
const zh = normalizePlaceDetailForSnapshot(zhRaw || enRaw);
|
||
const en = enRaw ? normalizePlaceDetailForSnapshot(enRaw) : null;
|
||
|
||
zh.displayName = biText(zh.displayName, en?.displayName);
|
||
zh.formattedAddress = biText(zh.formattedAddress, en?.formattedAddress);
|
||
zh.editorialSummary = biText(zh.editorialSummary, en?.editorialSummary);
|
||
zh.primaryTypeDisplayName = biText(zh.primaryTypeDisplayName, en?.primaryTypeDisplayName);
|
||
|
||
const zhHrs = zh.regularOpeningHours;
|
||
const enHrs = en?.regularOpeningHours;
|
||
if (zhHrs && typeof zhHrs === 'object') {
|
||
const merged = biArr(zhHrs.weekdayDescriptions, enHrs?.weekdayDescriptions);
|
||
if (merged) zhHrs.weekdayDescriptions = merged;
|
||
}
|
||
const zhCurHrs = zh.currentOpeningHours;
|
||
const enCurHrs = en?.currentOpeningHours;
|
||
if (zhCurHrs && typeof zhCurHrs === 'object') {
|
||
const merged = biArr(zhCurHrs.weekdayDescriptions, enCurHrs?.weekdayDescriptions);
|
||
if (merged) zhCurHrs.weekdayDescriptions = merged;
|
||
}
|
||
|
||
return zh;
|
||
}
|
||
|
||
// ─── Places Search API ──────────────────────────────────────────────────────
|
||
|
||
async function searchTextOnePage(apiKey, query, includedType, pageSize, centerLat, centerLng, pageToken) {
|
||
const body = {
|
||
textQuery: query,
|
||
locationBias: {
|
||
circle: { center: { latitude: centerLat, longitude: centerLng }, radius: SEARCH_RADIUS },
|
||
},
|
||
pageSize,
|
||
languageCode: 'zh-CN',
|
||
};
|
||
if (includedType) body.includedType = includedType;
|
||
if (pageToken) body.pageToken = pageToken;
|
||
try {
|
||
const json = await requestJson('https://places.googleapis.com/v1/places:searchText', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json', 'X-Goog-Api-Key': apiKey, 'X-Goog-FieldMask': SEARCH_FIELDS },
|
||
body: JSON.stringify(body),
|
||
});
|
||
if (json.error) { console.error(` ⚠ searchText("${query}") error: ${json.error.message?.slice(0, 120)}`); return { places: [], nextPageToken: null }; }
|
||
return { places: parsePlaces(json, centerLat, centerLng), nextPageToken: json.nextPageToken || null };
|
||
} catch (e) {
|
||
console.error(` ⚠ searchText("${query}") 错误: ${e.message?.slice(0, 120)}`);
|
||
return { places: [], nextPageToken: null };
|
||
}
|
||
}
|
||
|
||
async function searchTextAllPages(apiKey, query, includedType, pageSize, centerLat, centerLng) {
|
||
const all = [];
|
||
let pageToken = null;
|
||
for (let page = 0; page < MAX_PAGES; page++) {
|
||
const { places, nextPageToken } = await searchTextOnePage(apiKey, query, includedType, pageSize, centerLat, centerLng, pageToken);
|
||
all.push(...places);
|
||
if (!nextPageToken) break;
|
||
pageToken = nextPageToken;
|
||
console.log(` 第 ${page + 2} 页...`);
|
||
await sleep(300);
|
||
}
|
||
return all;
|
||
}
|
||
|
||
function getQueryPredictionMainText(prediction) {
|
||
return prediction.terms?.[0]?.value ?? prediction.description ?? '';
|
||
}
|
||
|
||
function getQueryPredictionSecondaryText(prediction) {
|
||
return (prediction.terms || []).slice(1).map((term) => term.value).join(' ');
|
||
}
|
||
|
||
function startLocalSdkHost() {
|
||
const html = '<!doctype html><html><head><meta charset="utf-8"><title>Map SDK Snapshot</title></head><body></body></html>';
|
||
const server = createServer((_, res) => {
|
||
res.writeHead(200, {
|
||
'Content-Type': 'text/html; charset=utf-8',
|
||
'Cache-Control': 'no-store',
|
||
});
|
||
res.end(html);
|
||
});
|
||
return new Promise((resolveHost, rejectHost) => {
|
||
server.once('error', rejectHost);
|
||
server.listen(0, '127.0.0.1', () => {
|
||
const addr = server.address();
|
||
if (!addr || typeof addr === 'string') {
|
||
rejectHost(new Error('无法启动本地 JS SDK host'));
|
||
return;
|
||
}
|
||
resolveHost({
|
||
url: `http://127.0.0.1:${addr.port}/`,
|
||
close: () => new Promise((resolveClose) => server.close(resolveClose)),
|
||
});
|
||
});
|
||
});
|
||
}
|
||
|
||
async function createJsSdkAutocompleteClient(apiKey, loc) {
|
||
const { default: puppeteer } = await import('puppeteer');
|
||
const host = await startLocalSdkHost();
|
||
const browser = await puppeteer.launch({
|
||
headless: true,
|
||
args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage'],
|
||
});
|
||
const page = await browser.newPage();
|
||
page.on('console', (msg) => {
|
||
const text = msg.text();
|
||
if (text.startsWith('[JS SDK autocomplete]')) console.log(` ${text}`);
|
||
});
|
||
|
||
try {
|
||
await page.goto(host.url, { waitUntil: 'domcontentloaded' });
|
||
await page.evaluate((key) => new Promise((resolveReady, rejectReady) => {
|
||
if (window.google?.maps?.places?.AutocompleteService) {
|
||
resolveReady(true);
|
||
return;
|
||
}
|
||
window.__mapSdkSnapshotReady = () => resolveReady(true);
|
||
const script = document.createElement('script');
|
||
const params = new URLSearchParams({
|
||
key,
|
||
libraries: 'places',
|
||
language: 'zh-CN',
|
||
region: 'CN',
|
||
v: 'weekly',
|
||
loading: 'async',
|
||
callback: '__mapSdkSnapshotReady',
|
||
});
|
||
script.src = `https://maps.googleapis.com/maps/api/js?${params.toString()}`;
|
||
script.async = true;
|
||
script.onerror = () => rejectReady(new Error('Google Maps JS SDK 加载失败'));
|
||
document.head.appendChild(script);
|
||
}), apiKey);
|
||
await page.waitForFunction(
|
||
() => Boolean(window.google?.maps?.places?.AutocompleteService),
|
||
{ timeout: 20000 },
|
||
);
|
||
|
||
await page.evaluate(({ lat, lng, radius, limit }) => {
|
||
const service = new google.maps.places.AutocompleteService();
|
||
const center = new google.maps.LatLng(lat, lng);
|
||
const sleep = (ms) => new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
|
||
const queryMain = (prediction) => prediction.terms?.[0]?.value ?? prediction.description ?? '';
|
||
const querySecondary = (prediction) =>
|
||
(prediction.terms || []).slice(1).map((term) => term.value).join(' ');
|
||
|
||
const queryOne = (input) => new Promise((resolveOne) => {
|
||
service.getQueryPredictions(
|
||
{
|
||
input,
|
||
locationBias: { center, radius },
|
||
},
|
||
(results, status) => {
|
||
if (status !== google.maps.places.PlacesServiceStatus.OK || !results) {
|
||
resolveOne([]);
|
||
return;
|
||
}
|
||
const q = input.trim();
|
||
resolveOne(
|
||
results
|
||
.filter((r) => !r.place_id || queryMain(r) === q)
|
||
.map((r) => ({
|
||
kind: 'query',
|
||
place_id: '',
|
||
description: r.description ?? '',
|
||
main_text: queryMain(r),
|
||
secondary_text: querySecondary(r),
|
||
distance_meters: undefined,
|
||
})),
|
||
);
|
||
},
|
||
);
|
||
});
|
||
|
||
const placeOne = (input) => new Promise((resolveOne) => {
|
||
service.getPlacePredictions(
|
||
{
|
||
input,
|
||
language: 'zh-CN',
|
||
locationBias: { center, radius },
|
||
origin: center,
|
||
},
|
||
(results, status) => {
|
||
if (status !== google.maps.places.PlacesServiceStatus.OK || !results) {
|
||
resolveOne([]);
|
||
return;
|
||
}
|
||
resolveOne(
|
||
results
|
||
.map((r) => ({
|
||
kind: 'place',
|
||
place_id: r.place_id,
|
||
description: r.description ?? '',
|
||
main_text: r.structured_formatting?.main_text ?? r.description ?? '',
|
||
secondary_text: r.structured_formatting?.secondary_text ?? '',
|
||
distance_meters: r.distance_meters ?? undefined,
|
||
}))
|
||
.filter((p) => p.place_id && p.main_text),
|
||
);
|
||
},
|
||
);
|
||
});
|
||
|
||
window.__mapFetchAutocompleteBatch = async (inputs) => {
|
||
const out = {};
|
||
for (let i = 0; i < inputs.length; i += 1) {
|
||
const input = inputs[i];
|
||
const [rawQueryPreds, placePreds] = await Promise.all([queryOne(input), placeOne(input)]);
|
||
const seen = new Set();
|
||
const queryPreds = rawQueryPreds.filter((p) => {
|
||
if (!p.main_text || seen.has(p.main_text)) return false;
|
||
seen.add(p.main_text);
|
||
return true;
|
||
});
|
||
out[input] = [...queryPreds, ...placePreds].slice(0, limit);
|
||
if ((i + 1) % 20 === 0 || i + 1 === inputs.length) {
|
||
console.log(`[JS SDK autocomplete] ${i + 1}/${inputs.length}`);
|
||
}
|
||
await sleep(40);
|
||
}
|
||
return out;
|
||
};
|
||
}, {
|
||
lat: loc.latitude,
|
||
lng: loc.longitude,
|
||
radius: SEARCH_RADIUS,
|
||
limit: AUTOCOMPLETE_LIMIT,
|
||
});
|
||
|
||
return {
|
||
fetchBatch: (inputs) => page.evaluate((items) => window.__mapFetchAutocompleteBatch(items), inputs),
|
||
close: async () => {
|
||
await browser.close();
|
||
await host.close();
|
||
},
|
||
};
|
||
} catch (error) {
|
||
await browser.close().catch(() => {});
|
||
await host.close().catch(() => {});
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
// ─── Routes API ─────────────────────────────────────────────────────────────
|
||
|
||
function parseEndLocation(leg) {
|
||
const el = leg?.endLocation;
|
||
const ll = el?.latLng || el?.location?.latLng;
|
||
if (!ll) return null;
|
||
const lat = ll.latitude ?? ll.lat;
|
||
const lng = ll.longitude ?? ll.lng;
|
||
if (typeof lat !== 'number' || typeof lng !== 'number') return null;
|
||
return { lat, lng };
|
||
}
|
||
|
||
async function computeRouteOneLang(apiKey, oLat, oLng, dLat, dLng, mode, lang) {
|
||
const body = {
|
||
origin: { location: { latLng: { latitude: oLat, longitude: oLng } } },
|
||
destination: { location: { latLng: { latitude: dLat, longitude: dLng } } },
|
||
travelMode: mode,
|
||
computeAlternativeRoutes: false,
|
||
languageCode: lang,
|
||
};
|
||
try {
|
||
const json = await requestJson('https://routes.googleapis.com/directions/v2:computeRoutes', {
|
||
method: 'POST',
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
'X-Goog-Api-Key': apiKey,
|
||
'X-Goog-FieldMask': ROUTES_FIELD_MASK,
|
||
},
|
||
body: JSON.stringify(body),
|
||
});
|
||
if (json.error) return null;
|
||
const route = json.routes?.[0];
|
||
const leg = route?.legs?.[0];
|
||
if (!leg) return null;
|
||
const durationSec = parseFloat(leg.duration?.replace('s', '') || '0');
|
||
const durationText = leg.localizedValues?.duration?.text
|
||
|| `${Math.round(durationSec / 60)} ${lang === 'en' ? 'min' : '分钟'}`;
|
||
const distanceMeters = leg.distanceMeters ?? route?.distanceMeters;
|
||
let distanceText = leg.localizedValues?.distance?.text || '';
|
||
if (!distanceText && distanceMeters != null) {
|
||
const dm = Number(distanceMeters);
|
||
if (lang === 'en') {
|
||
distanceText = dm < 1000 ? `${Math.round(dm)} m` : `${(dm / 1000).toFixed(1)} km`;
|
||
} else {
|
||
distanceText = dm < 1000 ? `${Math.round(dm)} 米` : `${(dm / 1000).toFixed(1)} 公里`;
|
||
}
|
||
}
|
||
const encodedPolyline = route?.polyline?.encodedPolyline || null;
|
||
const endLocation = parseEndLocation(leg);
|
||
const routeLabels = route?.routeLabels || undefined;
|
||
const steps = (leg.steps || []).map(s => ({
|
||
instruction: s.navigationInstruction?.instructions || '',
|
||
distance: s.distanceMeters != null ? `${s.distanceMeters} m` : '',
|
||
distanceMeters: s.distanceMeters ?? 0,
|
||
maneuver: s.navigationInstruction?.maneuver || undefined,
|
||
}));
|
||
return { durationSec, durationText, distanceMeters, distanceText, encodedPolyline, endLocation, routeLabels, steps };
|
||
} catch (e) {
|
||
console.error(` ⚠ computeRoutes(${mode}, ${lang}): ${e.message?.slice(0, 100)}`);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
async function computeRoute(apiKey, oLat, oLng, dLat, dLng, mode) {
|
||
const [zh, en] = await Promise.all([
|
||
computeRouteOneLang(apiKey, oLat, oLng, dLat, dLng, mode, 'zh-CN'),
|
||
computeRouteOneLang(apiKey, oLat, oLng, dLat, dLng, mode, 'en'),
|
||
]);
|
||
if (!zh && !en) return null;
|
||
const primary = zh || en;
|
||
const modeKey = mode === 'WALK' ? 'WALKING' : 'DRIVING';
|
||
return {
|
||
mode: modeKey,
|
||
duration: biText(zh?.durationText, en?.durationText) || primary.durationText,
|
||
distance: biText(zh?.distanceText, en?.distanceText) || primary.distanceText,
|
||
distance_meters: primary.distanceMeters,
|
||
duration_seconds: primary.durationSec,
|
||
encodedPolyline: primary.encodedPolyline,
|
||
endLocation: primary.endLocation,
|
||
routeLabels: primary.routeLabels,
|
||
steps: (primary.steps || []).map((s, i) => {
|
||
const enStep = en?.steps?.[i];
|
||
return {
|
||
instruction: biText(zh?.steps?.[i]?.instruction, enStep?.instruction) || s.instruction,
|
||
distance: biText(zh?.steps?.[i]?.distance, enStep?.distance) || s.distance,
|
||
distanceMeters: s.distanceMeters,
|
||
maneuver: s.maneuver,
|
||
};
|
||
}),
|
||
};
|
||
}
|
||
|
||
// ─── 数据层 ──────────────────────────────────────────────────────────────────
|
||
|
||
function loadSnapshot(loc) {
|
||
const snapshot = {
|
||
location: { lat: loc.latitude, lng: loc.longitude },
|
||
places: {},
|
||
searchIndex: {},
|
||
autocompleteIndex: {},
|
||
routes: {},
|
||
};
|
||
|
||
try {
|
||
if (existsSync(PLACES_PATH)) {
|
||
const pd = JSON.parse(readFileSync(PLACES_PATH, 'utf-8'));
|
||
snapshot.places = pd.places || {};
|
||
snapshot.searchIndex = pd.search_index || {};
|
||
snapshot.autocompleteIndex = pd.autocomplete_index || {};
|
||
}
|
||
} catch (e) {
|
||
console.warn(' ⚠ 读取 places.json 失败，从空开始:', e.message);
|
||
}
|
||
|
||
try {
|
||
if (existsSync(ROUTES_PATH)) {
|
||
const rd = JSON.parse(readFileSync(ROUTES_PATH, 'utf-8'));
|
||
snapshot.routes = rd.routes || {};
|
||
}
|
||
} catch (e) {
|
||
console.warn(' ⚠ 读取 routes.json 失败，从空开始:', e.message);
|
||
}
|
||
|
||
return snapshot;
|
||
}
|
||
|
||
function saveSnapshot(snapshot) {
|
||
mkdirSync(OUT_DIR, { recursive: true });
|
||
const now = new Date().toISOString();
|
||
|
||
const placesData = {
|
||
location: snapshot.location,
|
||
generated_at: now,
|
||
places: snapshot.places,
|
||
search_index: snapshot.searchIndex,
|
||
autocomplete_index: snapshot.autocompleteIndex,
|
||
};
|
||
const routesData = {
|
||
location: snapshot.location,
|
||
generated_at: now,
|
||
routes: snapshot.routes,
|
||
};
|
||
|
||
writeFileSync(PLACES_PATH, JSON.stringify(placesData, null, 2) + '\n', 'utf-8');
|
||
writeFileSync(ROUTES_PATH, JSON.stringify(routesData, null, 2) + '\n', 'utf-8');
|
||
|
||
const pSize = Buffer.byteLength(JSON.stringify(placesData));
|
||
const rSize = Buffer.byteLength(JSON.stringify(routesData));
|
||
console.log(` ✓ places.json (${pSize.toLocaleString()} bytes, ${Object.keys(snapshot.places).length} POI)`);
|
||
console.log(` ✓ routes.json (${rSize.toLocaleString()} bytes, ${Object.keys(snapshot.routes).length} 路线)`);
|
||
}
|
||
|
||
function pruneDistantPlaces(snapshot, loc) {
|
||
const maxM = MAX_POI_DISTANCE_KM * 1000;
|
||
const farIds = [];
|
||
for (const [pid, poi] of Object.entries(snapshot.places)) {
|
||
const dm = poi.distanceMeters ?? haversineDistance(loc.latitude, loc.longitude, poi.lat, poi.lng);
|
||
if (dm > maxM) farIds.push(pid);
|
||
}
|
||
if (!farIds.length) return;
|
||
|
||
console.log(` 清理超远 POI (>${MAX_POI_DISTANCE_KM}km): ${farIds.length} 条`);
|
||
for (const pid of farIds) {
|
||
console.log(` 移除: ${extractText(snapshot.places[pid]?.name) || pid}`);
|
||
delete snapshot.places[pid];
|
||
}
|
||
for (const [key, ids] of Object.entries(snapshot.searchIndex)) {
|
||
const filtered = ids.filter(id => !farIds.includes(id));
|
||
if (filtered.length !== ids.length) snapshot.searchIndex[key] = filtered;
|
||
}
|
||
}
|
||
|
||
// ─── 阶段一：搜索 ───────────────────────────────────────────────────────────
|
||
|
||
async function runSearch(snapshot, queries, apiKey, loc, { full }) {
|
||
const { categoryTypes, placeQueries } = queries;
|
||
const maxM = MAX_POI_DISTANCE_KM * 1000;
|
||
|
||
let catsToSearch, queriesToSearch;
|
||
|
||
if (full) {
|
||
catsToSearch = [...categoryTypes.entries()];
|
||
queriesToSearch = [...placeQueries];
|
||
const newKeys = new Set([...categoryTypes.values(), ...placeQueries]);
|
||
for (const k of Object.keys(snapshot.searchIndex)) {
|
||
if (!newKeys.has(k)) delete snapshot.searchIndex[k];
|
||
}
|
||
console.log(` 全量: ${catsToSearch.length} 个分类, ${queriesToSearch.length} 个地名`);
|
||
} else {
|
||
const existingKeys = new Set(Object.keys(snapshot.searchIndex));
|
||
catsToSearch = [...categoryTypes.entries()].filter(([, kw]) => !existingKeys.has(kw));
|
||
queriesToSearch = placeQueries.filter(q => !existingKeys.has(q));
|
||
console.log(` 增量: ${catsToSearch.length} 个新分类, ${queriesToSearch.length} 个新地名`);
|
||
}
|
||
|
||
if (!catsToSearch.length && !queriesToSearch.length) {
|
||
console.log(' 所有关键词已覆盖，跳过');
|
||
return;
|
||
}
|
||
|
||
let newPoiCount = 0;
|
||
|
||
function addResults(key, results) {
|
||
const ids = [];
|
||
for (const poi of results) {
|
||
if (!poi.placeId) continue;
|
||
if (poi.distanceMeters != null && poi.distanceMeters > maxM) continue;
|
||
if (!snapshot.places[poi.placeId]) {
|
||
snapshot.places[poi.placeId] = poi;
|
||
newPoiCount++;
|
||
}
|
||
ids.push(poi.placeId);
|
||
}
|
||
snapshot.searchIndex[key] = ids;
|
||
}
|
||
|
||
for (const [, keyword] of catsToSearch) {
|
||
console.log(` 搜索分类: "${keyword}"`);
|
||
const results = await searchTextAllPages(apiKey, keyword, null, CATEGORY_PAGE_SIZE, loc.latitude, loc.longitude);
|
||
addResults(keyword, results);
|
||
printResults(`"${keyword}"`, results);
|
||
await sleep(300);
|
||
}
|
||
|
||
for (const query of queriesToSearch) {
|
||
console.log(` 搜索地名: "${query}"`);
|
||
const results = await searchTextAllPages(apiKey, query, null, PLACE_PAGE_SIZE, loc.latitude, loc.longitude);
|
||
addResults(query, results);
|
||
printResults(`"${query}"`, results);
|
||
await sleep(300);
|
||
}
|
||
|
||
console.log(` ✓ 搜索完成，新增 ${newPoiCount} 个 POI，共 ${Object.keys(snapshot.places).length} 个`);
|
||
}
|
||
|
||
// ─── 阶段二：搜索提示 ───────────────────────────────────────────────────────
|
||
|
||
async function runAutocomplete(snapshot, queries, apiKey, loc, { full }) {
|
||
let inputs = queries.autocompleteInputs || [];
|
||
if (!full) {
|
||
inputs = inputs.filter((q) => !snapshot.autocompleteIndex[q]);
|
||
}
|
||
|
||
console.log(` ${full ? '全量' : '增量'}: ${inputs.length} 个完整搜索词`);
|
||
if (!inputs.length) {
|
||
console.log(' 所有搜索提示已覆盖，跳过');
|
||
return;
|
||
}
|
||
|
||
const client = await createJsSdkAutocompleteClient(apiKey, loc);
|
||
try {
|
||
const results = await client.fetchBatch(inputs);
|
||
const nextIndex = full ? {} : snapshot.autocompleteIndex;
|
||
let fixed = 0;
|
||
for (const input of inputs) {
|
||
nextIndex[input] = results[input] || [];
|
||
fixed++;
|
||
}
|
||
if (full) snapshot.autocompleteIndex = nextIndex;
|
||
console.log(`\n ✓ 搜索提示完成 ${fixed}/${inputs.length}，共 ${Object.keys(snapshot.autocompleteIndex).length} 个输入`);
|
||
} finally {
|
||
await client.close();
|
||
}
|
||
}
|
||
|
||
// ─── 阶段三：详情 ───────────────────────────────────────────────────────────
|
||
|
||
async function runDetails(snapshot, apiKey, loc, { full }) {
|
||
/** REST 原始格式 displayName 为 {text: "...", languageCode: "..."}，处理后为纯字符串或 {zh, en} */
|
||
function needsBiTextUpgrade(detail) {
|
||
if (!detail?.displayName) return false;
|
||
const dn = detail.displayName;
|
||
return typeof dn === 'object' && 'text' in dn;
|
||
}
|
||
|
||
let targets;
|
||
const autocompleteMissing = [...collectAutocompletePlaceIds(snapshot)]
|
||
.filter((pid) => !snapshot.places[pid])
|
||
.map((pid) => [pid, null]);
|
||
if (full) {
|
||
targets = [...Object.entries(snapshot.places), ...autocompleteMissing];
|
||
console.log(` 全量: ${Object.keys(snapshot.places).length} 个已有 POI, autocomplete 新增 ${autocompleteMissing.length} 个`);
|
||
} else {
|
||
const missing = Object.entries(snapshot.places)
|
||
.filter(([, p]) => !p.details || Object.keys(p.details).length === 0);
|
||
const needsUpgrade = Object.entries(snapshot.places)
|
||
.filter(([, p]) => p.details && Object.keys(p.details).length > 0 && needsBiTextUpgrade(p.details));
|
||
targets = [...autocompleteMissing, ...missing, ...needsUpgrade];
|
||
console.log(` 增量: autocomplete 新增 ${autocompleteMissing.length} 条, 缺 ${missing.length} 条, 需升级 ${needsUpgrade.length} 条`);
|
||
}
|
||
|
||
if (!targets.length) {
|
||
console.log(' 所有详情已完备，跳过');
|
||
return;
|
||
}
|
||
|
||
let fixed = 0;
|
||
const tasks = targets.map(([pid, row]) => async () => {
|
||
const detail = await withRetry(() => fetchPlaceDetailREST(apiKey, pid), `detail(${pid.slice(0, 12)})`);
|
||
if (detail) {
|
||
const targetRow = row || snapshot.places[pid];
|
||
if (targetRow) {
|
||
targetRow.details = detail;
|
||
if (detail.displayName) targetRow.name = detail.displayName;
|
||
if (detail.formattedAddress) targetRow.formattedAddress = detail.formattedAddress;
|
||
} else {
|
||
const prediction = findAutocompletePrediction(snapshot, pid);
|
||
const newRow = placeRowFromDetail(pid, detail, loc, prediction);
|
||
if (!newRow) {
|
||
console.warn(` ⚠ autocomplete place ${pid.slice(0, 12)}... 缺少 location，跳过`);
|
||
return;
|
||
}
|
||
snapshot.places[pid] = newRow;
|
||
}
|
||
fixed++;
|
||
}
|
||
});
|
||
|
||
console.log(` 需拉取: ${tasks.length}`);
|
||
await runConcurrent(tasks);
|
||
console.log(`\n ✓ 详情完成 ${fixed}/${tasks.length}`);
|
||
}
|
||
|
||
// ─── 阶段四：路线 ───────────────────────────────────────────────────────────
|
||
|
||
async function runRoutes(snapshot, queries, apiKey, loc, { full }) {
|
||
const modes = ['WALK', 'DRIVE'];
|
||
const pending = [];
|
||
|
||
for (const [pid, poi] of Object.entries(snapshot.places)) {
|
||
if (poi.lat == null || poi.lng == null) continue;
|
||
for (const mode of modes) {
|
||
const modeKey = mode === 'WALK' ? 'WALKING' : 'DRIVING';
|
||
const rk = `current>${pid}>${modeKey}`;
|
||
if (!full && snapshot.routes[rk]) continue;
|
||
pending.push({ key: rk, oLat: loc.latitude, oLng: loc.longitude, dLat: poi.lat, dLng: poi.lng, mode });
|
||
}
|
||
}
|
||
|
||
for (const [originName, destName] of queries.routePairs) {
|
||
const oId = snapshot.searchIndex[originName]?.[0];
|
||
const dId = snapshot.searchIndex[destName]?.[0];
|
||
if (!oId || !dId) {
|
||
console.warn(` ⚠ 路线对 "${originName}" → "${destName}" 缺少搜索结果，跳过`);
|
||
continue;
|
||
}
|
||
const o = snapshot.places[oId];
|
||
const d = snapshot.places[dId];
|
||
if (!o || !d) continue;
|
||
for (const mode of modes) {
|
||
const modeKey = mode === 'WALK' ? 'WALKING' : 'DRIVING';
|
||
const rk = `${oId}>${dId}>${modeKey}`;
|
||
if (!full && snapshot.routes[rk]) continue;
|
||
if (pending.some(p => p.key === rk)) continue;
|
||
pending.push({ key: rk, oLat: o.lat, oLng: o.lng, dLat: d.lat, dLng: d.lng, mode });
|
||
}
|
||
}
|
||
|
||
const label = full ? '全量' : '增量';
|
||
console.log(` ${label}: ${pending.length} 条需计算`);
|
||
|
||
if (!pending.length) {
|
||
console.log(' 所有路线已完备，跳过');
|
||
return;
|
||
}
|
||
|
||
let fixed = 0;
|
||
const tasks = pending.map(({ key, oLat, oLng, dLat, dLng, mode }) => async () => {
|
||
const r = await withRetry(() => computeRoute(apiKey, oLat, oLng, dLat, dLng, mode), `route(${key.slice(0, 40)})`);
|
||
if (r) { snapshot.routes[key] = r; fixed++; }
|
||
});
|
||
|
||
await runConcurrent(tasks);
|
||
console.log(`\n ✓ 路线完成 ${fixed}/${pending.length}，共 ${Object.keys(snapshot.routes).length} 条`);
|
||
}
|
||
|
||
// ─── CLI 解析 ────────────────────────────────────────────────────────────────
|
||
|
||
function parseArgs() {
|
||
const argv = process.argv.slice(2);
|
||
const full = new Set();
|
||
const skip = new Set();
|
||
|
||
for (let i = 0; i < argv.length; i++) {
|
||
if (argv[i] === '--full' && argv[i + 1]) {
|
||
for (const s of argv[++i].split(',')) {
|
||
if (s === 'all') { full.add('search'); full.add('autocomplete'); full.add('details'); full.add('routes'); }
|
||
else full.add(s);
|
||
}
|
||
} else if (argv[i] === '--skip' && argv[i + 1]) {
|
||
for (const s of argv[++i].split(',')) skip.add(s);
|
||
}
|
||
// 兼容旧 CLI
|
||
else if (argv[i] === '--patch') { /* noop — 增量已是默认行为 */ }
|
||
else if (argv[i] === '--full-search') { full.add('search'); }
|
||
else if (argv[i] === '--skip-details') { skip.add('details'); }
|
||
else if (argv[i] === '--skip-routes') { skip.add('routes'); }
|
||
}
|
||
|
||
return { full, skip };
|
||
}
|
||
|
||
// ─── 主入口 ──────────────────────────────────────────────────────────────────
|
||
|
||
async function main() {
|
||
console.log('='.repeat(60));
|
||
console.log('Map 地理信息快照生成器');
|
||
console.log('='.repeat(60));
|
||
|
||
const args = parseArgs();
|
||
const apiKey = readApiKey();
|
||
const loc = readSimulatedLocation();
|
||
console.log('\nAPI Key: configured');
|
||
console.log(`当前模拟位置: (${loc.latitude}, ${loc.longitude})`);
|
||
|
||
const stages = ['search', 'autocomplete', 'details', 'routes'];
|
||
const modeDesc = stages.map(s => {
|
||
if (args.skip.has(s)) return `${s}:跳过`;
|
||
if (args.full.has(s)) return `${s}:全量`;
|
||
return `${s}:增量`;
|
||
});
|
||
console.log(`模式: ${modeDesc.join(' | ')}`);
|
||
|
||
console.log('\n[1] 从 tasks.py 提取搜索查询...');
|
||
const queries = extractQueriesFromTasks();
|
||
console.log(` 分类: ${[...queries.categoryTypes.values()].join(', ')}`);
|
||
console.log(` 地名: ${queries.placeQueries.join(', ')}`);
|
||
console.log(` 搜索提示输入: ${queries.autocompleteInputs.length} 个`);
|
||
console.log(` 路线: ${queries.routePairs.map(([o, d]) => `${o}→${d}`).join(', ') || '无'}`);
|
||
|
||
console.log('\n[2] 加载现有快照...');
|
||
const snapshot = loadSnapshot(loc);
|
||
console.log(` 已有 ${Object.keys(snapshot.places).length} POI, ${Object.keys(snapshot.searchIndex).length} 搜索索引, ${Object.keys(snapshot.autocompleteIndex).length} 搜索提示, ${Object.keys(snapshot.routes).length} 路线`);
|
||
pruneDistantPlaces(snapshot, loc);
|
||
|
||
if (!args.skip.has('search')) {
|
||
console.log('\n[3] 搜索...');
|
||
await runSearch(snapshot, queries, apiKey, loc, { full: args.full.has('search') });
|
||
saveSnapshot(snapshot);
|
||
} else {
|
||
console.log('\n[3] 跳过搜索');
|
||
}
|
||
|
||
if (!args.skip.has('autocomplete')) {
|
||
console.log('\n[4] 搜索提示...');
|
||
await runAutocomplete(snapshot, queries, apiKey, loc, { full: args.full.has('autocomplete') });
|
||
saveSnapshot(snapshot);
|
||
} else {
|
||
console.log('\n[4] 跳过搜索提示');
|
||
}
|
||
|
||
if (!args.skip.has('details')) {
|
||
console.log('\n[5] 详情...');
|
||
await runDetails(snapshot, apiKey, loc, { full: args.full.has('details') });
|
||
saveSnapshot(snapshot);
|
||
} else {
|
||
console.log('\n[5] 跳过详情');
|
||
}
|
||
|
||
if (!args.skip.has('routes')) {
|
||
console.log('\n[6] 路线...');
|
||
await runRoutes(snapshot, queries, apiKey, loc, { full: args.full.has('routes') });
|
||
saveSnapshot(snapshot);
|
||
} else {
|
||
console.log('\n[6] 跳过路线');
|
||
}
|
||
|
||
console.log('\n' + '='.repeat(60));
|
||
}
|
||
|
||
main().catch(e => { console.error('致命错误:', e); process.exit(1); });
|