@h-ai/capacitor 0.1.0-alpha9 → 1.0.0-beta.10

package/dist/index.js

@@ -8,15 +8,39 @@ var en_US_default = {
   capacitor_initFailed: "Capacitor initialization failed",
   capacitor_initInProgress: "Capacitor initialization is already in progress",
   capacitor_notAvailable: "Capacitor is not available in this environment",
+  capacitor_secureStorageClearFailed: "Could not fully clear sign-in credentials from secure storage; retry signing out",
   capacitor_preferencesGetFailed: "Failed to read from Capacitor Preferences",
   capacitor_preferencesSetFailed: "Failed to write to Capacitor Preferences",
   capacitor_preferencesRemoveFailed: "Failed to remove from Capacitor Preferences",
   capacitor_deviceInfoFailed: "Failed to get device info",
+  capacitor_appVersionFailed: "Failed to get app version",
   capacitor_pushRegisterFailed: "Failed to register push notifications",
   capacitor_pushListenFailed: "Failed to listen for push notifications",
   capacitor_cameraFailed: "Failed to access camera",
   capacitor_statusBarFailed: "Failed to configure status bar",
-  capacitor_notInitialized: "Capacitor module is not initialized"
+  capacitor_notInitialized: "Capacitor module is not initialized",
+  capacitor_pushCancelled: "The push operation was cancelled, timed out or the module was closed",
+  capacitor_pushCleanupFailed: "Push listeners could not be fully removed; retry cleanup or close the module"
+};
+
+// messages/ja-JP.json
+var ja_JP_default = {
+  capacitor_initFailed: "Capacitor\u306E\u521D\u671F\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_initInProgress: "Capacitor\u306E\u521D\u671F\u5316\u306F\u65E2\u306B\u5B9F\u884C\u4E2D\u3067\u3059",
+  capacitor_notAvailable: "\u3053\u306E\u74B0\u5883\u3067\u306FCapacitor\u3092\u5229\u7528\u3067\u304D\u307E\u305B\u3093",
+  capacitor_secureStorageClearFailed: "\u5B89\u5168\u306A\u30B9\u30C8\u30EC\u30FC\u30B8\u306E\u30ED\u30B0\u30A4\u30F3\u8A8D\u8A3C\u60C5\u5831\u3092\u5B8C\u5168\u306B\u524A\u9664\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u30ED\u30B0\u30A2\u30A6\u30C8\u3092\u518D\u8A66\u884C\u3057\u3066\u304F\u3060\u3055\u3044",
+  capacitor_preferencesGetFailed: "Capacitor Preferences\u304B\u3089\u306E\u8AAD\u307F\u53D6\u308A\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_preferencesSetFailed: "Capacitor Preferences\u3078\u306E\u66F8\u304D\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_preferencesRemoveFailed: "Capacitor Preferences\u304B\u3089\u306E\u524A\u9664\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_deviceInfoFailed: "\u30C7\u30D0\u30A4\u30B9\u60C5\u5831\u306E\u53D6\u5F97\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_appVersionFailed: "\u30A2\u30D7\u30EA\u306E\u30D0\u30FC\u30B8\u30E7\u30F3\u306E\u53D6\u5F97\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_pushRegisterFailed: "\u30D7\u30C3\u30B7\u30E5\u901A\u77E5\u306E\u767B\u9332\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_pushListenFailed: "\u30D7\u30C3\u30B7\u30E5\u901A\u77E5\u306E\u53D7\u4FE1\u8A2D\u5B9A\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_cameraFailed: "\u30AB\u30E1\u30E9\u3078\u306E\u30A2\u30AF\u30BB\u30B9\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_statusBarFailed: "\u30B9\u30C6\u30FC\u30BF\u30B9\u30D0\u30FC\u306E\u8A2D\u5B9A\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  capacitor_notInitialized: "Capacitor\u30E2\u30B8\u30E5\u30FC\u30EB\u304C\u521D\u671F\u5316\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+  capacitor_pushCancelled: "\u30D7\u30C3\u30B7\u30E5\u64CD\u4F5C\u304C\u30AD\u30E3\u30F3\u30BB\u30EB\u3055\u308C\u305F\u304B\u3001\u30BF\u30A4\u30E0\u30A2\u30A6\u30C8\u3057\u305F\u304B\u3001\u30E2\u30B8\u30E5\u30FC\u30EB\u304C\u7D42\u4E86\u3057\u307E\u3057\u305F",
+  capacitor_pushCleanupFailed: "\u30D7\u30C3\u30B7\u30E5\u30EA\u30B9\u30CA\u30FC\u3092\u5B8C\u5168\u306B\u524A\u9664\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u30AF\u30EA\u30FC\u30F3\u30A2\u30C3\u30D7\u3092\u518D\u8A66\u884C\u3059\u308B\u304B\u3001\u30E2\u30B8\u30E5\u30FC\u30EB\u3092\u7D42\u4E86\u3057\u3066\u304F\u3060\u3055\u3044"
 };
 
 // messages/zh-CN.json
