abckit 0.0.19 → 0.0.21

package/dist/module.mjs

@@ -204,6 +204,8 @@ export {}
     nuxt.options.alias["abckit/components"] = resolve("./runtime/components");
     nuxt.options.alias["abckit/shadcn"] = resolve("./runtime/components/ui");
     nuxt.options.alias["abckit/composables"] = resolve("./runtime/composables");
+    nuxt.options.alias["abckit/middleware"] = resolve("./runtime/middleware");
+    nuxt.options.alias["abckit/plugins"] = resolve("./runtime/plugins");
     nuxt.options.alias["abckit/graphql"] = resolve("./runtime/graphql");
     nuxt.options.alias["abckit/stores"] = resolve("./runtime/stores");
     nuxt.options.alias["abckit/utils"] = resolve("./runtime/utils");
@@ -243,9 +245,8 @@ export {}
     };
     addServerScanDir(resolve("./runtime/server"));
     addRouteMiddleware({
-      name: "auth-status",
-      path: resolve("./runtime/middleware/auth.global"),
-      global: true
+      name: "auth",
+      path: resolve("./runtime/middleware/auth")
     });
   }
 });

package/dist/runtime/composables/useAppRouter.d.ts

@@ -0,0 +1,18 @@
+import type { UseIonRouterResult } from '@ionic/vue';
+import type { RouteLocationRaw } from 'vue-router';
+/**
+ * Register Ionic router for mobile navigation
+ * Call this in app.vue or a plugin: setIonRouter(useIonRouter())
+ */
+export declare function setIonRouter(router: UseIonRouterResult): void;
+/**
+ * Platform-aware router composable
+ * Uses Ionic router on mobile (if registered), Nuxt router on web
+ */
+export declare function useAppRouter(): {
+    push: (to: RouteLocationRaw) => void;
+    replace: (to: RouteLocationRaw) => void;
+    back: () => void;
+    canGoBack: () => boolean;
+    isMobile: any;
+};

package/dist/runtime/composables/useAppRouter.js

@@ -0,0 +1,46 @@
+import { navigateTo, useRouter, useRuntimeConfig } from "#app";
+let _ionRouter = null;
+export function setIonRouter(router) {
+  _ionRouter = router;
+}
+export function useAppRouter() {
+  const config = useRuntimeConfig();
+  const isMobile = config.public.abckit?.auth?.capacitor ?? false;
+  const vueRouter = useRouter();
+  function push(to) {
+    const path = typeof to === "string" ? to : to.path || "/";
+    if (isMobile && _ionRouter) {
+      _ionRouter.push(path);
+    } else {
+      navigateTo(to);
+    }
+  }
+  function replace(to) {
+    const path = typeof to === "string" ? to : to.path || "/";
+    if (isMobile && _ionRouter) {
+      _ionRouter.navigate(path, "forward", "replace");
+    } else {
+      navigateTo(to, { replace: true });
+    }
+  }
+  function back() {
+    if (isMobile && _ionRouter) {
+      _ionRouter.back();
+    } else {
+      vueRouter.back();
+    }
+  }
+  function canGoBack() {
+    if (isMobile && _ionRouter) {
+      return _ionRouter.canGoBack();
+    }
+    return true;
+  }
+  return {
+    push,
+    replace,
+    back,
+    canGoBack,
+    isMobile
+  };
+}

package/dist/runtime/composables/useIsMobile.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Check if running on mobile (Capacitor)
+ * Uses abckit.auth.capacitor config
+ */
+export declare function useIsMobile(): boolean;

package/dist/runtime/composables/useIsMobile.js

@@ -0,0 +1,5 @@
+import { useRuntimeConfig } from "#app";
+export function useIsMobile() {
+  const config = useRuntimeConfig();
+  return config.public.abckit?.auth?.capacitor ?? false;
+}

package/dist/runtime/middleware/auth.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Auth middleware - protects routes from unauthenticated access
+ * Usage: definePageMeta({ middleware: 'auth' })
+ */
+declare const _default: import("nuxt/app").RouteMiddleware;
+export default _default;

package/dist/runtime/middleware/auth.js

