@heycar/heycars-map 2.0.0-switchMap3 → 2.0.0-switchMap5

package/dist/v2/hooks/useMapLoader.js

@@ -1,8 +1,8 @@
-import { shallowRef, computed, ref } from "vue-demi";
+import { shallowRef, computed } from "vue-demi";
+import { apiPingAmap, apiPingGmap } from "../api/pingConnection.js";
 import { watchPostEffectForDeepOption } from "../utils/compare.js";
-import { createRunOnce } from "../utils/helper.js";
+import { createOneConcurrent, sleep, createRunOnce } from "../utils/helper.js";
 import { patchGoogleMapLoader } from "../utils/patchGoogleMapLoader.js";
-import { t as throttle } from "../chunks/throttle.8bdd8d3b.js";
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 var distExports = {};
 var dist = {
@@ -540,7 +540,6 @@ class Loader {
   }
 }
 const MIN_MAP_RELOAD_INTERVAL = 5e3;
-const GMAP_LOAD_TIMEOUT = 1e4;
 const DEFAULT_AMAP_PLUGINS = [
   "AMap.Geocoder",
   "AMap.Driving",
@@ -550,7 +549,6 @@ const DEFAULT_AMAP_PLUGINS = [
 const DEFAULT_GMAP_LIBRARIES = ["marker", "geometry"];
 var Status = /* @__PURE__ */ ((Status2) => {
   Status2["LOADING"] = "LOADING";
-  Status2["TIMEOUT"] = "TIMEOUT";
   Status2["FAILURE"] = "FAILURE";
   Status2["SUCCESS"] = "SUCCESS";
   return Status2;
@@ -558,15 +556,14 @@ var Status = /* @__PURE__ */ ((Status2) => {
 const useAmapLoader = (props) => {
   const { disableRef, onSuccess, onFail } = props;
   let resolveLoader;
-  let rejectLoader;
-  const readyPromise = new Promise((resolve, reject) => {
+  const readyPromise = new Promise((resolve) => {
     resolveLoader = resolve;
-    rejectLoader = reject;
   });
   const statusRef = shallowRef(
     "LOADING"
     /* LOADING */
   );
+  const pingStatusRef = shallowRef("connected");
   const optionsRef = computed(() => {
     const {
       onSuccess: onSuccess2,
@@ -586,102 +583,123 @@ const useAmapLoader = (props) => {
       serviceHost: props.apiServiceHost
     } : { securityJsCode: props.apiSecret };
   });
-  const reload = throttle(
-    (options) => {
-      if (statusRef.value === "SUCCESS")
-        return;
-      statusRef.value = "LOADING";
-      defineSecurityOnce();
-      return distExports.load(options).then(
-        () => {
-          statusRef.value = "SUCCESS";
-          resolveLoader();
-          onSuccess == null ? void 0 : onSuccess();
-        },
-        () => {
-          statusRef.value = "FAILURE";
-          rejectLoader();
-          onFail == null ? void 0 : onFail();
-        }
-      );
-    },
-    MIN_MAP_RELOAD_INTERVAL,
-    { trailing: false }
-  );
-  watchPostEffectForDeepOption(
-    () => [optionsRef.value, disableRef == null ? void 0 : disableRef.value],
-    ([options, disable]) => {
-      if (disable)
-        return;
-      reload(options);
+  const reload = createOneConcurrent((options) => {
+    if (statusRef.value === "SUCCESS")
+      return Promise.resolve();
+    defineSecurityOnce();
+    distExports.reset();
+    statusRef.value = "LOADING";
+    return distExports.load(options).then(
+      () => {
+        statusRef.value = "SUCCESS";
+        resolveLoader();
+        onSuccess == null ? void 0 : onSuccess();
+      },
+      () => {
+        statusRef.value = "FAILURE";
+        onFail == null ? void 0 : onFail();
+      }
+    );
+  });
+  const keepRetry = createOneConcurrent(async () => {
+    const options = optionsRef.value;
+    while (!(disableRef == null ? void 0 : disableRef.value) && statusRef.value !== "SUCCESS") {
+      if (statusRef.value === "LOADING") {
+        await reload(options);
+        continue;
+      }
+      await sleep(MIN_MAP_RELOAD_INTERVAL);
+      const pingStatus = await apiPingAmap();
+      if (pingStatus === "unconnected")
+        continue;
+      await reload(options);
     }
-  );
-  return { statusRef, readyPromise };
+  });
+  watchPostEffectForDeepOption(() => [optionsRef.value, disableRef == null ? void 0 : disableRef.value], keepRetry);
+  return { statusRef, pingStatusRef, readyPromise };
 };
 const useGmapLoader = (props) => {
   const { disableRef, onSuccess, onFail } = props;
   let resolveLoader;
-  let rejectLoader;
-  const readyPromise = new Promise((resolve, reject) => {
+  const readyPromise = new Promise((resolve) => {
     resolveLoader = resolve;
-    rejectLoader = reject;
   });
   const statusRef = shallowRef(
     "LOADING"
     /* LOADING */
   );
+  const pingStatusRef = shallowRef("pending");
   const optionsRef = computed(() => {
     const { onSuccess: onSuccess2, onFail: onFail2, fallback, loading, language, ...options } = props;
     return options;
   });
-  const timerRef = ref();
-  const reload = throttle(
-    (options) => {
-      if (statusRef.value === "SUCCESS")
-        return;
-      const loader = new Loader(options);
-      patchGoogleMapLoader(loader);
-      clearTimeout(timerRef.value);
-      timerRef.value = window.setTimeout(() => {
-        statusRef.value = "TIMEOUT";
-      }, GMAP_LOAD_TIMEOUT);
-      if (loader.status !== LoaderStatus.INITIALIZED) {
-        window.google = void 0;
-        loader.reset();
+  const reload = createOneConcurrent((options, signal) => {
+    if (statusRef.value === "SUCCESS")
+      return Promise.resolve();
+    const loader = new Loader({ ...options, retries: 0 });
+    patchGoogleMapLoader(loader);
+    if (loader.status !== LoaderStatus.INITIALIZED) {
+      window.google = void 0;
+      loader.reset();
+    }
+    const abortPromise = new Promise((resolve) => signal == null ? void 0 : signal.addEventListener("abort", resolve));
+    statusRef.value = "LOADING";
+    const loadPromise = loader.load().then(
+      () => {
+        if (signal == null ? void 0 : signal.aborted)
+          return;
+        statusRef.value = "SUCCESS";
+        resolveLoader();
+        onSuccess == null ? void 0 : onSuccess();
+      },
+      () => {
+        if (signal == null ? void 0 : signal.aborted)
+          return;
+        statusRef.value = "FAILURE";
+        onFail == null ? void 0 : onFail();
+      }
+    );
+    return Promise.race([abortPromise, loadPromise]);
+  });
+  const keepRetry = createOneConcurrent(async () => {
+    if (statusRef.value === "SUCCESS") {
+      pingStatusRef.value = "pending";
+      while (pingStatusRef.value !== "connected") {
+        if (pingStatusRef.value === "unconnected")
+          await sleep(MIN_MAP_RELOAD_INTERVAL);
+        pingStatusRef.value = await apiPingGmap();
       }
-      statusRef.value = "LOADING";
-      return loader.load().then(
-        () => {
-          clearTimeout(timerRef.value);
-          statusRef.value = "SUCCESS";
-          resolveLoader();
-          onSuccess == null ? void 0 : onSuccess();
-        },
-        () => {
-          clearTimeout(timerRef.value);
-          statusRef.value = "FAILURE";
-          rejectLoader();
-          onFail == null ? void 0 : onFail();
-        }
-      );
-    },
-    MIN_MAP_RELOAD_INTERVAL,
-    { trailing: false }
-  );
-  watchPostEffectForDeepOption(
-    () => [optionsRef.value, disableRef == null ? void 0 : disableRef.value],
-    ([options, disable]) => {
-      if (disable)
-        return;
-      const language = navigator.language;
-      reload({ ...options, language });
     }
-  );
-  return { statusRef, readyPromise };
+    const language = navigator.language;
+    const options = { ...optionsRef.value, language };
+    while (!(disableRef == null ? void 0 : disableRef.value) && statusRef.value !== "SUCCESS") {
+      if (statusRef.value === "FAILURE" || pingStatusRef.value === "unconnected") {
+        await sleep(MIN_MAP_RELOAD_INTERVAL);
+        pingStatusRef.value = await apiPingGmap();
+        if (pingStatusRef.value === "connected")
+          statusRef.value = "LOADING";
+        continue;
+      }
+      const controller = new AbortController();
+      const reloadPromise = reload(options, controller.signal);
+      pingStatusRef.value = await apiPingGmap();
+      if (pingStatusRef.value === "unconnected") {
+        controller.abort();
+        continue;
+      }
+      await reloadPromise;
+    }
+  });
+  watchPostEffectForDeepOption(() => [optionsRef.value, disableRef == null ? void 0 : disableRef.value], keepRetry);
+  return { statusRef, pingStatusRef, readyPromise };
 };
 const useMapLoader = (props) => {
   const { gmapKey, amapKey, amapSecret, amapServiceHost, language, onSuccess, onFail } = props;
-  const { statusRef: amapStatusRef, readyPromise: amapReadyPromise } = useAmapLoader({
+  const {
+    statusRef: amapStatusRef,
+    pingStatusRef: amapPingStatusRef,
+    readyPromise: amapReadyPromise
+  } = useAmapLoader({
     apiKey: amapKey,
     apiSecret: amapSecret,
     apiServiceHost: amapServiceHost,
@@ -690,7 +708,11 @@ const useMapLoader = (props) => {
     onSuccess,
     onFail
   });
-  const { statusRef: gmapStatusRef, readyPromise: gmapReadyPromise } = useGmapLoader({
+  const {
+    statusRef: gmapStatusRef,
+    pingStatusRef: gmapPingStatusRef,
+    readyPromise: gmapReadyPromise
+  } = useGmapLoader({
     apiKey: gmapKey,
     language,
     version: "weekly",
@@ -705,6 +727,9 @@ const useMapLoader = (props) => {
     get statusRef() {
       return props.supplier === "gmap" ? gmapStatusRef : amapStatusRef;
     },
+    get pingStatusRef() {
+      return props.supplier === "gmap" ? gmapPingStatusRef : amapPingStatusRef;
+    },
     get readyPromise() {
       return props.supplier === "gmap" ? gmapReadyPromise : amapReadyPromise;
     }

package/dist/v2/hooks/useMapPlace.js

@@ -31,32 +31,37 @@ const useAmapPlace = (props) => {
   };
   const getPlaceByRegeo = abortable(([lng, lat]) => {
     return new Promise((resolve) => {
-      const geocoder = new AMap.Geocoder({ lang: language === "en" ? "en" : "zh_cn" });
-      const pipeTw = createPipeTw(language === "zh-TW");
-      const isChina = inChina([lng, lat]);
-      geocoder.getAddress(new AMap.LngLat(lng, lat), (status, result) => {
-        switch (status) {
-          case "complete": {
-            const { formattedAddress, addressComponent } = result.regeocode;
-            const name = formattedAddress ? formattedAddress : emptyPlaceName;
-            const displayName = amapPlaceName2DisplayName(name, { isChina, ...addressComponent });
-            resolve({ lng, lat, name: pipeTw(name), displayName: pipeTw(displayName) });
-            return;
-          }
-          case "no_data":
-          case "error": {
-            const name = emptyPlaceName;
-            const displayName = emptyPlaceName;
-            resolve({ lng, lat, name, displayName });
-            return;
-          }
-        }
-      });
-      setTimeout(() => {
-        console.warn("高德逆地理请求超时!");
+      const handleFailed = () => {
         const name = emptyPlaceName;
         const displayName = emptyPlaceName;
         resolve({ lng, lat, name, displayName });
+      };
+      readyPromise.then(() => {
+        const geocoder = new AMap.Geocoder({ lang: language === "en" ? "en" : "zh_cn" });
+        const pipeTw = createPipeTw(language === "zh-TW");
+        const isChina = inChina([lng, lat]);
+        geocoder.getAddress(new AMap.LngLat(lng, lat), (status, result) => {
+          switch (status) {
+            case "complete": {
+              const { formattedAddress, addressComponent } = result.regeocode;
+              const name = formattedAddress ? formattedAddress : emptyPlaceName;
+              const displayName = amapPlaceName2DisplayName(name, {
+                isChina,
+                ...addressComponent
+              });
+              resolve({ lng, lat, name: pipeTw(name), displayName: pipeTw(displayName) });
+              return;
+            }
+            case "no_data":
+            case "error": {
+              handleFailed();
+            }
+          }
+        });
+      }, handleFailed);
+      setTimeout(() => {
+        console.warn("高德逆地理请求超时!");
+        handleFailed();
       }, REGEO_TIMEOUT);
     });
   });
@@ -96,23 +101,25 @@ const useGmapPlace = (props) => {
   };
   const getPlaceByRegeo = abortable(([lng, lat]) => {
     return new Promise((resolve) => {
-      const geocoder = new google.maps.Geocoder();
-      const pipeTw = createPipeTw(language === "zh-TW");
-      geocoder.geocode({ language, location: { lng, lat } }).then(({ results }) => {
-        const name = results[0].formatted_address ? results[0].formatted_address : emptyPlaceName;
-        const displayName = gmapPlaceName2DisplayName(name, results[0].address_components);
-        resolve({ lng, lat, name: pipeTw(name), displayName: pipeTw(displayName) });
-      }).catch((err) => {
-        console.error(err);
+      const handleFailed = (err) => {
+        if (err)
+          console.error(err);
         const name = emptyPlaceName;
         const displayName = emptyPlaceName;
         resolve({ lng, lat, name, displayName });
-      });
+      };
+      readyPromise.then(() => {
+        const geocoder = new google.maps.Geocoder();
+        const pipeTw = createPipeTw(language === "zh-TW");
+        geocoder.geocode({ language, location: { lng, lat } }).then(({ results }) => {
+          const name = results[0].formatted_address ? results[0].formatted_address : emptyPlaceName;
+          const displayName = gmapPlaceName2DisplayName(name, results[0].address_components);
+          resolve({ lng, lat, name: pipeTw(name), displayName: pipeTw(displayName) });
+        }).catch(handleFailed);
+      }, handleFailed);
       setTimeout(() => {
         console.warn("谷歌逆地理请求超时!");
-        const name = emptyPlaceName;
-        const displayName = emptyPlaceName;
-        resolve({ lng, lat, name, displayName });
+        handleFailed();
       }, REGEO_TIMEOUT);
     });
   });

package/dist/v2/hooks/useMapRecomendPlace.js

@@ -3,7 +3,7 @@ import { GET_RECOMMEND_PLACE_TIMEOUT } from "../api/contants.js";
 import { logNoneManualAbortError } from "../utils/ManualAbortError.js";
 import { equalAssign, createAbortable, isPlacesInclude } from "../utils/helper.js";
 import { isZoneEqual, place2point, isPlaceEqual, businessCandidatesToAdsorptionPlace } from "../utils/transform.js";
-import { useMapGeometry } from "./useMapGeometry.js";
+import { useMapGeometry, apiLocalIsPointInRing } from "./useMapGeometry.js";
 import { useMapPlace } from "./useMapPlace.js";
 function mergeGetRecommendPlaceAndGetAvailable(getRecomendPlace, getAvailable, timeout) {
   return function mergedGetRecommendPlace(place, context) {
@@ -53,7 +53,7 @@ const useMapRecomendPlace = (props) => {
   const placeCandidatesRef = ref([]);
   const zoneRef = ref();
   const abortable = createAbortable(signal);
-  const { apiMapIsPointInRing, apiMapDistance } = useMapGeometry();
+  const { apiMapDistance } = useMapGeometry();
   const { getPlaceByRegeo } = useMapPlace({
     emptyPlaceName,
     pointRef: ref([...defaultPoint]),
@@ -99,7 +99,7 @@ const useMapRecomendPlace = (props) => {
     async (point, prevState) => {
       const [lng, lat] = point;
       const zone = zoneRef.value;
-      if (!zone || !apiMapIsPointInRing(point, zone.path)) {
+      if (!zone || !apiLocalIsPointInRing(point, zone.path)) {
         const reGeoPlacePromise = getPlaceByRegeo(point);
         const {
           place: closestPlace,
@@ -130,7 +130,7 @@ const useMapRecomendPlace = (props) => {
   );
   const updateIntermediateQueryingState = (point) => {
     const zone = zoneRef.value;
-    if (zone && apiMapIsPointInRing(point, zone.path))
+    if (zone && apiLocalIsPointInRing(point, zone.path))
       return;
     const [lng, lat] = point;
     const intermediateQueryingPlace = {

package/dist/v2/hooks/useMapSupplier.d.ts

@@ -1,10 +1,12 @@
 import type { AnyFn } from "@vueuse/core";
+import type { ConnectionStatus } from "../types/interface";
 import type { Status, UseMapLoaderOutput, UseMapLoaderProps } from "./useMapLoader";
 export interface MapSupplierPayolad extends UseMapLoaderProps {
     gmapRasterId: string;
     gmapId: string;
     readyPromise: UseMapLoaderOutput["readyPromise"];
     status: Status;
+    pingStatus: ConnectionStatus;
     renderLoadFailedTitle?: (status: Status) => string | undefined;
     renderLoadFailedDescription?: (status: Status) => string | undefined;
 }

package/dist/v2/hooks/usePingConnection.d.ts

@@ -0,0 +1,10 @@
+import { type PingConnectionOnChangeHandler } from "../api/pingConnection";
+export interface UsePingConnectionProps {
+    onChange?: PingConnectionOnChangeHandler;
+}
+export declare const usePingAmapConnection: (props?: UsePingConnectionProps) => {
+    connectionStatus: Readonly<import("vue-demi").Ref<import("..").ConnectionStatus>>;
+};
+export declare const usePingGmapConnection: (props?: UsePingConnectionProps) => {
+    connectionStatus: Readonly<import("vue-demi").Ref<import("..").ConnectionStatus>>;
+};

package/dist/v2/hooks/usePingConnection.js

@@ -0,0 +1,26 @@
+import { ref, onUnmounted, readonly } from "vue-demi";
+import { apiGetPingAmapStatus, apiSubscribePingAmapChange, apiGetPingGmapStatus, apiSubscribePingGmapChange } from "../api/pingConnection.js";
+const usePingAmapConnection = (props) => {
+  const statusRef = ref(apiGetPingAmapStatus());
+  const unsubscribe = apiSubscribePingAmapChange((status) => {
+    var _a;
+    statusRef.value = status;
+    (_a = props == null ? void 0 : props.onChange) == null ? void 0 : _a.call(props, status);
+  });
+  onUnmounted(unsubscribe);
+  return { connectionStatus: readonly(statusRef) };
+};
+const usePingGmapConnection = (props) => {
+  const statusRef = ref(apiGetPingGmapStatus());
+  const unsubscribe = apiSubscribePingGmapChange((status) => {
+    var _a;
+    statusRef.value = status;
+    (_a = props == null ? void 0 : props.onChange) == null ? void 0 : _a.call(props, status);
+  });
+  onUnmounted(unsubscribe);
+  return { connectionStatus: readonly(statusRef) };
+};
+export {
+  usePingAmapConnection,
+  usePingGmapConnection
+};

package/dist/v2/hooks-business/useBusinessRecomendPlaceMap.js

@@ -1,5 +1,5 @@
 import { reactive, ref, readonly } from "vue-demi";
-import { E as EMPTY_PLACE } from "../chunks/BusinessRecomendPlaceMap.f589ebf7.js";
+import { E as EMPTY_PLACE } from "../chunks/BusinessRecomendPlaceMap.4b641c71.js";
 import { CenterPlaceStatus } from "../types/interface.js";
 import { proxyFunctionalProperty, assertAssingedBeforeUsed } from "../utils/helper.js";
 const useBusinessRecomendPlaceMap = () => {

package/dist/v2/index.js

@@ -2,7 +2,7 @@ import "./utils/alipayPolyfill.js";
 import { AbsoluteAddressBox } from "./business-components/AbsoluteAddressBox/AbsoluteAddressBox.js";
 import { AddressBox } from "./business-components/AddressBox/AddressBox.js";
 import { BusinessQuotingMap } from "./business-components/BusinessQuotingMap/BusinessQuotingMap.js";
-import { B } from "./chunks/BusinessRecomendPlaceMap.f589ebf7.js";
+import { B } from "./chunks/BusinessRecomendPlaceMap.4b641c71.js";
 import { BusinessReselectPlaceMap } from "./business-components/BusinessReselectPlaceMap/BusinessReselectPlaceMap.js";
 import { BusinessTaxiEndMap } from "./business-components/BusinessTaxiEndMap/BusinessTaxiEndMap.js";
 import { BusinessTaxiServiceMap } from "./business-components/BusinessTaxiServiceMap/BusinessTaxiServiceMap.js";

package/dist/v2/types/global.d.ts

@@ -20,3 +20,6 @@ declare global {
         deviceorientationabsolute: DeviceOrientationEvent;
     }
 }
+declare module "@amap/amap-jsapi-loader" {
+    const reset: () => void;
+}

package/dist/v2/types/interface.d.ts

@@ -93,7 +93,7 @@ export declare enum CenterPlaceStatus {
     SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
     OK = "OK"
 }
-export type GoogleConnectionStatus = "pending" | "connected" | "unconnected";
+export type ConnectionStatus = "pending" | "connected" | "unconnected";
 export interface BusinessGeolocationPositionError extends GeolocationPositionError {
     isBusinessTimeout: boolean;
 }

package/dist/v2/utils/helper.d.ts

@@ -22,6 +22,7 @@ export declare const pausableSleep: (milliSeconds: number) => {
     restart: () => void;
 };
 export declare const createRunOnce: <P extends any[], R>(fn: (...args: P) => R) => (...args: P) => R;
+export declare const createOneConcurrent: <P extends any[], R>(fn: (...args: P) => Promise<R>) => (...args: P) => Promise<R> | undefined;
 export declare const createReadOnce: <T>(value: T) => () => T | undefined;
 export declare const createAsyncNoFailNonNullable: <P extends any[], R>(fn: (...args: P) => Promise<R>, defaultValue: NonNullable<R>) => (...args: P) => Promise<NonNullable<R>>;
 export declare const pipeTimeout: <P extends any[], R>(fn: (...args: P) => Promise<R>, defaultValue: R, timeout: number) => (...args: P) => Promise<R>;

package/dist/v2/utils/helper.js

@@ -93,6 +93,17 @@ const createRunOnce = (fn) => {
     return result;
   };
 };
+const createOneConcurrent = (fn) => {
+  let isRunning = false;
+  return function runOneConcurrent(...args) {
+    if (isRunning)
+      return;
+    isRunning = true;
+    const result = fn(...args);
+    result.finally(() => isRunning = false);
+    return result;
+  };
+};
 const createReadOnce = (value) => {
   let isRead = false;
   return function read() {
@@ -171,6 +182,7 @@ export {
   assertZone,
   createAbortable,
   createAsyncNoFailNonNullable,
+  createOneConcurrent,
   createReadOnce,
   createRunOnce,
   defered,

package/dist/v2/utils/log.js

@@ -1,6 +1,6 @@
 const availableLogKeys = /* @__PURE__ */ new Set();
 const pkgName = "@heycar/heycars-map";
-const pkgVersion = "2.0.0-switchMap3";
+const pkgVersion = "2.0.0-switchMap5";
 const isEnableLog = (name) => {
   const searchParam = new URLSearchParams(location.search);
   return searchParam.has(`log-${name}`);

package/dist/v3/Demo/DemoBusinessRecomendPlace.js

@@ -1,5 +1,5 @@
 import { createVNode } from "vue";
-import { B as BusinessRecomendPlaceMap } from "../chunks/BusinessRecomendPlaceMap.86e9c287.js";
+import { B as BusinessRecomendPlaceMap } from "../chunks/BusinessRecomendPlaceMap.4befb6c7.js";
 import { useBusinessRecomendPlaceMap } from "../hooks-business/useBusinessRecomendPlaceMap.js";
 import { defineSetup } from "../types/helper.js";
 import { d as demo } from "../chunks/Demo.css.e921a2f6.js";

package/dist/v3/api/pingConnection.d.ts

@@ -0,0 +1,9 @@
+import type { ConnectionStatus } from "../types/interface";
+export type PingConnectionOnChangeHandler = (status: ConnectionStatus) => void;
+export type PingConnectionOnChangeCleanup = () => void;
+export declare const apiGetPingAmapStatus: () => ConnectionStatus;
+export declare const apiGetPingGmapStatus: () => ConnectionStatus;
+export declare const apiPingAmap: () => Promise<ConnectionStatus>;
+export declare const apiPingGmap: () => Promise<ConnectionStatus>;
+export declare const apiSubscribePingAmapChange: (handler: PingConnectionOnChangeHandler) => PingConnectionOnChangeCleanup;
+export declare const apiSubscribePingGmapChange: (handler: PingConnectionOnChangeHandler) => PingConnectionOnChangeCleanup;

package/dist/v3/api/pingConnection.js

@@ -0,0 +1,107 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { sleep } from "../utils/helper.js";
+const PING_AMAP_URL = "https://webapi.amap.com/favicon.ico";
+const PING_AMAP_TIMEOUT = 5e3;
+const PING_AMAP_INTERVAL = 5e3;
+const PING_GMAP_URL = "https://maps.googleapis.com/";
+const PING_GMAP_TIMEOUT = 5e3;
+const PING_GMAP_INTERVAL = 5e3;
+const noop = () => {
+};
+const toUncachableUrl = (url, label = "") => {
+  const parsedUrl = new URL(url);
+  const randomKey = `ping${Date.now()}`;
+  parsedUrl.searchParams.set(randomKey, label);
+  return parsedUrl.toString();
+};
+class PingConnection {
+  constructor({ timeout, url }) {
+    __publicField(this, "timeout");
+    __publicField(this, "url");
+    __publicField(this, "status", "pending");
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "updatingPromise");
+    this.timeout = timeout;
+    this.url = url;
+  }
+  // 只有订阅了 onChange 事件，listen 才会更新状态
+  async listen(interval) {
+    while (true) {
+      if (this.listeners.size > 0)
+        await this.updateStatus();
+      await sleep(interval);
+    }
+  }
+  async updateStatus() {
+    const { url, timeout } = this;
+    if (this.updatingPromise)
+      return this.updatingPromise;
+    return this.updatingPromise = this.check(url, timeout).then((status) => {
+      this.status = status;
+      this.updatingPromise = void 0;
+      for (const handler of this.listeners) {
+        try {
+          handler(status);
+        } catch (err) {
+          console.error(err);
+        }
+      }
+      return status;
+    });
+  }
+  check(url, timeout) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    return fetch(toUncachableUrl(url, timeout.toString()), {
+      signal: controller.signal,
+      method: "HEAD",
+      mode: "no-cors"
+    }).then(() => "connected").catch(() => "unconnected").finally(() => clearTimeout(timer));
+  }
+  onChange(handler) {
+    if (typeof handler !== "function")
+      return noop;
+    this.listeners.add(handler);
+    const clear = () => {
+      this.listeners.delete(handler);
+    };
+    return clear;
+  }
+}
+const pingAmapConnection = new PingConnection({
+  timeout: PING_AMAP_TIMEOUT,
+  url: PING_AMAP_URL
+});
+const pingGmapConnection = new PingConnection({
+  timeout: PING_GMAP_TIMEOUT,
+  url: PING_GMAP_URL
+});
+pingAmapConnection.listen(PING_AMAP_INTERVAL);
+pingGmapConnection.listen(PING_GMAP_INTERVAL);
+const apiGetPingAmapStatus = () => {
+  return pingAmapConnection.status;
+};
+const apiGetPingGmapStatus = () => {
+  return pingGmapConnection.status;
+};
+const apiPingAmap = () => {
+  return pingAmapConnection.updateStatus();
+};
+const apiPingGmap = () => {
+  return pingGmapConnection.updateStatus();
+};
+const apiSubscribePingAmapChange = (handler) => pingAmapConnection.onChange(handler);
+const apiSubscribePingGmapChange = (handler) => pingGmapConnection.onChange(handler);
+export {
+  apiGetPingAmapStatus,
+  apiGetPingGmapStatus,
+  apiPingAmap,
+  apiPingGmap,
+  apiSubscribePingAmapChange,
+  apiSubscribePingGmapChange
+};