@@ -24,21 +48,26 @@ var zh_CN_default = {
   capacitor_initFailed: "Capacitor \u521D\u59CB\u5316\u5931\u8D25",
   capacitor_initInProgress: "Capacitor \u6B63\u5728\u521D\u59CB\u5316\u4E2D",
   capacitor_notAvailable: "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 Capacitor",
+  capacitor_secureStorageClearFailed: "\u672A\u80FD\u5B8C\u5168\u6E05\u9664\u5B89\u5168\u5B58\u50A8\u4E2D\u7684\u767B\u5F55\u51ED\u636E\uFF0C\u8BF7\u91CD\u8BD5\u9000\u51FA",
   capacitor_preferencesGetFailed: "\u8BFB\u53D6 Capacitor Preferences \u5931\u8D25",
   capacitor_preferencesSetFailed: "\u5199\u5165 Capacitor Preferences \u5931\u8D25",
   capacitor_preferencesRemoveFailed: "\u5220\u9664 Capacitor Preferences \u5931\u8D25",
   capacitor_deviceInfoFailed: "\u83B7\u53D6\u8BBE\u5907\u4FE1\u606F\u5931\u8D25",
+  capacitor_appVersionFailed: "\u83B7\u53D6\u5E94\u7528\u7248\u672C\u5931\u8D25",
   capacitor_pushRegisterFailed: "\u6CE8\u518C\u63A8\u9001\u901A\u77E5\u5931\u8D25",
   capacitor_pushListenFailed: "\u76D1\u542C\u63A8\u9001\u901A\u77E5\u5931\u8D25",
   capacitor_cameraFailed: "\u8BBF\u95EE\u76F8\u673A\u5931\u8D25",
   capacitor_statusBarFailed: "\u914D\u7F6E\u72B6\u6001\u680F\u5931\u8D25",
-  capacitor_notInitialized: "Capacitor \u6A21\u5757\u672A\u521D\u59CB\u5316"
+  capacitor_notInitialized: "Capacitor \u6A21\u5757\u672A\u521D\u59CB\u5316",
+  capacitor_pushCancelled: "\u63A8\u9001\u64CD\u4F5C\u5DF2\u53D6\u6D88\u3001\u8D85\u65F6\u6216\u6A21\u5757\u5DF2\u5173\u95ED",
+  capacitor_pushCleanupFailed: "\u63A8\u9001\u76D1\u542C\u5668\u672A\u5B8C\u5168\u79FB\u9664\uFF0C\u8BF7\u91CD\u8BD5\u6E05\u7406\u6216\u5173\u95ED\u6A21\u5757"
 };
 
 // src/capacitor-i18n.ts
 var capacitorM = core.i18n.createMessageGetter({
   "zh-CN": zh_CN_default,
-  "en-US": en_US_default
+  "en-US": en_US_default,
+  "ja-JP": ja_JP_default
 });
 var CapacitorErrorInfo = {
   INIT_FAILED: "001:500",
@@ -49,8 +78,10 @@ var CapacitorErrorInfo = {
   PREFERENCES_SET_FAILED: "012:500",
   PREFERENCES_REMOVE_FAILED: "013:500",
   DEVICE_INFO_FAILED: "020:500",
+  APP_VERSION_FAILED: "021:500",
   PUSH_REGISTER_FAILED: "030:500",
   PUSH_LISTEN_FAILED: "031:500",
+  PUSH_CLEANUP_FAILED: "032:500",
   CAMERA_FAILED: "040:500",
   STATUS_BAR_FAILED: "050:500"
 };
@@ -128,100 +159,188 @@ async function getAppVersion() {
     });
   } catch (cause) {
     return err(
-      HaiCapacitorError.DEVICE_INFO_FAILED,
-      capacitorM("capacitor_deviceInfoFailed"),
+      HaiCapacitorError.APP_VERSION_FAILED,
+      capacitorM("capacitor_appVersionFailed"),
       cause
     );
   }
 }