@@ -0,0 +1,15 @@
+import { defineNuxtRouteMiddleware } from "#app";
+import { useAppRouter } from "../composables/useAppRouter.js";
+import { useAuth } from "../composables/useAuth.js";
+export default defineNuxtRouteMiddleware((to) => {
+  if (import.meta.server)
+    return;
+  const { isAuthenticated, isLoading } = useAuth();
+  if (isLoading.value)
+    return;
+  if (!isAuthenticated.value) {
+    const { replace } = useAppRouter();
+    replace(`/auth/login?redirect=${encodeURIComponent(to.fullPath)}`);
+    return false;
+  }
+});

package/dist/runtime/plugins/capacitor-client.d.ts

@@ -1,11 +1,20 @@
 import type { BetterAuthClientPlugin } from 'better-auth';
+import type { FocusManager, OnlineManager } from 'better-auth/client';
 interface CapacitorClientOptions {
     /**
      * Prefix for storage keys
      * @default 'better-auth'
      */
     storagePrefix?: string;
+    /**
+     * Prefix(es) for server cookie names to filter
+     * Prevents infinite refetching when third-party cookies are set
+     * @default 'better-auth'
+     */
+    cookiePrefix?: string | string[];
 }
+export declare function setupCapacitorFocusManager(): FocusManager;
+export declare function setupCapacitorOnlineManager(): OnlineManager;
 /**
  * Capacitor client plugin for Better Auth
  * Provides offline-first authentication with persistent storage

package/dist/runtime/plugins/capacitor-client.js

@@ -1,4 +1,74 @@
 import { Preferences } from "@capacitor/preferences";
+import { kFocusManager, kOnlineManager } from "better-auth/client";
+class CapacitorFocusManager {
+  listeners = /* @__PURE__ */ new Set();
+  unsubscribe;
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  setFocused(focused) {
+    this.listeners.forEach((listener) => listener(focused));
+  }
+  setup() {
+    import("@capacitor/app").then(async ({ App }) => {
+      const handle = await App.addListener("appStateChange", (state) => {
+        this.setFocused(state.isActive);
+      });
+      this.unsubscribe = () => handle.remove();
+    }).catch(() => {
+    });
+    return () => {
+      this.unsubscribe?.();
+    };
+  }
+}
+export function setupCapacitorFocusManager() {
+  const global = globalThis;
+  if (!global[kFocusManager]) {
+    global[kFocusManager] = new CapacitorFocusManager();
+  }
+  return global[kFocusManager];
+}
+class CapacitorOnlineManager {
+  listeners = /* @__PURE__ */ new Set();
+  isOnline = true;
+  unsubscribe;
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  setOnline(online) {
+    this.isOnline = online;
+    this.listeners.forEach((listener) => listener(online));
+  }
+  setup() {
+    import("@capacitor/network").then(async ({ Network }) => {
+      const handle = await Network.addListener("networkStatusChange", (status) => {
+        this.setOnline(status.connected);
+      });
+      this.unsubscribe = () => handle.remove();
+    }).catch(() => {
+      this.setOnline(true);
+    });
+    return () => {
+      this.unsubscribe?.();
+    };
+  }
+}
+export function setupCapacitorOnlineManager() {
+  const global = globalThis;
+  if (!global[kOnlineManager]) {
+    global[kOnlineManager] = new CapacitorOnlineManager();
+  }
+  return global[kOnlineManager];
+}
+setupCapacitorFocusManager();
+setupCapacitorOnlineManager();
 function parseSetCookieHeader(header) {
   const cookieMap = /* @__PURE__ */ new Map();
   const cookies = splitSetCookieHeader(header);
@@ -87,6 +157,26 @@ function getCookieString(storedCookies) {
   }
   return parts.join("; ");
 }
