@inzombieland/nuxt-common 1.16.23 → 1.16.25

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@inzombieland/nuxt-common",
-  "version": "1.16.23",
+  "version": "1.16.25",
   "configKey": "nuxt-common",
   "builder": {
     "@nuxt/module-builder": "0.6.0",

package/dist/module.mjs

@@ -2,7 +2,7 @@ import { fileURLToPath } from 'node:url';
 import { defineNuxtModule, createResolver, addServerHandler, addImportsDir, addPlugin, addComponent } from '@nuxt/kit';
 
 const name = "@inzombieland/nuxt-common";
-const version = "1.16.23";
+const version = "1.16.25";
 
 const module = defineNuxtModule({
   meta: {

package/dist/runtime/AppProvider.vue

@@ -1,52 +1,19 @@
 <script setup lang="ts">
 import { StyleProvider, Themes } from "@varlet/ui"
 import { useLocalStorage } from "@vueuse/core"
-import { useI18n, useLocalePath } from "#i18n"
 import { useNuxtApp } from "#imports"
 import { onMounted, ref, watch } from "vue"
-import { useRouter } from "vue-router"
-import { getVisitorId } from "./api"
-import { useActiveSessions } from "./composables/use-active-sessions"
-import { useUserActions } from "./composables/use-user-actions"
-import { useSubscribe, useUser } from "./packages/api"
+import { useUser } from "./packages/api"
 import bus from "./packages/api/bus"
 import type { ConfigProviderTheme } from "vant"
 import "@vant/touch-emulator"
 
 const theme = ref("")
 const appPreferencesTheme = useLocalStorage("app-preferences-theme", JSON.stringify({ value: "" }))
-const locale = useLocalStorage("app-preferences-locale", JSON.stringify({ value: "en" }))
 const user = useUser()
-const activeSessions = useActiveSessions()
-const { fetchActiveSessions, logout } = useUserActions()
-const localePath = useLocalePath()
-const router = useRouter()
 const appLoading = ref(Boolean(user.value))
-// @ts-ignore
-const { setLocale } = useI18n()
 const { $mobileApp } = useNuxtApp()
 
-useSubscribe("WS.SessionsUpdated", async (session: { status?: string; visitorId?: string; sessionId?: string }) => {
-	if (user.value && activeSessions.value.length > 0) {
-		activeSessions.value = [...activeSessions.value].map(activeSession => {
-			if (activeSession.id === session?.sessionId) {
-				activeSession.isOnline = session?.status === "Online"
-				activeSession.signedOut = session?.status === "SignedOut"
-				activeSession.dateTime = new Date()
-			}
-			return activeSession
-		})
-	}
-	if (user.value && session?.status === "SignedOut" && session?.visitorId === getVisitorId()) {
-		const data = await fetchActiveSessions()
-		const isCurrentSession = data.sessions.some((s: any) => s.isCurrentSession && s.id === session?.sessionId)
-		if (isCurrentSession) {
-			await logout()
-			await router.push({ path: localePath("/") })
-		}
-	}
-})
-
 onMounted(() => {
 	watch(
 		appPreferencesTheme,
@@ -82,20 +49,6 @@ onMounted(() => {
 		{ immediate: true }
 	)
 
-	watch(
-		locale,
-		locale => {
-			try {
-				const { value } = JSON.parse(locale)
-				setLocale(value)
-			} catch (error) {
-				console.error(`Error parsing app preferences locale:`, error)
-				setLocale("en")
-			}
-		},
-		{ immediate: true }
-	)
-
 	appLoading.value = false
 })
 

package/dist/runtime/api/index.d.ts

@@ -27,5 +27,8 @@ declare const fetch: Fetch, getUser: () => Promise<import("src/runtime/packages/
         key: string;
     }>;
     logout: () => Promise<void>;
+    fetchActiveSessions: () => Promise<{
+        sessions: import("src/runtime/packages/api/types").ActiveSession[];
+    }>;
 };
 export { fetch, getUser, useApiFetch, userActions };

package/dist/runtime/packages/api/composables/use-active-sessions.d.ts

@@ -0,0 +1,26 @@
+import type { ActiveSession } from "../types";
+export declare function useActiveSessions(): import("vue").Ref<{
+    id: string;
+    visitorId: string;
+    device: string;
+    appName: string;
+    location: string;
+    ipAddress: string;
+    isCurrentSession?: boolean | undefined;
+    isOnline?: boolean | undefined;
+    signedOut?: boolean | undefined;
+    dateTime: Date;
+    firstSignIn: Date;
+}[], ActiveSession[] | {
+    id: string;
+    visitorId: string;
+    device: string;
+    appName: string;
+    location: string;
+    ipAddress: string;
+    isCurrentSession?: boolean | undefined;
+    isOnline?: boolean | undefined;
+    signedOut?: boolean | undefined;
+    dateTime: Date;
+    firstSignIn: Date;
+}[]>;

package/dist/runtime/packages/api/composables/use-active-sessions.mjs

@@ -0,0 +1,14 @@
+import { ref } from "vue";
+import { useUserActions } from "../index.mjs";
+const activeSessions = ref([]);
+export function useActiveSessions() {
+  const userActions = useUserActions();
+  const fetchActiveSessions = async () => {
+    if (activeSessions.value.length === 0) {
+      const data = await userActions?.value.fetchActiveSessions();
+      activeSessions.value = data?.sessions ?? [];
+    }
+  };
+  fetchActiveSessions();
+  return activeSessions;
+}

package/dist/runtime/packages/api/index.d.ts

@@ -1,3 +1,4 @@
+import { type Ref } from "vue";
 import type { ActiveSession, Fetch, FetchConfig, User } from "./types";
 export type { ActiveSession, Fetch, FetchConfig, User };
 export { useUser } from "./composables/use-user";
@@ -16,5 +17,33 @@ export declare function initApiFetch($fetch: Fetch, config: FetchConfig): {
             key: string;
         }>;
         logout: () => Promise<void>;
+        fetchActiveSessions: () => Promise<{
+            sessions: ActiveSession[];
+        }>;
     };
 };
+export declare const useUserActions: () => Ref<{
+    signIn: (body: {
+        username: string;
+        password: string;
+        rememberMe: boolean;
+    }) => Promise<import("./types").GetUserResponse | {
+        key: string;
+    }>;
+    logout: () => Promise<void>;
+    fetchActiveSessions: () => Promise<{
+        sessions: ActiveSession[];
+    }>;
+}, {
+    signIn: (body: {
+        username: string;
+        password: string;
+        rememberMe: boolean;
+    }) => Promise<import("./types").GetUserResponse | {
+        key: string;
+    }>;
+    logout: () => Promise<void>;
+    fetchActiveSessions: () => Promise<{
+        sessions: ActiveSession[];
+    }>;
+}> | undefined;

package/dist/runtime/packages/api/index.mjs

@@ -1,28 +1,26 @@
-import { Locale as VarletLocale } from "@varlet/ui";
 import { useLocalStorage } from "@vueuse/core";
-import { setNotifyDefaultOptions, Locale as VantLocale } from "vant";
-import enUS from "vant/es/locale/lang/en-US";
-import ruRU from "vant/es/locale/lang/ru-RU";
-import { watch } from "vue";
+import { ref } from "vue";
 import { createApiFetch } from "./api-client.mjs";
 import bus from "./bus.mjs";
 import { newCometClient } from "./comet-client.mjs";
 import { useApiActions } from "./composables/use-api-actions.mjs";
 import { createApiGetUser } from "./get-user.mjs";
 import { createApiGetVisitorIdentifier } from "./get-visitor.mjs";
+import { createInitApplication } from "./init-application.mjs";
 import { createApiRefreshToken } from "./refresh-token.mjs";
 import { createApiUserActions } from "./user-actions.mjs";
 export { useUser } from "./composables/use-user.mjs";
 export { useSubscribe } from "./composables/use-subscribe.mjs";
 export { getVisitor, getVisitorId } from "./get-visitor.mjs";
 const apiActions = useApiActions();
+let userActions;
 export function initApiFetch($fetch, config) {
   const fetch = createApiFetch($fetch, config);
   const getUser = createApiGetUser(fetch, config);
   const getVisitorIdentifier = createApiGetVisitorIdentifier(config);
+  const initApplication = createInitApplication();
   const refreshToken = createApiRefreshToken(fetch, config);
-  const useApiFetch = () => fetch;
-  const userActions = createApiUserActions(fetch, config, getUser);
+  userActions = ref(createApiUserActions(fetch, config, getUser));
   apiActions.value = {
     initialized: true,
     getVisitorIdentifier,
@@ -30,8 +28,6 @@ export function initApiFetch($fetch, config) {
   };
   if (typeof window !== "undefined") {
     const loggedIn = useLocalStorage("lin", "no");
-    const theme = useLocalStorage("app-preferences-theme", JSON.stringify({ value: "" }));
-    const locale = useLocalStorage("app-preferences-locale", JSON.stringify({ value: "en" }));
     const cometServerURL = config.cometServerURL;
     let cometClient;
     bus.subscribe("user:onUpdated", (user) => {
@@ -46,48 +42,15 @@ export function initApiFetch($fetch, config) {
         cometClient.isStarted = false;
       }
       loggedIn.value = user ? "yes" : "no";
-      try {
-        const { value } = JSON.parse(theme.value);
-        if (user && user.theme !== value) {
-          theme.value = JSON.stringify({ value: user.theme });
-        }
-      } catch (error) {
-        console.error(`Error parsing app preferences theme:`, error);
-      }
-      try {
-        const { value } = JSON.parse(locale.value);
-        if (user && user.locale !== value) {
-          locale.value = JSON.stringify({ value: user.locale });
-        }
-      } catch (error) {
-        console.error(`Error parsing app preferences locale:`, error);
-      }
     });
-    watch(
-      locale,
-      (locale2) => {
-        try {
-          const { value } = JSON.parse(locale2);
-          if (value === "en") {
-            VantLocale.use(locale2, enUS);
-            VarletLocale.add("en-US", VarletLocale.enUS);
-          }
-          if (value === "ru") {
-            VantLocale.use(locale2, ruRU);
-            VarletLocale.add("en-US", VarletLocale.enUS);
-          }
-        } catch (error) {
-          console.error(`Error parsing app preferences locale:`, error);
-          VantLocale.use(locale2, enUS);
-          VarletLocale.add("en-US", VarletLocale.enUS);
-        }
-      },
-      { immediate: true }
-    );
-    setNotifyDefaultOptions({ position: "bottom" });
     bus.subscribe("app:beforeMount", () => {
       getVisitorIdentifier();
+      initApplication();
     });
   }
-  return { fetch, getUser, useApiFetch, userActions };
+  const useApiFetch = () => fetch;
+  return { fetch, getUser, useApiFetch, userActions: userActions.value };
 }
+export const useUserActions = () => {
+  return userActions;
+};

package/dist/runtime/packages/api/init-application.d.ts

@@ -0,0 +1 @@
+export declare const createInitApplication: () => () => void;

package/dist/runtime/packages/api/init-application.mjs

@@ -0,0 +1,94 @@
+import { Locale as VarletLocale } from "@varlet/ui";
+import { useLocalStorage } from "@vueuse/core";
+import { setNotifyDefaultOptions, Locale as VantLocale } from "vant";
+import enUS from "vant/es/locale/lang/en-US";
+import ruRU from "vant/es/locale/lang/ru-RU";
+import { watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { useRouter } from "vue-router";
+import { useActiveSessions } from "./composables/use-active-sessions.mjs";
+import { useSubscribe } from "./composables/use-subscribe.mjs";
+import { useUser } from "./composables/use-user.mjs";
+import { once } from "./helpers/index.mjs";
+import { getVisitorId, useUserActions } from "./index.mjs";
+function initApplication() {
+  const user = useUser();
+  const theme = useLocalStorage("app-preferences-theme", JSON.stringify({ value: "" }));
+  const locale = useLocalStorage("app-preferences-locale", JSON.stringify({ value: "en" }));
+  const i18n = useI18n();
+  watch(
+    user,
+    (user2) => {
+      try {
+        const { value } = JSON.parse(theme.value);
+        if (user2 && user2.theme !== value) {
+          theme.value = JSON.stringify({ value: user2.theme });
+        }
+      } catch (error) {
+        console.error(`Error parsing app preferences theme:`, error);
+      }
+      try {
+        const { value } = JSON.parse(locale.value);
+        if (user2 && user2.locale !== value) {
+          locale.value = JSON.stringify({ value: user2.locale });
+        }
+      } catch (error) {
+        console.error(`Error parsing app preferences locale:`, error);
+      }
+    },
+    { immediate: true }
+  );
+  watch(
+    locale,
+    (locale2) => {
+      try {
+        const { value } = JSON.parse(locale2);
+        if ("setLocale" in i18n && typeof i18n.setLocale === "function") {
+          i18n.setLocale(value);
+        }
+        if (value === "en") {
+          VantLocale.use(locale2, enUS);
+          VarletLocale.add("en-US", VarletLocale.enUS);
+        }
+        if (value === "ru") {
+          VantLocale.use(locale2, ruRU);
+          VarletLocale.add("en-US", VarletLocale.enUS);
+        }
+      } catch (error) {
+        console.error(`Error parsing app preferences locale:`, error);
+      }
+    },
+    { immediate: true }
+  );
+  setNotifyDefaultOptions({ position: "bottom" });
+  useSubscribe("WS.SessionsUpdated", async (session) => {
+    const user2 = useUser();
+    if (!user2.value) {
+      return;
+    }
+    const activeSessions = useActiveSessions();
+    if (activeSessions.value.length > 0) {
+      activeSessions.value = [...activeSessions.value].map((activeSession) => {
+        if (activeSession.id === session?.sessionId) {
+          activeSession.isOnline = session?.status === "Online";
+          activeSession.signedOut = session?.status === "SignedOut";
+          activeSession.dateTime = /* @__PURE__ */ new Date();
+        }
+        return activeSession;
+      });
+    }
+    if (session?.status === "SignedOut" && session?.visitorId === getVisitorId()) {
+      const userActions = useUserActions();
+      const data = await userActions?.value.fetchActiveSessions();
+      const isCurrentSession = data?.sessions.some((s) => s.isCurrentSession && s.id === session?.sessionId);
+      if (isCurrentSession) {
+        await userActions?.value.logout();
+        const router = useRouter();
+        await router.push({ path: "/" });
+      }
+    }
+  });
+}
+export const createInitApplication = once(() => {
+  return () => initApplication();
+});

package/dist/runtime/packages/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inzombieland/api",
-  "version": "1.16.23",
+  "version": "1.16.25",
   "type": "module",
   "license": "ISC",
   "main": "./index.mjs",
@@ -17,7 +17,6 @@
     "ofetch": "^1.4.1",
     "rxjs": "^7.8.2",
     "vant": "^4.9.19",
-    "vue": "^3.5.13",
     "zod": "^3.24.2"
   }
 }

package/dist/runtime/packages/api/user-actions.d.ts

@@ -1,4 +1,5 @@
-import type { Fetch, FetchConfig, GetUserResponse } from "./types";
+import type { ActiveSession, Fetch, FetchConfig, GetUserResponse } from "./types";
+export type UserActions = ReturnType<typeof createApiUserActions>;
 export declare const createApiUserActions: (fetch: Fetch, config: FetchConfig, getUser: () => Promise<GetUserResponse>) => {
     signIn: (body: {
         username: string;
@@ -8,4 +9,7 @@ export declare const createApiUserActions: (fetch: Fetch, config: FetchConfig, g
         key: string;
     }>;
     logout: () => Promise<void>;
+    fetchActiveSessions: () => Promise<{
+        sessions: ActiveSession[];
+    }>;
 };

package/dist/runtime/packages/api/user-actions.mjs

@@ -29,6 +29,9 @@ export const createApiUserActions = once(
         } finally {
           flush();
         }
+      },
+      fetchActiveSessions: async () => {
+        return await fetch("/account/1/sessions");
       }
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inzombieland/nuxt-common",
-  "version": "1.16.23",
+  "version": "1.16.25",
   "license": "ISC",
   "type": "module",
   "exports": {