clxx 3.0.1 → 3.0.4

package/build/MapLocationSelection/provider.amap.js

@@ -0,0 +1,659 @@
+"use strict";
+// 高德地图 Provider 实现。
+//
+// 这个文件是从原 index.tsx 直接拆出来的：所有 AMap 相关 API 调用、
+// NEARBY_POI_TYPE、expandWithChildren、normalizePOI、Geolocation 单例化、
+// hasMore 计算（`reachedFullPage && targetPage * pageSize < count`）等
+// 全部内聚在这里，UI 层完全不再 import "AMap*"。
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AMapProvider = void 0;
+const loader_amap_1 = require("./loader.amap");
+const types_1 = require("./types");
+const userMarker_1 = require("./userMarker");
+const DEFAULT_FALLBACK_CENTER_GCJ02 = [116.397428, 39.90923]; // 北京
+// IP 定位判定阈值：accuracy ≥ 此值视为 IP 兜底（城市级精度）。
+// 室内 H5/WiFi 定位精度再差也很少超过 2km，5km 完全是城市级 IP 才有的精度，
+// 与百度端 isIpLikeBmapAccuracy 阈值保持一致。
+const IP_LOCATION_ACCURACY_THRESHOLD_M = 5000;
+// 高德 IP 兜底事后判定。
+//
+// 字段优先级：
+//   1) result.location_type：高德 SDK 内部字段，'ip' / 'cgi' 表示非 GPS。
+//      官方文档未在公开 API 表中列出，但实际运行时存在（v2.0 至今稳定）；
+//   2) accuracy 阈值兜底：location_type 缺省 / 字段名变更时仍能识别。
+function isIpLikeAmapResult(result) {
+    var _a;
+    const t = ((_a = result === null || result === void 0 ? void 0 : result.location_type) !== null && _a !== void 0 ? _a : "").toString().toLowerCase();
+    if (t === "ip" || t === "cgi")
+        return true;
+    const acc = Number(result === null || result === void 0 ? void 0 : result.accuracy);
+    return Number.isFinite(acc) && acc >= IP_LOCATION_ACCURACY_THRESHOLD_M;
+}
+// 高德 PlaceSearch 在 keyword 为空时，必须依靠 type 才会返回附近 POI。
+// 这里把所有大类编码全部打开，确保「楼栋 / 门牌地址 / 室内设施 / 公共厕所
+// 等」全部召回，否则附近列表会只到“小区”这一级，丢掉具体的楼栋 / 加油站
+// 厕所 / 商场内店铺等子粒度 POI。
+//
+// 高德官方 24 个一级大类对照（**全部打开**，配合 extensions=all + child_pois
+// 可达"楼栋/楼层/出入口/公厕"等子 POI 极细粒度）：
+//   010000 汽车服务（加油站、充电站）   020000 汽车销售
+//   030000 汽车维修                    040000 摩托车服务
+//   050000 餐饮服务                    060000 购物服务
+//   070000 生活服务                    080000 体育休闲
+//   090000 医疗保健                    100000 住宿服务（酒店）
+//   110000 风景名胜                    120000 商务住宅（小区/楼栋）
+//   130000 政府机构                    140000 科教文化
+//   150000 交通设施（地铁站/出入口）    160000 金融保险
+//   170000 公司企业（写字楼）           180000 道路附属设施
+//   190000 地名地址（门牌/村庄）        200000 公共设施（公厕/邮筒/报刊亭）
+//   220000 室内设施（楼层/出入口/电梯） 970000 通行设施
+//   990000 事件活动
+const NEARBY_POI_TYPE = [
+    "010000",
+    "020000",
+    "030000",
+    "040000",
+    "050000",
+    "060000",
+    "070000",
+    "080000",
+    "090000",
+    "100000",
+    "110000",
+    "120000",
+    "130000",
+    "140000",
+    "150000",
+    "160000",
+    "170000",
+    "180000",
+    "190000",
+    "200000",
+    "220000",
+    "970000",
+    "990000",
+].join("|");
+// 把父 POI 与其 child_pois 展开成一个扁平数组（父在前，子按原顺序紧随其后）。
+// 子 POI 通常缺少 distance / cityname，这里基于父 POI 兜底，让排序与展示一致。
+function expandWithChildren(pois) {
+    var _a, _b, _c;
+    const out = [];
+    for (const p of pois) {
+        if (!p)
+            continue;
+        out.push(p);
+        const children = Array.isArray(p.child_pois) ? p.child_pois : [];
+        for (const c of children) {
+            if (!c || !c.location)
+                continue;
+            out.push(Object.assign(Object.assign({}, c), { cityname: (_a = c.cityname) !== null && _a !== void 0 ? _a : p.cityname, pname: (_b = c.pname) !== null && _b !== void 0 ? _b : p.pname, adname: (_c = c.adname) !== null && _c !== void 0 ? _c : p.adname, distance: typeof c.distance === "number"
+                    ? c.distance
+                    : typeof p.distance === "number"
+                        ? p.distance
+                        : undefined, 
+                // 子 POI 的 address 经常为空，回退到父 POI 名称作为上下文
+                address: c.address || p.name || p.address || "" }));
+        }
+    }
+    return out;
+}
+function normalizePOI(poi) {
+    var _a, _b, _c, _d;
+    if (!poi || !poi.location)
+        return null;
+    const lng = typeof poi.location.getLng === "function"
+        ? poi.location.getLng()
+        : poi.location.lng;
+    const lat = typeof poi.location.getLat === "function"
+        ? poi.location.getLat()
+        : poi.location.lat;
+    if (typeof lng !== "number" || typeof lat !== "number")
+        return null;
+    return {
+        id: (_a = poi.id) !== null && _a !== void 0 ? _a : `${lng},${lat},${(_b = poi.name) !== null && _b !== void 0 ? _b : ""}`,
+        name: (_c = poi.name) !== null && _c !== void 0 ? _c : "",
+        address: (_d = poi.address) !== null && _d !== void 0 ? _d : "",
+        location: { lng, lat },
+        cityname: poi.cityname,
+        pname: poi.pname,
+        adname: poi.adname,
+        distance: typeof poi.distance === "number" ? poi.distance : undefined,
+        raw: poi,
+    };
+}
+class AMapProvider {
+    constructor(opts) {
+        this.AMap = null;
+        this.map = null;
+        // 周边检索专用：init 时设 type=NEARBY_POI_TYPE 让"附近列表"覆盖楼宇/门牌等大类，
+        // extensions=all 才返回 child_pois（楼栋粒度）。
+        this.placeSearch = null;
+        // 关键字检索：双实例并发，覆盖两类用户意图，二者结果合并去重 + 50km 半径过滤
+        // 后回给 UI 层（UI 再用「名称命中度优先 + 同档距离升序」做最终排序）。
+        //
+        // 单实例（仅 searchNearBy）的痛点：
+        //   * searchNearBy 是「半径内 + 关键字宽松匹配 + 按距离排」。高德 SDK 内部对
+        //     "虹桥火车站"拆 token，"虹桥"、"火车站"任一片段命中即收录——浦东虹桥花园
+        //     里的充电站等近距离模糊命中会把 pageSize=20 的首页全部占满，**真实
+        //     虹桥火车站（28km 外）根本进不了候选**，用户感觉"列表里完全没有想搜的"；
+        //   * 单纯 ps.search(kw) 又会被"锦博苑"等非热门小区在全国相关性排序里挤掉
+        //     （北京同名 POI 热度更高时会跑到前面），且 search 不限半径会拿到外地结果。
+        //
+        // 双实例并发（实测能解 99% 的"搜不到真实 POI"问题）：
+        //   * keywordPlaceSearchNear（searchNearBy）拿"近距离命中"——锦博苑/楼宇/
+        //     近距离模糊匹配等都从这里来；
+        //   * keywordPlaceSearchFull（search）拿"全国相关性命中"——虹桥火车站/陆家
+        //     嘴等高热精确匹配 POI 即便远在 28km 外也能稳定进入候选；
+        //   * 二者各取 pageSize=50（SDK 上限）、extensions=all、不设 type 让 keyword
+        //     当主过滤；不设 cityLimit（city="全国"）不加城市约束；
+        //   * 合并后用 haversine 重算距离并丢弃 > 50km 的跨市残留（search 会带回北京
+        //     /广州的同名 POI，距离过滤天然解决）；
+        //   * 名称命中度优先排序由 UI 层 sortByKeywordRelevance 完成（与百度共用），
+        //     这里只负责"把候选凑齐"。
+        //
+        // 与单实例相比的代价：每次关键字检索多打一次 SDK 调用（约 +200~500ms 网络），
+        // 已被 UI 层 250ms debounce 削平至单次输入只触发一组并发请求；调用配额翻倍
+        // 但 keyword 检索本身在打车流程中频次很低，整体配额压力可忽略。
+        this.keywordPlaceSearchNear = null;
+        this.keywordPlaceSearchFull = null;
+        this.geocoder = null;
+        this.geolocation = null;
+        this.userMarker = null;
+        // 复用一次进行中的定位 Promise，去抖
+        this.pendingGeolocate = null;
+        // 周边搜索 / 关键字搜索 各自独立的 seq，过期请求直接丢弃
+        this.aroundSeq = 0;
+        this.keywordSeq = 0;
+        // ===== 跨城 flyTo 状态（v2 新增）=====
+        // 高德 JSAPI 没有原生 flyTo（百度有 map.flyTo），setZoomAndCenter 默认只是
+        // "直线平移 + 同步缩放"，跨城（如上海点北京天安门，距离 1000+ km）时，途中
+        // 以高 zoom 沿途经过大量瓦片，瓦片下载量爆炸 + 地图长时间空白。
+        // 这里手动模拟 Mapbox flyTo 风格的"先缩小 → 平移 → 再放大"三段式动画，
+        // 让中间段在低 zoom（5-8 级）下平移，瓦片密度极低，请求量与空白时间都收敛。
+        // flying = true 期间 SDK 触发的 movestart / moveend 都被 on() wrapper 屏蔽——
+        // 让上层 programmaticMoveRef 单次 flag 设计无需感知内部多段动画细节。
+        this.flying = false;
+        this.flyToTimers = [];
+        this.opts = opts;
+    }
+    // 加载 SDK + 创建所有 service 类（Geocoder / PlaceSearch ×3 / Geolocation
+    // 单例延迟到 geolocate 内部按需创建）。
+    // init() 在本方法之后创建 Map；initHeadless() 到此为止（getLocation 用）。
+    // 抽出来共用是因为两条路径下 service 类的构造完全相同。
+    initServices(initialCity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const AMap = yield (0, loader_amap_1.loadAMap)({
+                key: this.opts.amapKey,
+                securityJsCode: this.opts.securityJsCode,
+                plugins: ["AMap.Geocoder", "AMap.PlaceSearch", "AMap.Geolocation"],
+            });
+            this.AMap = AMap;
+            const city = initialCity !== null && initialCity !== void 0 ? initialCity : "全国";
+            this.placeSearch = new AMap.PlaceSearch({
+                pageSize: 20,
+                pageIndex: 1,
+                // extensions=all 才会返回 child_pois（楼栋等子 POI），
+                // 否则即便 type 命中"商务住宅"也只到小区粒度。
+                extensions: "all",
+                type: NEARBY_POI_TYPE,
+                city,
+            });
+            // 关键字检索双实例：分别给 searchNearBy / search 用，避免共享实例时 setPageSize
+            // 等状态被并发调用相互覆盖。pageSize 拉满到 50（SDK 上限）尽量多召回候选，
+            // 让 UI 端的"名称命中度优先排序"有更多素材可挑。
+            this.keywordPlaceSearchNear = new AMap.PlaceSearch({
+                pageSize: 50,
+                pageIndex: 1,
+                extensions: "all",
+                city,
+            });
+            this.keywordPlaceSearchFull = new AMap.PlaceSearch({
+                pageSize: 50,
+                pageIndex: 1,
+                extensions: "all",
+                city,
+            });
+            // extensions=all 是关键：让 regeocode 一并返回 pois 数组（带 distance 字段）。
+            // 默认值在不同 JSAPI 版本下会变（v1 默认 base / v2 默认 all），显式声明
+            // 避免被 SDK 默认值变化打脸——reverseGeocode 内部需要 pois[].distance
+            // 才能挑出"30m 内最贴近 centerPin 的精确 POI"。
+            this.geocoder = new AMap.Geocoder({ extensions: "all" });
+            return AMap;
+        });
+    }
+    init(o) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const AMap = yield this.initServices(o.initialCity);
+            const center = (_a = o.initialCenter) !== null && _a !== void 0 ? _a : DEFAULT_FALLBACK_CENTER_GCJ02;
+            const zoom = (_b = o.initialZoom) !== null && _b !== void 0 ? _b : 16;
+            this.map = new AMap.Map(o.container, {
+                viewMode: "2D",
+                zoom,
+                center,
+                showLabel: true,
+            });
+        });
+    }
+    // headless：仅 service 类，不创建 Map 实例 → 不挂容器 / 不下载瓦片 /
+    // 不渲染。详见 MapProvider.initHeadless 接口注释。
+    initHeadless(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initServices(opts === null || opts === void 0 ? void 0 : opts.initialCity);
+        });
+    }
+    destroy() {
+        // 先清 flyTo 的 setTimeout，避免段 2 / 段 3 在地图已销毁后仍尝试调用
+        // this.map.setCenter / setZoom 抛 NPE。
+        this.flyToTimers.forEach((id) => window.clearTimeout(id));
+        this.flyToTimers = [];
+        this.flying = false;
+        try {
+            if (this.map)
+                this.map.destroy();
+        }
+        catch (_a) {
+            // ignore
+        }
+        this.AMap = null;
+        this.map = null;
+        this.placeSearch = null;
+        this.keywordPlaceSearchNear = null;
+        this.keywordPlaceSearchFull = null;
+        this.geocoder = null;
+        this.geolocation = null;
+        this.userMarker = null;
+        this.pendingGeolocate = null;
+    }
+    getCenter() {
+        const c = this.map.getCenter();
+        return [c.getLng(), c.getLat()];
+    }
+    // 短距离：保持原 setZoomAndCenter / setCenter 行为（一段直线平移）。
+    // 跨城（>= 50km）：走 flyTo 三段式动画——先缩小到能一屏看到起终点的 zoom、
+    // 在低 zoom 下平移、再放大到目标 zoom。可大幅降低瓦片请求量与地图空白时间，
+    // 体感与百度 BMapGL.Map.flyTo / 微信"发送位置"跨城跳转一致。
+    setCenter(center, zoom) {
+        if (!this.map)
+            return;
+        const c = this.map.getCenter();
+        const distanceM = (0, types_1.haversineMeters)(c.getLng(), c.getLat(), center[0], center[1]);
+        // 50km 阈值兼顾"市内跨区"与"跨城"：
+        //   * 市内拖图 / 列表点选附近 POI 距离普遍 < 30km，不应触发"先缩小再放大"
+        //     的鸟瞰动画（反而显得卡顿绕路）；
+        //   * 50km 以上基本是"省内跨市"或"跨省"，瓦片直线穿越的成本足够高，三段式
+        //     动画的体感收益开始回正。
+        const SHORT_RANGE_M = 50000;
+        if (distanceM < SHORT_RANGE_M) {
+            if (typeof zoom === "number") {
+                this.map.setZoomAndCenter(zoom, [center[0], center[1]]);
+            }
+            else {
+                this.map.setCenter([center[0], center[1]]);
+            }
+            return;
+        }
+        // zoom 缺省时取当前 zoom 作为目标——保持调用方"不传 zoom = 不改 zoom"的语义。
+        const targetZoom = typeof zoom === "number" ? zoom : this.map.getZoom();
+        this.flyTo([center[0], center[1]], targetZoom, distanceM);
+    }
+    // 三段式 flyTo（手动模拟，因为高德 JSAPI 2.0 没有原生 flyTo 接口）。
+    //
+    // 时序（总耗时 ≈ 990ms，与百度 flyTo 体感对齐）：
+    //   t=0     setZoomAndCenter(midZoom, current, 250)  // 段 1：原地缩小
+    //   t=270   setCenter(target, 350)                   // 段 2：低 zoom 平移
+    //   t=640   flying=false → setZoom(targetZoom, 350)  // 段 3：放大到目标
+    //   t=990   段 3 动画结束 → 真实 moveend 上抛 → 上层正常 commit + drop pin
+    //
+    // midZoom 选择策略：距离越远越缩小，让平移阶段瓦片密度尽可能低。
+    //   1000km+  → zoom 5（全国一屏）
+    //   500-1000 → zoom 6
+    //   200-500  → zoom 7
+    //   50-200   → zoom 8（省内跨市）
+    //
+    // 段 1 / 段 2 触发的 SDK moveend 被 on() wrapper 按 this.flying 屏蔽；段 3
+    // 启动前清掉 flying，让段 3 自然产生的 moveend 正常上抛——上层
+    // programmaticMoveRef 设计是"单次消费"，只期待一次 moveend。
+    //
+    // 取消语义：连续 setCenter 时新调用先清掉旧的 flyToTimers，由新一轮 flyTo
+    // 接管——避免多次连续点击跨城 POI 时段动画堆叠到错乱位置。
+    flyTo(target, targetZoom, distanceM) {
+        if (!this.map)
+            return;
+        this.flyToTimers.forEach((id) => window.clearTimeout(id));
+        this.flyToTimers = [];
+        let midZoom = 8;
+        if (distanceM >= 1000000)
+            midZoom = 5;
+        else if (distanceM >= 500000)
+            midZoom = 6;
+        else if (distanceM >= 200000)
+            midZoom = 7;
+        const c = this.map.getCenter();
+        const currentLng = c.getLng();
+        const currentLat = c.getLat();
+        this.flying = true;
+        this.map.setZoomAndCenter(midZoom, [currentLng, currentLat], false, 250);
+        this.flyToTimers.push(window.setTimeout(() => {
+            if (!this.map)
+                return;
+            this.map.setCenter([target[0], target[1]], false, 350);
+        }, 270));
+        this.flyToTimers.push(window.setTimeout(() => {
+            if (!this.map)
+                return;
+            // 段 3 启动前先解屏：本段自然结束触发的 moveend 会到达上层。
+            this.flying = false;
+            this.map.setZoom(targetZoom, false, 350);
+        }, 640));
+    }
+    upsertUserMarker(center) {
+        const AMap = this.AMap;
+        if (!AMap || !this.map)
+            return;
+        if (!this.userMarker) {
+            const content = (0, userMarker_1.createUserMarkerDom)();
+            this.userMarker = new AMap.Marker({
+                position: [center[0], center[1]],
+                content,
+                // content 是 0x0 的锚点 wrap（详见 userMarker.ts）：默认 top-left 对齐时
+                // wrap 左上角就是 position；内部真实可见 marker 已用 absolute -6/-6 自我居中。
+                // 所以这里 offset 必须是 (0, 0)，再叠加 -6 反而会双重偏移把蓝点拉到 position 左上方。
+                offset: new AMap.Pixel(0, 0),
+                zIndex: 90,
+                clickable: false,
+                bubble: true,
+            });
+            this.userMarker.setMap(this.map);
+        }
+        else {
+            this.userMarker.setPosition([center[0], center[1]]);
+        }
+    }
+    searchAround(center, options) {
+        var _a;
+        const AMap = this.AMap;
+        const ps = this.placeSearch;
+        if (!AMap || !ps) {
+            return Promise.resolve({ pois: [], hasMore: false });
+        }
+        const page = Math.max(1, (_a = options.page) !== null && _a !== void 0 ? _a : 1);
+        const pageSize = options.pageSize;
+        const seq = ++this.aroundSeq;
+        return new Promise((resolve) => {
+            ps.setPageIndex(page);
+            ps.setPageSize(pageSize);
+            // 高德 searchNearBy 文档明确 radius 取值 [0, 50000]：业务方传超过 50000
+            // 会触发 SDK 报错（status='error'），这里先 clamp 兜住。
+            const radius = Math.min(Math.max(0, options.radius), 50000);
+            ps.searchNearBy("", new AMap.LngLat(center[0], center[1]), radius, (status, result) => {
+                var _a, _b, _c, _d;
+                if (seq !== this.aroundSeq) {
+                    // 请求已被作废
+                    resolve({ pois: [], hasMore: false });
+                    return;
+                }
+                const rawPois = (_b = (_a = result === null || result === void 0 ? void 0 : result.poiList) === null || _a === void 0 ? void 0 : _a.pois) !== null && _b !== void 0 ? _b : [];
+                const pois = expandWithChildren(rawPois)
+                    .map(normalizePOI)
+                    .filter((x) => !!x);
+                // 高德 PlaceSearch 返回的 count 只统计父 POI，而 list 是展开 child_pois 后的扁平数组，
+                // 当区域内 child_pois 多时 list.length 会远大于 count，用 list.length < count 判断
+                // 「是否还有下一页」会永远 false，分页完全失效。
+                // 这里用「本次接口返回的原始 pois 是否取满一页」作为判断依据：
+                //   - 满一页（rawPois.length >= pageSize）→ 大概率还有下一页
+                //   - 不满一页 → 已是最后一页（高德接口约定）
+                // 同时叠加 totalCount 兜底（page * pageSize < count），避免接口偶尔返回多余数据。
+                const totalCount = (_d = (_c = result === null || result === void 0 ? void 0 : result.poiList) === null || _c === void 0 ? void 0 : _c.count) !== null && _d !== void 0 ? _d : (status === "complete" ? rawPois.length : 0);
+                const reachedFullPage = rawPois.length >= pageSize;
+                const hasMoreByCount = page * pageSize < totalCount;
+                const hasMore = reachedFullPage && hasMoreByCount;
+                if (status !== "complete" || pois.length === 0) {
+                    // 诊断：status='error' 大多是安全密钥未配置或服务报错
+                    if (status === "error") {
+                        console.warn("[MapLocationSelection] AMap PlaceSearch 失败。常见原因：" +
+                            "未配置 securityJsCode（JSAPI v2.0 必填） / Key 未开通服务 / 超出限额。info=", result === null || result === void 0 ? void 0 : result.info);
+                    }
+                    resolve({ pois: [], hasMore: false });
+                    return;
+                }
+                resolve({ pois, hasMore });
+            });
+        });
+    }
+    searchByKeyword(center, keyword, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 关键字检索 = 「searchNearBy（近距离命中）」+「search（全国相关性命中）」并发，
+            // 合并去重后**全部**返回，**不做距离过滤**。
+            //
+            // 旧版本曾在末尾做 50km 半径过滤以剔除同名跨市 POI（"北京/广州的锦博苑"）。
+            // 但实测这条过滤会误杀用户实际想找的远端地标——例如在上海搜"天安门"，全国
+            // 唯一的精确命中就是 1075km 外的北京天安门，被 50km 切掉后整个列表为空，
+            // 与微信"发送位置"的体感（远端命中显示 1074.5km）严重不符。
+            //
+            // 排序口径：本方法只负责把候选凑齐，**不在这里排序**——UI 层
+            // sortByKeywordRelevance 用「名称包含完整关键字优先 + 同档距离升序」做最终排序，
+            // 同城精确命中（"上海锦博苑"）凭距离稳居顶部，同名跨市命中（北京/广州）
+            // 自然沉到列表末尾；而对于唯一远端命中（"天安门" → 北京），它顶到首位
+            // 是用户期望的行为。距离过滤反而是误杀。
+            const AMap = this.AMap;
+            const psNear = this.keywordPlaceSearchNear;
+            const psFull = this.keywordPlaceSearchFull;
+            if (!AMap || !psNear || !psFull)
+                return [];
+            const seq = ++this.keywordSeq;
+            const pageSize = Math.min(50, Math.max(20, options.pageSize));
+            const runNear = () => new Promise((resolve) => {
+                psNear.setPageIndex(1);
+                psNear.setPageSize(pageSize);
+                psNear.searchNearBy(keyword, new AMap.LngLat(center[0], center[1]), 50000, (status, result) => {
+                    var _a;
+                    if (status !== "complete" || !((_a = result === null || result === void 0 ? void 0 : result.poiList) === null || _a === void 0 ? void 0 : _a.pois)) {
+                        resolve([]);
+                        return;
+                    }
+                    const list = expandWithChildren(result.poiList.pois)
+                        .map(normalizePOI)
+                        .filter((x) => !!x);
+                    resolve(list);
+                });
+            });
+            const runFull = () => new Promise((resolve) => {
+                psFull.setPageIndex(1);
+                psFull.setPageSize(pageSize);
+                // search(kw) 不限半径、不限城市：高热 POI（虹桥火车站 / 陆家嘴 / 东方明珠
+                // 等）会稳定排在 search 结果首页，**远端唯一精确命中也会被召回**——
+                // 例如在上海搜"天安门"，能拿到 1075km 外的北京天安门，跟微信"发送
+                // 位置"的体感一致。与 runNear 合并去重后**全部**返回，不在 provider
+                // 层做距离过滤；UI 层 sortByKeywordRelevance 会按"名称命中度分级 +
+                // 同档距离升序"排序，跨城远端命中自然排在同城精确命中之后。
+                psFull.search(keyword, (status, result) => {
+                    var _a;
+                    if (status !== "complete" || !((_a = result === null || result === void 0 ? void 0 : result.poiList) === null || _a === void 0 ? void 0 : _a.pois)) {
+                        resolve([]);
+                        return;
+                    }
+                    const list = expandWithChildren(result.poiList.pois)
+                        .map(normalizePOI)
+                        .filter((x) => !!x);
+                    resolve(list);
+                });
+            });
+            const [nearby, fulltext] = yield Promise.all([runNear(), runFull()]);
+            if (seq !== this.keywordSeq)
+                return [];
+            // 合并去重：以 nearby 优先（更可能带 SDK 算好的 distance），fulltext 仅补
+            // nearby 漏掉的远端高热精确命中。同 id 用 nearby 的版本，避免 search 不带
+            // distance 的副本覆盖 nearby 已经拿到的距离信息。
+            const seen = new Map();
+            for (const p of nearby)
+                seen.set(p.id, p);
+            for (const p of fulltext) {
+                if (!seen.has(p.id))
+                    seen.set(p.id, p);
+            }
+            return Array.from(seen.values());
+        });
+    }
+    // 定位：AMap.Geolocation.getCurrentPosition（官方推荐方式）。
+    //
+    // ⚠️ IP 兜底事后判定（与 noIpLocate 取舍）：
+    //   高德 v1.4 提供过 `noIpLocate` 构造参数，但 v2 下已不再可靠（部分版本静默
+    //   忽略），且业务层希望"是否允许 IP 兜底"做成**调用时**的开关而非"实例级"
+    //   配置（同一个 provider 实例下不同调用可以选择不同策略）。所以这里**不再
+    //   传 noIpLocate**，统一走"拿到 result 后看 location_type / accuracy 事后判定"
+    //   的路径——既兼容所有 SDK 版本，也支持调用时灵活切换。
+    //
+    // 判定规则（详见 isIpLikeAmapResult）：
+    //   * result.location_type === 'ip' / 'cgi' → 视为 IP 定位
+    //   * accuracy ≥ 5000m → 兜底视为 IP（5km 阈值远超室内 H5 误差上限）
+    geolocate(options) {
+        const AMap = this.AMap;
+        if (!AMap)
+            return Promise.resolve(null);
+        // in-flight 复用：避免连续点击触发多次 GPS 弹权限框。同一 provider 实例
+        // 上不会出现"a 调用 allowIpFallback=true、b 调用 allowIpFallback=false"
+        // 的并发——业务方一次决策，全程一致——所以此处不区分 options 复用即可。
+        if (this.pendingGeolocate)
+            return this.pendingGeolocate;
+        if (!this.geolocation) {
+            this.geolocation = new AMap.Geolocation({
+                enableHighAccuracy: true,
+                timeout: 10000,
+                // convert: true 让 SDK 把原始 WGS84 转成 GCJ02，与 provider 坐标系自洽。
+                convert: true,
+                // 关闭高德自带 UI，由组件接管
+                showButton: false,
+                showMarker: false,
+                showCircle: false,
+                panToLocation: false,
+                zoomToAccuracy: false,
+            });
+        }
+        const allowIp = (options === null || options === void 0 ? void 0 : options.allowIpFallback) === true;
+        const promise = new Promise((resolve) => {
+            this.geolocation.getCurrentPosition((status, result) => {
+                if (status !== "complete" || !(result === null || result === void 0 ? void 0 : result.position)) {
+                    console.warn("[MapLocationSelection] AMap Geolocation 失败，请确认 https/localhost 环境与授权。status=", status, "result=", result);
+                    resolve(null);
+                    return;
+                }
+                if (!allowIp && isIpLikeAmapResult(result)) {
+                    console.warn("[MapLocationSelection] AMap Geolocation 命中 IP 兜底（location_type=", result.location_type, "accuracy=", result.accuracy, "）但 allowIpFallback=false，已丢弃返回 null。");
+                    resolve(null);
+                    return;
+                }
+                resolve([result.position.getLng(), result.position.getLat()]);
+            });
+        }).finally(() => {
+            this.pendingGeolocate = null;
+        });
+        this.pendingGeolocate = promise;
+        return promise;
+    }
+    reverseGeocode(center) {
+        const geocoder = this.geocoder;
+        if (!geocoder)
+            return Promise.resolve(null);
+        return new Promise((resolve) => {
+            geocoder.getAddress([center[0], center[1]], (status, result) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+                if (status === "complete" && (result === null || result === void 0 ? void 0 : result.regeocode)) {
+                    const r = result.regeocode;
+                    const city = ((_a = r.addressComponent) === null || _a === void 0 ? void 0 : _a.city) || ((_b = r.addressComponent) === null || _b === void 0 ? void 0 : _b.province) || "";
+                    // reverseGeocode 只负责"地名兜底"——返回覆盖中心点的具体地名
+                    // （楼宇 / 街道+门牌 / 街道 / 镇）。**不掺 POI**，POI 借用由
+                    // commitMapCenter 用 fetchAround（PlaceSearch.searchNearBy 全大类）
+                    // 的结果统一处理，因为 regeo.pois 是按"重要性"筛过的 N 条，常
+                    // 漏掉酒店/楼宇等具体 POI（实测："全季酒店"在地图上明显贴 centerPin
+                    // 但 regeo.pois 里根本没有，导致 fallback 到 township="北蔡镇"）。
+                    //
+                    // 文档参考：
+                    //   https://lbs.amap.com/api/webservice/guide/api/georegeo
+                    //
+                    // name 候选优先级（精到粗）：
+                    //   楼宇.name（extensions=all 才有）→ 街道+门牌 → 街道 → 街道乡镇 → 商圈
+                    // address 候选：
+                    //   街道+门牌 → 街道 → formattedAddress
+                    const ac = (_c = r.addressComponent) !== null && _c !== void 0 ? _c : {};
+                    const businessAreas = Array.isArray(ac.businessAreas)
+                        ? ac.businessAreas
+                        : [];
+                    const sn = (_d = ac.streetNumber) !== null && _d !== void 0 ? _d : {};
+                    const street = ((_e = sn.street) !== null && _e !== void 0 ? _e : "").toString().trim();
+                    const number = ((_f = sn.number) !== null && _f !== void 0 ? _f : "").toString().trim();
+                    const streetAndNumber = street && number ? `${street}${number}` : "";
+                    const township = ((_g = ac.township) !== null && _g !== void 0 ? _g : "").toString().trim();
+                    const formatted = ((_h = r.formattedAddress) !== null && _h !== void 0 ? _h : "").toString().trim();
+                    const nameCandidates = [
+                        (_j = ac.building) === null || _j === void 0 ? void 0 : _j.name,
+                        streetAndNumber,
+                        street,
+                        township,
+                        (_k = businessAreas[0]) === null || _k === void 0 ? void 0 : _k.name,
+                    ];
+                    const name = (_l = nameCandidates
+                        .map((s) => (s !== null && s !== void 0 ? s : "").toString().trim())
+                        .find(Boolean)) !== null && _l !== void 0 ? _l : "";
+                    const addressCandidates = [
+                        streetAndNumber,
+                        street,
+                        township,
+                        formatted,
+                    ];
+                    const addressRaw = (_m = addressCandidates.find(Boolean)) !== null && _m !== void 0 ? _m : "";
+                    // name / address 落到同一候选时会完全重复，让 address 留空（描述行
+                    // 只显示距离），跟周边 POI 项 "address 为空" 的渲染分支保持一致。
+                    const address = addressRaw === name ? "" : addressRaw;
+                    // 高德 r.addressComponent.adcode 是 6 位国标区县码（如 310115），
+                    // 与 GB/T 2260 完全对齐。直辖市 / 不设区地级市的 corner case 由
+                    // UI 层 splitAdcode 处理（参考 SelectedLocation.provinceCode 注释）。
+                    const adcodeRaw = ((_o = ac.adcode) !== null && _o !== void 0 ? _o : "").toString().trim();
+                    const adcode = /^\d{6}$/.test(adcodeRaw) ? adcodeRaw : undefined;
+                    resolve({
+                        name,
+                        address,
+                        province: (_p = r.addressComponent) === null || _p === void 0 ? void 0 : _p.province,
+                        city: city || undefined,
+                        district: (_q = r.addressComponent) === null || _q === void 0 ? void 0 : _q.district,
+                        adcode,
+                    });
+                }
+                else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+    on(event, handler) {
+        if (!this.map)
+            return;
+        if (event === "click") {
+            this.map.on("click", (e) => {
+                const lng = e.lnglat.getLng();
+                const lat = e.lnglat.getLat();
+                handler(lng, lat);
+            });
+        }
+        else if (event === "movestart" || event === "moveend") {
+            // flying = true 期间（段 1 / 段 2 进行中）SDK 触发的 movestart / moveend
+            // 都被吞掉——上层 programmaticMoveRef 是单次消费设计，只期望一次 moveend。
+            // 段 3 启动前 flying 已被清为 false，段 3 的 movestart / moveend 正常上抛。
+            this.map.on(event, () => {
+                if (this.flying)
+                    return;
+                handler();
+            });
+        }
+    }
+}
+exports.AMapProvider = AMapProvider;