@inzombieland/nuxt-common 1.18.13 → 1.18.15

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@inzombieland/nuxt-common",
-  "version": "1.18.13",
+  "version": "1.18.15",
   "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.18.13";
+const version = "1.18.15";
 
 const module = defineNuxtModule({
   meta: {

package/dist/runtime/packages/core/AppProvider.vue

@@ -1,6 +1,6 @@
 <script setup lang="ts">
-import { onMounted, ref } from "vue"
-import { bus } from "./api-client"
+import { onBeforeMount, onMounted, ref } from "vue"
+import bus from "./bus"
 import { useThemeMode, useUser } from "./index"
 import type { ConfigProviderTheme } from "vant"
 import "@vant/touch-emulator"
@@ -9,12 +9,18 @@ const theme = useThemeMode()
 const user = useUser()
 const appLoading = ref(Boolean(user.value))
 
+onBeforeMount(() => {
+	bus.publish("app:beforeMount", true)
+})
+
 onMounted(() => {
 	appLoading.value = false
 })
+</script>
 
-if (typeof window !== "undefined") {
-	bus.publish("app:mounted", true)
+<script lang="ts">
+export const useBus = () => {
+	return bus
 }
 </script>
 

package/dist/runtime/packages/core/api-client.d.ts

@@ -1,6 +1,4 @@
-import bus from "./bus";
 import type { Fetch, FetchConfig, FetchExtraOptions as FetchOptions, User } from "./types";
-export { bus };
 export declare const setUser: (newUser?: User | null) => void;
 export declare const updateUser: (newUser: Partial<User>) => void;
 export declare const getToken: () => string | null | undefined;

package/dist/runtime/packages/core/api-client.mjs

@@ -1,12 +1,11 @@
-import bus from "./bus.mjs";
-import { useUser, useVisitor } from "./composables/index.mjs";
+import { useApiActions, useUser, useVisitor } from "./composables/index.mjs";
 import { apiHelper, once } from "./helpers/index.mjs";
-import { useApiActions } from "./index.mjs";
-export { bus };
+import { useBus } from "./index.mjs";
 let token = null;
 export const setUser = (newUser) => {
   const user = useUser();
   user.value = newUser;
+  const bus = useBus();
   bus.publish("user:onUpdated", user.value);
 };
 export const updateUser = (newUser) => {
@@ -27,6 +26,7 @@ export const flush = () => {
 };
 const eventHandler = (requestID, eventName) => {
   return new Promise((resolve, reject) => {
+    const bus = useBus();
     const subscription = bus.subscribe(eventName, (data) => {
       if (requestID !== data?.requestID) {
         return;
@@ -117,7 +117,7 @@ const fetchRequest = (url, options = {}, fetch, config) => {
       const { status } = error?.response ?? { status: 500 };
       if (status === 401 && url !== "/account/1/offline") {
         const apiActions = useApiActions();
-        await apiActions?.value?.refreshToken?.();
+        await apiActions.value?.refreshToken?.();
         return request();
       }
       throw errorHandler(error);

package/dist/runtime/packages/core/comet-client.mjs

@@ -1,9 +1,11 @@
 import { Centrifuge } from "centrifuge";
-import { bus, getToken } from "./api-client.mjs";
+import { getToken } from "./api-client.mjs";
+import { useApiActions } from "./composables/index.mjs";
 import { apiHelper } from "./helpers/index.mjs";
-import { useApiActions } from "./index.mjs";
+import { useBus } from "./index.mjs";
 if (typeof window !== "undefined" && import.meta.env.MODE !== "production") {
   window.wsPublish = (eventName, data) => {
+    const bus = useBus();
     setTimeout(() => bus.publish(`WS.${eventName}`, data), 0);
   };
 }
@@ -27,10 +29,11 @@ export function newCometClient(user, cometServerURL) {
     debug: import.meta.env.MODE !== "production",
     getToken: async () => {
       const apiActions = useApiActions();
-      return await apiActions?.value?.refreshToken?.() ?? "";
+      return await apiActions.value?.refreshToken?.() ?? "";
     }
   });
   const publish = (eventName, data) => () => {
+    const bus = useBus();
     bus.publish(`WS.${eventName}`, apiHelper.convertToClient(data));
   };
   let userSubscription;

package/dist/runtime/packages/core/composables/index.d.ts

@@ -1,6 +1,8 @@
 export * from "../helpers/composables";
 export { useActiveSessions } from "./use-active-sessions";
+export { useApiActions } from "./use-api-actions";
 export { useAppLocale } from "./use-app-locale";
+export { useCookies } from "./use-cookies";
 export { useSubscribe } from "./use-subscribe";
 export { useThemeMode } from "./use-theme-mode";
 export { useUser } from "./use-user";

package/dist/runtime/packages/core/composables/index.mjs

@@ -1,6 +1,8 @@
 export * from "../helpers/composables.mjs";
 export { useActiveSessions } from "./use-active-sessions.mjs";
+export { useApiActions } from "./use-api-actions.mjs";
 export { useAppLocale } from "./use-app-locale.mjs";
+export { useCookies } from "./use-cookies.mjs";
 export { useSubscribe } from "./use-subscribe.mjs";
 export { useThemeMode } from "./use-theme-mode.mjs";
 export { useUser } from "./use-user.mjs";

package/dist/runtime/packages/core/composables/use-api-actions.d.ts

@@ -0,0 +1,13 @@
+export declare const useApiActions: () => import("vue").Ref<{
+    initialized: boolean;
+    getVisitorIdentifier?: (() => Promise<void>) | undefined;
+    refreshToken?: (() => Promise<string>) | undefined;
+}, {
+    initialized: boolean;
+    getVisitorIdentifier?: () => Promise<void>;
+    refreshToken?: () => Promise<string>;
+} | {
+    initialized: boolean;
+    getVisitorIdentifier?: (() => Promise<void>) | undefined;
+    refreshToken?: (() => Promise<string>) | undefined;
+}>;

package/dist/runtime/packages/core/composables/use-api-actions.mjs

@@ -0,0 +1,5 @@
+import { ref } from "vue";
+const apiActions = ref({ initialized: false });
+export const useApiActions = () => {
+  return apiActions;
+};

package/dist/runtime/packages/core/composables/use-cookies.d.ts

@@ -0,0 +1,27 @@
+import { type CookieParseOptions, type CookieSerializeOptions } from "cookie-es";
+import { type Ref } from "vue";
+declare global {
+    interface Window {
+        cookieStore?: {
+            addEventListener: (type: "change", listener: (event: any) => void) => void;
+            removeEventListener: (type: "change", listener: (event: any) => void) => void;
+        };
+    }
+}
+type _CookieOptions = Omit<CookieSerializeOptions & CookieParseOptions, "decode" | "encode">;
+export interface CookieOptions<T = any> extends _CookieOptions {
+    decode?: (value: string) => T;
+    encode?: (value: T) => string;
+    default?: () => T | Ref<T>;
+    watch?: boolean | "shallow";
+    readonly?: boolean;
+}
+export interface CookieRef<T> extends Ref<T> {
+}
+export declare function useCookies<T = string | null | undefined>(name: string, _opts?: CookieOptions<T> & {
+    readonly?: false;
+}): CookieRef<T>;
+export declare function useCookies<T = string | null | undefined>(name: string, _opts: CookieOptions<T> & {
+    readonly: true;
+}): Readonly<CookieRef<T>>;
+export {};

package/dist/runtime/packages/core/composables/use-cookies.mjs

@@ -0,0 +1,152 @@
+import { parse, serialize } from "cookie-es";
+import destr from "destr";
+import { klona } from "klona";
+import { isEqual } from "ohash";
+import { customRef, getCurrentScope, nextTick, onScopeDispose, ref, watch } from "vue";
+const CookieDefaults = {
+  path: "/",
+  watch: true,
+  decode: (val) => destr(decodeURIComponent(val)),
+  encode: (val) => encodeURIComponent(typeof val === "string" ? val : JSON.stringify(val))
+};
+const store = typeof window !== "undefined" ? window.cookieStore : void 0;
+export function useCookies(name, _opts) {
+  const opts = { ...CookieDefaults, ..._opts };
+  opts.filter ??= (key) => key === name;
+  const cookies = readRawCookies(opts) || {};
+  let delay;
+  if (opts.maxAge !== void 0) {
+    delay = opts.maxAge * 1e3;
+  } else if (opts.expires) {
+    delay = opts.expires.getTime() - Date.now();
+  }
+  const hasExpired = delay !== void 0 && delay <= 0;
+  const shouldSetInitialClientCookie = hasExpired || cookies[name] === void 0 || cookies[name] === null;
+  const cookieValue = klona(hasExpired ? void 0 : cookies[name] ?? opts.default?.());
+  const cookie = delay && !hasExpired ? cookieRef(cookieValue, delay, opts.watch && opts.watch !== "shallow") : ref(cookieValue);
+  if (import.meta.env.MODE !== "production" && hasExpired) {
+    console.warn(`not setting cookie \`${name}\` as it has already expired.`);
+  }
+  let channel = null;
+  try {
+    if (!store && typeof BroadcastChannel !== "undefined") {
+      channel = new BroadcastChannel(`app:cookies:${name}`);
+    }
+  } catch {
+  }
+  const callback = (force = false) => {
+    if (!force && (opts.readonly || isEqual(cookie.value, cookies[name]))) {
+      return;
+    }
+    writeClientCookie(name, cookie.value, opts);
+    cookies[name] = klona(cookie.value);
+    channel?.postMessage({ value: opts.encode(cookie.value) });
+  };
+  const handleChange = (data) => {
+    const value = data.refresh ? readRawCookies(opts)?.[name] : opts.decode(data.value);
+    watchPaused = true;
+    cookie.value = value;
+    cookies[name] = klona(value);
+    nextTick(() => {
+      watchPaused = false;
+    });
+  };
+  let watchPaused = false;
+  const hasScope = !!getCurrentScope();
+  if (hasScope) {
+    onScopeDispose(() => {
+      watchPaused = true;
+      callback();
+      channel?.close();
+    });
+  }
+  if (store) {
+    const changeHandler = (event) => {
+      const changedCookie = event.changed.find((c) => c.name === name);
+      const removedCookie = event.deleted.find((c) => c.name === name);
+      if (changedCookie) {
+        handleChange({ value: changedCookie.value });
+      }
+      if (removedCookie) {
+        handleChange({ value: null });
+      }
+    };
+    store.addEventListener("change", changeHandler);
+    if (hasScope) {
+      onScopeDispose(() => store.removeEventListener("change", changeHandler));
+    }
+  } else if (channel) {
+    channel.onmessage = ({ data }) => handleChange(data);
+  }
+  if (opts.watch) {
+    watch(
+      cookie,
+      () => {
+        if (watchPaused) {
+          return;
+        }
+        callback();
+      },
+      { deep: opts.watch !== "shallow" }
+    );
+  }
+  if (shouldSetInitialClientCookie) {
+    callback(shouldSetInitialClientCookie);
+  }
+  return cookie;
+}
+function readRawCookies(opts = {}) {
+  return parse(document.cookie, opts);
+}
+function serializeCookie(name, value, opts = {}) {
+  if (value === null || value === void 0) {
+    return serialize(name, value, { ...opts, maxAge: -1 });
+  }
+  return serialize(name, value, opts);
+}
+function writeClientCookie(name, value, opts = {}) {
+  document.cookie = serializeCookie(name, value, opts);
+}
+const MAX_TIMEOUT_DELAY = 2147483647;
+function cookieRef(value, delay, shouldWatch) {
+  let timeout;
+  let unsubscribe;
+  let elapsed = 0;
+  const internalRef = shouldWatch ? ref(value) : { value };
+  if (getCurrentScope()) {
+    onScopeDispose(() => {
+      unsubscribe?.();
+      clearTimeout(timeout);
+    });
+  }
+  return customRef((track, trigger) => {
+    if (shouldWatch) {
+      unsubscribe = watch(internalRef, trigger);
+    }
+    function createExpirationTimeout() {
+      elapsed = 0;
+      clearTimeout(timeout);
+      const timeRemaining = delay - elapsed;
+      const timeoutLength = Math.min(timeRemaining, MAX_TIMEOUT_DELAY);
+      timeout = setTimeout(() => {
+        elapsed += timeoutLength;
+        if (elapsed < delay) {
+          return createExpirationTimeout();
+        }
+        internalRef.value = void 0;
+        trigger();
+      }, timeoutLength);
+    }
+    return {
+      get() {
+        track();
+        return internalRef.value;
+      },
+      set(newValue) {
+        createExpirationTimeout();
+        internalRef.value = newValue;
+        trigger();
+      }
+    };
+  });
+}

package/dist/runtime/packages/core/composables/use-subscribe.d.ts

@@ -1,4 +1,4 @@
-import { type Subscription } from "../bus";
+import type { Subscription } from "rxjs";
 export declare const useSubscribe: <T>(eventName: string, func: (data: T) => void, options?: {
     once?: boolean;
     unsubscribeOnUnmount?: boolean;

package/dist/runtime/packages/core/composables/use-subscribe.mjs

@@ -1,6 +1,7 @@
 import { onMounted, onUnmounted } from "vue";
-import bus from "../bus.mjs";
+import { useBus } from "../index.mjs";
 export const useSubscribe = (eventName, func, options = { once: false, unsubscribeOnUnmount: true }) => {
+  const bus = useBus();
   let subscription;
   onMounted(() => {
     subscription = bus.subscribe(eventName, (data) => {

package/dist/runtime/packages/core/get-user.mjs

@@ -1,8 +1,7 @@
 import { useLocalStorage } from "@vueuse/core";
 import { flush, getToken, setUser } from "./api-client.mjs";
-import { useUser } from "./composables/index.mjs";
+import { useApiActions, useUser } from "./composables/index.mjs";
 import { createSingletonAsync, once } from "./helpers/index.mjs";
-import { useApiActions } from "./index.mjs";
 async function getUserRequest(fetch, config) {
   const token = getToken();
   const user = useUser();
@@ -17,8 +16,8 @@ async function getUserRequest(fetch, config) {
     }
     try {
       const apiActions = useApiActions();
-      await apiActions?.value?.getVisitorIdentifier?.();
-      await apiActions?.value?.refreshToken?.();
+      await apiActions.value?.getVisitorIdentifier?.();
+      await apiActions.value?.refreshToken?.();
     } catch {
       flush();
       return { token: null, user: null };

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

@@ -1,13 +1,9 @@
 import { type Ref } from "vue";
 import type { Fetch, FetchConfig } from "./types";
 export { defineVuePlugins } from "./define-vue-plugins";
-export { default as AppProvider } from "./AppProvider.vue";
+export { default as AppProvider, useBus } from "./AppProvider.vue";
 export * from "./composables";
 export * from "./types";
-type ApiActions = {
-    getVisitorIdentifier?: () => Promise<void>;
-    refreshToken?: () => Promise<string>;
-};
 export declare function initApiFetch($fetch: Fetch, config: FetchConfig): {
     fetch: Fetch;
     getUser: () => Promise<import("./types").GetUserResponse>;
@@ -69,4 +65,3 @@ export declare const useUserActions: () => Ref<{
         locale: string;
     }) => Promise<void>;
 }> | undefined;
-export declare const useApiActions: () => Ref<ApiActions, ApiActions> | undefined;

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

@@ -1,18 +1,20 @@
 import { useLocalStorage } from "@vueuse/core";
 import { ref } from "vue";
-import { bus, createApiFetch } from "./api-client.mjs";
+import { createApiFetch } from "./api-client.mjs";
+import { useBus } from "./AppProvider.vue";
 import { newCometClient } from "./comet-client.mjs";
+import { useApiActions } from "./composables/index.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 { defineVuePlugins } from "./define-vue-plugins.mjs";
-export { default as AppProvider } from "./AppProvider.vue";
+export { default as AppProvider, useBus } from "./AppProvider.vue";
 export * from "./composables/index.mjs";
 export * from "./types.mjs";
+const apiActions = useApiActions();
 let userActions;
-let apiActions;
 export function initApiFetch($fetch, config) {
   const fetch = createApiFetch($fetch, config);
   const getUser = createApiGetUser(fetch, config);
@@ -20,11 +22,16 @@ export function initApiFetch($fetch, config) {
   const initApplication = createInitApplication();
   const refreshToken = createApiRefreshToken(fetch, config);
   userActions = ref(createApiUserActions(fetch, config, getUser));
-  apiActions = ref({ getVisitorIdentifier, refreshToken });
+  apiActions.value = {
+    initialized: true,
+    getVisitorIdentifier,
+    refreshToken
+  };
   if (typeof window !== "undefined") {
     const loggedIn = useLocalStorage("lin", "no");
     const cometServerURL = config.cometServerURL;
     let cometClient;
+    const bus = useBus();
     bus.subscribe("user:onUpdated", (user) => {
       if (user) {
         cometClient || (cometClient = newCometClient(user, cometServerURL));
@@ -38,7 +45,8 @@ export function initApiFetch($fetch, config) {
       }
       loggedIn.value = user ? "yes" : "no";
     });
-    bus.subscribe("app:mounted", () => {
+    bus.subscribe("app:beforeMount", () => {
+      console.log("Service started in mode", import.meta.env.MODE);
       getVisitorIdentifier();
       initApplication();
     });
@@ -49,6 +57,3 @@ export function initApiFetch($fetch, config) {
 export const useUserActions = () => {
   return userActions;
 };
-export const useApiActions = () => {
-  return apiActions;
-};

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

@@ -5,7 +5,7 @@ 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, useSubscribe, useUser } from "./composables/index.mjs";
+import { useActiveSessions, useCookies, useSubscribe, useUser } from "./composables/index.mjs";
 import { once } from "./helpers/index.mjs";
 import { useAppLocale, useThemeMode, useUserActions, useVisitor } from "./index.mjs";
 function initApplication() {
@@ -62,6 +62,8 @@ function initApplication() {
         VantLocale.use(locale2, ruRU);
         VarletLocale.add("en-US", VarletLocale.enUS);
       }
+      const localeCookie = useCookies("locale", { maxAge: 60 * 60 * 24 * 365 });
+      localeCookie.value = locale2?.value;
     },
     { immediate: true }
   );

package/dist/runtime/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inzombieland/core",
-  "version": "1.18.13",
+  "version": "1.18.15",
   "type": "module",
   "license": "ISC",
   "main": "./index.mjs",
@@ -14,7 +14,11 @@
     "@varlet/ui": "^3.10.5",
     "@vueuse/core": "^12.8.2",
     "centrifuge": "^5.3.4",
+    "cookie-es": "^2.0.0",
+    "destr": "^2.0.5",
+    "klona": "^2.0.6",
     "ofetch": "^1.4.1",
+    "ohash": "^2.0.11",
     "rxjs": "^7.8.2",
     "vant": "^4.9.19",
     "zod": "^3.24.2"

package/dist/runtime/plugin.mjs

@@ -1,9 +1,9 @@
 import { addRouteMiddleware, defineNuxtPlugin } from "#app";
-import { useCookie, useNuxtApp, useRequestHeaders, useRuntimeConfig, useState } from "#imports";
+import { useNuxtApp, useRequestHeaders, useRuntimeConfig, useState } from "#imports";
 import { watch } from "vue";
 import { fetch, getUser } from "./api/index.mjs";
 import { authMiddleware, guestMiddleware, localeMiddleware } from "./middleware/index.mjs";
-import { defineVuePlugins, useAppLocale, useThemeMode } from "./packages/core/index.mjs";
+import { defineVuePlugins, useThemeMode } from "./packages/core/index.mjs";
 import { flush, setToken, setUser } from "./packages/core/api-client.mjs";
 const useAuth = () => {
   return useState("auth", () => null);
@@ -14,7 +14,6 @@ export default defineNuxtPlugin(async (nuxtApp) => {
   const runtimeConfig = useRuntimeConfig();
   const { $mobileApp } = useNuxtApp();
   const theme = useThemeMode();
-  const locale = useAppLocale();
   if (runtimeConfig.public.ssr && import.meta.server || !runtimeConfig.public.ssr) {
     flush();
     if (import.meta.server) {
@@ -41,14 +40,6 @@ export default defineNuxtPlugin(async (nuxtApp) => {
       },
       { immediate: true }
     );
-    watch(
-      locale,
-      (locale2) => {
-        const localeCookie = useCookie("locale", { maxAge: 60 * 60 * 24 * 365 });
-        localeCookie.value = locale2?.value;
-      },
-      { immediate: true }
-    );
   });
   addRouteMiddleware("auth", authMiddleware, { global: false });
   addRouteMiddleware("guest", guestMiddleware, { global: false });

package/package.json

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