-async function registerPush() {
-  try {
-    const { PushNotifications } = await import('@capacitor/push-notifications');
-    const permResult = await PushNotifications.requestPermissions();
-    if (permResult.receive !== "granted") {
-      return err(
-        HaiCapacitorError.PUSH_REGISTER_FAILED,
-        capacitorM("capacitor_pushRegisterFailed")
-      );
+var logger = core.logger.child({ module: "capacitor", scope: "push" });
+var activeScopes = /* @__PURE__ */ new Set();
+function createPushScope(options) {
+  let scope;
+  const controller = new AbortController();
+  const handles = /* @__PURE__ */ new Set();
+  const removals = /* @__PURE__ */ new Map();
+  let pending = 0;
+  let closing;
+  let timer;
+  const cancelled = () => new Error(capacitorM("capacitor_pushCancelled"));
+  function releaseIfComplete() {
+    if (controller.signal.aborted && pending === 0 && handles.size === 0)
+      activeScopes.delete(scope);
+  }
+  function remove(handle) {
+    const current = removals.get(handle);
+    if (current)
+      return current;
+    const removal = Promise.resolve().then(() => handle.remove()).then(() => {
+      handles.delete(handle);
+    }).finally(() => {
+      removals.delete(handle);
+      releaseIfComplete();
+    });
+    removals.set(handle, removal);
+    return removal;
+  }
+  function finishSetup() {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
     }
-    const REGISTER_TIMEOUT_MS = 3e4;
-    const token = await new Promise((resolve, reject) => {
-      let regListener;
-      let errListener;
-      const timer = setTimeout(() => {
-        cleanup();
-        reject(new Error("Push registration timed out"));
-      }, REGISTER_TIMEOUT_MS);
-      function cleanup() {
-        clearTimeout(timer);
-        regListener?.remove();
-        errListener?.remove();
+  }
+  function dispose() {
+    controller.abort();
+    finishSetup();
+    options?.signal?.removeEventListener("abort", onAbort);
+    if (closing)
+      return closing;
+    closing = Promise.allSettled([...handles].map(remove)).then((results) => {
+      releaseIfComplete();
+      if (results.some((result) => result.status === "rejected"))
+        throw new Error(capacitorM("capacitor_pushCleanupFailed"));
+    }).finally(() => {
+      closing = void 0;
+    });
+    return closing;
+  }
+  function onAbort() {
+    void dispose().catch(() => logger.warn("Push listener cleanup failed; retry cleanup or capacitor.close"));
+  }
+  scope = {
+    signal: controller.signal,
+    assertOpen() {
+      if (controller.signal.aborted)
+        throw cancelled();
+    },
+    async attach(add) {
+      scope.assertOpen();
+      pending++;
+      try {
+        const handle = await add();
+        handles.add(handle);
+        if (controller.signal.aborted) {
+          await remove(handle);
+          throw cancelled();
+        }
+      } finally {
+        pending--;
+        releaseIfComplete();
       }
-      PushNotifications.addListener("registration", (t) => {
-        cleanup();
-        resolve(t.value);
-      }).then((l) => {
-        regListener = l;
+    },
+    async wait(operation) {
+      scope.assertOpen();
+      let interrupt;
+      const aborted = new Promise((_, reject) => {
+        interrupt = () => reject(cancelled());
+        controller.signal.addEventListener("abort", interrupt, { once: true });
       });
-      PushNotifications.addListener("registrationError", (error) => {
-        cleanup();
-        reject(error);
-      }).then((l) => {
-        errListener = l;
+      try {
+        return await Promise.race([Promise.resolve().then(operation), aborted]);
+      } finally {
+        if (interrupt)
+          controller.signal.removeEventListener("abort", interrupt);
+      }
+    },
+    finishSetup,
+    dispose
+  };
+  activeScopes.add(scope);
+  timer = setTimeout(onAbort, 3e4);
+  options?.signal?.addEventListener("abort", onAbort, { once: true });
+  if (options?.signal?.aborted)
+    onAbort();
+  return scope;
+}
+async function loadPushPlugin() {
+  const { Capacitor } = await import('@capacitor/core');
+  if (!Capacitor.isNativePlatform())
+    throw new Error(capacitorM("capacitor_notAvailable"));
+  return (await import('@capacitor/push-notifications')).PushNotifications;
+}
+async function closePushListeners() {
+  const results = await Promise.allSettled([...activeScopes].map((scope) => scope.dispose()));
+  return results.some((result) => result.status === "rejected") ? err(HaiCapacitorError.PUSH_CLEANUP_FAILED, capacitorM("capacitor_pushCleanupFailed")) : ok(void 0);
+}
+async function registerPush(options) {
+  const scope = createPushScope(options);
+  try {
+    const token = await scope.wait(async () => {
+      const push = await loadPushPlugin();
+      scope.assertOpen();
+      const permission = await push.requestPermissions();
+      scope.assertOpen();
+      if (permission.receive !== "granted")
+        throw new Error(capacitorM("capacitor_pushRegisterFailed"));
+      let resolveToken;
+      let rejectToken;
+      const tokenResult = new Promise((resolve, reject) => {
+        resolveToken = resolve;
+        rejectToken = reject;
       });
-      PushNotifications.register();
+      const setup = async () => {
+        await scope.attach(() => push.addListener("registration", (result) => {
+          if (!scope.signal.aborted)
+            resolveToken(result.value);
+        }));
+        await scope.attach(() => push.addListener("registrationError", () => {
+          if (!scope.signal.aborted)
+            rejectToken(new Error(capacitorM("capacitor_pushRegisterFailed")));
+        }));
+        scope.assertOpen();
+        await push.register();
+      };
+      return (await Promise.all([setup(), tokenResult]))[1];
     });
+    await scope.dispose();
     return ok({ token });
   } catch (cause) {
-    return err(
-      HaiCapacitorError.PUSH_REGISTER_FAILED,
-      capacitorM("capacitor_pushRegisterFailed"),
-      cause
-    );
+    await scope.dispose().catch(() => logger.warn("Push registration cleanup failed; retry capacitor.close"));
+    return err(HaiCapacitorError.PUSH_REGISTER_FAILED, capacitorM("capacitor_pushRegisterFailed"), cause);
   }
 }
-async function listenPush(callbacks) {
+async function listenPush(callbacks, options) {
+  const scope = createPushScope(options);
   try {
-    const { PushNotifications } = await import('@capacitor/push-notifications');
-    const listeners = [];
-    if (callbacks.onReceived) {
-      const listener = await PushNotifications.addListener(
-        "pushNotificationReceived",
-        (notification) => {
-          callbacks.onReceived?.({
-            id: notification.id,
-            title: notification.title,
-            body: notification.body,
-            data: notification.data
-          });
-        }
-      );
-      listeners.push(listener);
-    }
-    if (callbacks.onActionPerformed) {
-      const listener = await PushNotifications.addListener(
-        "pushNotificationActionPerformed",
-        (action) => {
-          callbacks.onActionPerformed?.({
-            id: action.notification.id,
-            title: action.notification.title,
-            body: action.notification.body,
-            data: action.notification.data
-          });
-        }
-      );
-      listeners.push(listener);
-    }
-    const cleanup = async () => {
-      await Promise.all(listeners.map((l) => l.remove()));
-    };
-    return ok(cleanup);
+    await scope.wait(async () => {
+      const push = await loadPushPlugin();
+      scope.assertOpen();
+      if (callbacks.onReceived) {
+        await scope.attach(() => push.addListener("pushNotificationReceived", (notification) => {
+          if (!scope.signal.aborted)
+            callbacks.onReceived?.({ id: notification.id, title: notification.title, body: notification.body, data: notification.data });
+        }));
+      }
+      if (callbacks.onActionPerformed) {
+        await scope.attach(() => push.addListener("pushNotificationActionPerformed", (action) => {
+          if (!scope.signal.aborted)
+            callbacks.onActionPerformed?.({ id: action.notification.id, title: action.notification.title, body: action.notification.body, data: action.notification.data });
+        }));
+      }
+    });
+    scope.assertOpen();
+    scope.finishSetup();
+    return ok(async () => {
+      try {
+        await scope.dispose();
+        return ok(void 0);
+      } catch (cause) {
+        return err(HaiCapacitorError.PUSH_CLEANUP_FAILED, capacitorM("capacitor_pushCleanupFailed"), cause);
+      }
+    });
   } catch (cause) {
-    return err(
-      HaiCapacitorError.PUSH_LISTEN_FAILED,
-      capacitorM("capacitor_pushListenFailed"),
-      cause
-    );
+    await scope.dispose().catch(() => logger.warn("Push setup cleanup failed; retry capacitor.close"));
+    return err(HaiCapacitorError.PUSH_LISTEN_FAILED, capacitorM("capacitor_pushListenFailed"), cause);
   }
 }
 async function configureStatusBar(config) {
@@ -276,52 +395,74 @@ async function hideStatusBar() {
     );
   }
 }
-var logger = core.logger.child({ module: "capacitor", scope: "token-storage" });
 var PREF_ACCESS_TOKEN = "hai_access_token";
 var PREF_REFRESH_TOKEN = "hai_refresh_token";
+async function loadSecureStoragePlugin() {
+  const { Capacitor } = await import('@capacitor/core');
+  if (!Capacitor.isNativePlatform())
+    throw new Error(capacitorM("capacitor_notAvailable"));
+  const { SecureStorage } = await import('@aparajita/capacitor-secure-storage');
+  return SecureStorage;
+}
 function createCapacitorTokenStorage() {
+  let credentialGeneration = 0;
+  let accessBlocked = false;
+  let refreshBlocked = false;
+  function blockCredentials() {
+    credentialGeneration++;
+    accessBlocked = true;
+    refreshBlocked = true;
+  }
+  async function writeToken(key, token) {
+    const writeGeneration = credentialGeneration;
+    try {
+      const storage = await loadSecureStoragePlugin();
+      await storage.setItem(key, token);
+      if (writeGeneration === credentialGeneration) {
+        if (key === PREF_ACCESS_TOKEN)
+          accessBlocked = false;
+        else
+          refreshBlocked = false;
+      }
+    } catch (error) {
+      if (writeGeneration === credentialGeneration)
+        blockCredentials();
+      throw error;
+    }
+  }
   return {
     async getAccessToken() {
-      try {
-        const { value } = await Preferences.get({ key: PREF_ACCESS_TOKEN });
-        return value;
-      } catch (error) {
-        logger.error("Failed to get access token from Preferences", { error });
+      const readGeneration = credentialGeneration;
+      const storage = await loadSecureStoragePlugin();
+      if (accessBlocked)
         return null;
-      }
+      const token = await storage.getItem(PREF_ACCESS_TOKEN);
+      return accessBlocked || readGeneration !== credentialGeneration ? null : token;
     },
     async getRefreshToken() {
-      try {
-        const { value } = await Preferences.get({ key: PREF_REFRESH_TOKEN });
-        return value;
-      } catch (error) {
-        logger.error("Failed to get refresh token from Preferences", { error });
+      const readGeneration = credentialGeneration;
+      const storage = await loadSecureStoragePlugin();
+      if (refreshBlocked)
         return null;
-      }
+      const token = await storage.getItem(PREF_REFRESH_TOKEN);
+      return refreshBlocked || readGeneration !== credentialGeneration ? null : token;
     },
     async setAccessToken(token) {
-      try {
-        await Preferences.set({ key: PREF_ACCESS_TOKEN, value: token });
-      } catch (error) {
-        logger.error("Failed to set access token in Preferences", { error });
-      }
+      await writeToken(PREF_ACCESS_TOKEN, token);
     },
     async setRefreshToken(token) {
-      try {
-        await Preferences.set({ key: PREF_REFRESH_TOKEN, value: token });
-      } catch (error) {
-        logger.error("Failed to set refresh token in Preferences", { error });
-      }
+      await writeToken(PREF_REFRESH_TOKEN, token);
     },
     async clear() {
-      try {
-        await Promise.all([
-          Preferences.remove({ key: PREF_ACCESS_TOKEN }),
-          Preferences.remove({ key: PREF_REFRESH_TOKEN })
-        ]);
-      } catch (error) {
-        logger.error("Failed to clear tokens from Preferences", { error });
-      }
+      blockCredentials();
+      const storage = await loadSecureStoragePlugin();
+      const results = await Promise.allSettled([
+        storage.removeItem(PREF_ACCESS_TOKEN),
+        storage.removeItem(PREF_REFRESH_TOKEN)
+      ]);
+      const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+      if (errors.length > 0)
+        throw new AggregateError(errors, capacitorM("capacitor_secureStorageClearFailed"));
     }
   };
 }
@@ -417,8 +558,13 @@ var capacitor = {
     try {
       if (initialized) {
         logger2.warn("Capacitor module is already initialized, reinitializing");
-        await capacitor.close();
+        const closed = await capacitor.close();
+        if (!closed.success)
+          return closed;
       }
+      const cleaned = await closePushListeners();
+      if (!cleaned.success)
+        return cleaned;
       logger2.info("Initializing capacitor module");
       if (!isCapacitorAvailable()) {
         logger2.error("Capacitor is not available in current environment");
@@ -452,14 +598,14 @@ var capacitor = {
     }
   },
   async close() {
-    if (!initialized) {
-      logger2.info("Capacitor module is already closed, skipping");
-      return;
-    }
     logger2.info("Closing capacitor module");
     initialized = false;
     cachedPlatform = null;
+    const cleaned = await closePushListeners();
+    if (!cleaned.success)
+      return cleaned;
     logger2.info("Capacitor module closed");
+    return ok(void 0);
   },
   getPlatform() {
     if (cachedPlatform) {