+function hasBetterAuthCookies(setCookieHeader, cookiePrefix) {
+  const cookies = parseSetCookieHeader(setCookieHeader);
+  const cookieSuffixes = ["session_token", "session_data"];
+  const prefixes = Array.isArray(cookiePrefix) ? cookiePrefix : [cookiePrefix];
+  for (const name of cookies.keys()) {
+    const nameWithoutSecure = name.startsWith("__Secure-") ? name.slice(9) : name;
+    for (const prefix of prefixes) {
+      if (prefix) {
+        if (nameWithoutSecure.startsWith(prefix))
+          return true;
+      } else {
+        for (const suffix of cookieSuffixes) {
+          if (nameWithoutSecure.endsWith(suffix))
+            return true;
+        }
+      }
+    }
+  }
+  return false;
+}
 function hasSessionCookieChanged(prevCookie, newCookie) {
   if (!prevCookie)
     return true;
@@ -114,6 +204,7 @@ function hasSessionCookieChanged(prevCookie, newCookie) {
 export function capacitorClient(opts) {
   let store = null;
   const storagePrefix = opts?.storagePrefix || "better-auth";
+  const cookiePrefix = opts?.cookiePrefix || "better-auth";
   const cookieName = `${storagePrefix}_cookie`;
   const sessionCacheName = `${storagePrefix}_session`;
   return {
@@ -170,13 +261,15 @@ export function capacitorClient(opts) {
             }
             const setCookie = context.response.headers.get("set-cookie");
             if (setCookie) {
-              const prevCookie = (await Preferences.get({ key: cookieName }))?.value;
-              const newCookie = mergeCookies(setCookie, prevCookie ?? void 0);
-              if (hasSessionCookieChanged(prevCookie ?? null, newCookie)) {
-                await Preferences.set({ key: cookieName, value: newCookie });
-                store?.notify("$sessionSignal");
-              } else {
-                await Preferences.set({ key: cookieName, value: newCookie });
+              if (hasBetterAuthCookies(setCookie, cookiePrefix)) {
+                const prevCookie = (await Preferences.get({ key: cookieName }))?.value;
+                const newCookie = mergeCookies(setCookie, prevCookie ?? void 0);
+                if (hasSessionCookieChanged(prevCookie ?? null, newCookie)) {
+                  await Preferences.set({ key: cookieName, value: newCookie });
+                  store?.notify("$sessionSignal");
+                } else {
+                  await Preferences.set({ key: cookieName, value: newCookie });
+                }
               }
             }
             if (context.request.url.toString().includes("/get-session")) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "abckit",
   "type": "module",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "private": false,
   "sideEffects": false,
   "exports": {
@@ -56,9 +56,12 @@
     "release": "pnpm publish --no-git-checks --access public"
   },
   "dependencies": {
+    "@capacitor/app": "^7.1.1",
     "@capacitor/core": "^7.0.1",
+    "@capacitor/network": "^7.0.3",
     "@capacitor/preferences": "^7.0.1",
     "@graphql-tools/utils": "^10.11.0",
+    "@ionic/vue": "^8.7.13",
     "@nuxt/icon": "^2.1.0",
     "@nuxtjs/color-mode": "^4.0.0",
     "@nuxtjs/i18n": "^10.2.1",

package/dist/runtime/middleware/auth.global.d.ts

@@ -1,8 +0,0 @@
-/**
- * Global auth middleware for Better Auth
- * - Redirects pending approval users to /auth/pending
- * - Redirects banned users to /auth/banned
- * Note: Route protection is handled by layouts, not this middleware
- */
-declare const _default: import("nuxt/app").RouteMiddleware;
-export default _default;

package/dist/runtime/middleware/auth.global.js

@@ -1,28 +0,0 @@
-import { defineNuxtRouteMiddleware, navigateTo } from "#app";
-import { useAuth } from "abckit/composables/useAuth";
-export default defineNuxtRouteMiddleware(async (to) => {
-  if (import.meta.server) {
-    return;
-  }
-  const { isAuthenticated, isLoading, user } = useAuth();
-  if (to.path.startsWith("/auth/") && to.path !== "/auth/pending" && to.path !== "/auth/banned") {
-    return;
-  }
-  if (isLoading.value) {
-    return;
-  }
-  if (isAuthenticated.value && user.value) {
-    const userData = user.value;
-    const isBanned = userData.banned === true;
-    const isPendingApproval = isBanned && userData.banReason === "pending approval";
-    if (isPendingApproval && to.path !== "/auth/pending") {
-      return navigateTo("/auth/pending");
-    }
-    if (isBanned && !isPendingApproval && to.path !== "/auth/banned") {
-      return navigateTo("/auth/banned");
-    }
-    if (!isBanned && (to.path === "/auth/pending" || to.path === "/auth/banned")) {
-      return navigateTo("/");
-    }
-  }
-});