@inzombieland/core 1.18.14 → 1.18.16

package/api-client.mjs

@@ -109,6 +109,10 @@ const optionsHandler = (options = {}, config) => {
 };
 const fetchRequest = (url, options = {}, fetch, config) => {
   const request = async () => {
+    const apiActions = useApiActions();
+    if (typeof window !== "undefined") {
+      await apiActions.value?.getVisitorIdentifier?.();
+    }
     const opts = optionsHandler(options, config);
     try {
       const response = await fetch.raw(url, opts);
@@ -116,7 +120,6 @@ const fetchRequest = (url, options = {}, fetch, config) => {
     } catch (error) {
       const { status } = error?.response ?? { status: 500 };
       if (status === 401 && url !== "/account/1/offline") {
-        const apiActions = useApiActions();
         await apiActions.value?.refreshToken?.();
         return request();
       }

package/composables/index.d.ts

@@ -2,6 +2,7 @@ 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/composables/index.mjs

@@ -2,6 +2,7 @@ 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/composables/use-api-actions.d.ts

@@ -1,13 +1,10 @@
 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/composables/use-api-actions.mjs

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

package/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/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/get-user.mjs

@@ -16,7 +16,6 @@ async function getUserRequest(fetch, config) {
     }
     try {
       const apiActions = useApiActions();
-      await apiActions.value?.getVisitorIdentifier?.();
       await apiActions.value?.refreshToken?.();
     } catch {
       flush();

package/get-visitor.mjs

@@ -8,7 +8,7 @@ const setVisitor = (newVisitor) => {
 };
 const getVisitorRequest = async (config) => {
   const visitor = useVisitor();
-  if (typeof window === "undefined" || visitor.value) {
+  if (visitor.value) {
     return;
   }
   const fp = await load();

package/index.mjs

@@ -22,11 +22,7 @@ export function initApiFetch($fetch, config) {
   const initApplication = createInitApplication();
   const refreshToken = createApiRefreshToken(fetch, config);
   userActions = ref(createApiUserActions(fetch, config, getUser));
-  apiActions.value = {
-    initialized: true,
-    getVisitorIdentifier,
-    refreshToken
-  };
+  apiActions.value = { getVisitorIdentifier, refreshToken };
   if (typeof window !== "undefined") {
     const loggedIn = useLocalStorage("lin", "no");
     const cometServerURL = config.cometServerURL;
@@ -45,7 +41,8 @@ export function initApiFetch($fetch, config) {
       }
       loggedIn.value = user ? "yes" : "no";
     });
-    bus.subscribe("app:beforeMount", () => {
+    const subscription = bus.subscribe("app:beforeMount", () => {
+      subscription.unsubscribe();
       console.log("Service started in mode", import.meta.env.MODE);
       getVisitorIdentifier();
       initApplication();

package/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inzombieland/core",
-  "version": "1.18.14",
+  "version": "1.18.16",
   "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"