@inzombieland/nuxt-common 0.0.3 → 0.0.8

package/runtime/composables/use-api-fetch.mjs

@@ -0,0 +1,3 @@
+import { useApiFetch } from "../api/index.mjs";
+export { useApiFetch };
+export default useApiFetch;

package/runtime/composables/use-helpers.d.ts

@@ -0,0 +1,16 @@
+import { once } from "../packages/helpers";
+export declare const useHelpers: () => {
+    once: typeof once;
+    dateHelper: {
+        stringToDate: typeof import("src/runtime/packages/api/helpers/date-helper").stringToDate;
+        dateFormat: typeof import("src/runtime/packages/api/helpers/date-helper").dateFormat;
+    };
+    phoneHelper: {
+        getPlainPhoneNumber: typeof import("@inzombieland/helpers/phone-helper").getPlainPhoneNumber;
+        convertToPhone: typeof import("@inzombieland/helpers/phone-helper").convertToPhone;
+        maskPhone: typeof import("@inzombieland/helpers/phone-helper").maskPhone;
+    };
+    stringHelper: {
+        maskEmail: typeof import("@inzombieland/helpers/string-helper").maskEmail;
+    };
+};

package/runtime/composables/use-helpers.mjs

@@ -0,0 +1,10 @@
+import { dateHelper } from "../packages/api/helpers/index.mjs";
+import { once, phoneHelper, stringHelper } from "../packages/helpers/index.mjs";
+export const useHelpers = () => {
+  return {
+    once,
+    dateHelper,
+    phoneHelper,
+    stringHelper
+  };
+};

package/runtime/composables/use-layer-manager.d.ts

@@ -0,0 +1,3 @@
+import { useLayerManager } from "../packages/layer-manager";
+export { useLayerManager };
+export default useLayerManager;

package/runtime/composables/use-layer-manager.mjs

@@ -0,0 +1,3 @@
+import { useLayerManager } from "../packages/layer-manager/index.mjs";
+export { useLayerManager };
+export default useLayerManager;

package/runtime/composables/use-subscribe.d.ts

@@ -0,0 +1,10 @@
+import { type Subscription } from "../packages/api/bus";
+export declare const useSubscribe: <T>(eventName: string, func: (data: T) => void, options?: {
+    once?: boolean;
+    unsubscribeOnUnmount?: boolean;
+}) => Subscription | undefined;
+declare const _default: <T>(eventName: string, func: (data: T) => void, options?: {
+    once?: boolean;
+    unsubscribeOnUnmount?: boolean;
+}) => Subscription | undefined;
+export default _default;

package/runtime/composables/use-subscribe.mjs

@@ -0,0 +1,22 @@
+import { onMounted, onUnmounted } from "vue";
+import bus from "../packages/api/bus.mjs";
+export const useSubscribe = (eventName, func, options = { once: false, unsubscribeOnUnmount: true }) => {
+  let subscription;
+  onMounted(() => {
+    subscription = bus.subscribe(eventName, (data) => {
+      func(data);
+      if (options.once) {
+        subscription?.unsubscribe();
+      }
+    });
+  });
+  onUnmounted(() => {
+    if (options.unsubscribeOnUnmount) {
+      subscription?.unsubscribe();
+    }
+  });
+  return subscription;
+};
+export default (eventName, func, options) => {
+  return useSubscribe(eventName, func, options);
+};

package/runtime/composables/use-toggle-sidebar.d.ts

@@ -0,0 +1,3 @@
+export declare const useToggleSidebar: () => import("vue").Ref<(() => string) | undefined, (() => string) | undefined>;
+declare const _default: () => () => string | undefined;
+export default _default;

package/runtime/composables/use-toggle-sidebar.mjs

@@ -0,0 +1,8 @@
+import { useState } from "#imports";
+export const useToggleSidebar = () => {
+  return useState("toggleSidebar", () => void 0);
+};
+export default () => {
+  const toggleSidebar = useToggleSidebar();
+  return () => toggleSidebar.value?.();
+};

package/runtime/composables/use-user-actions.d.ts

@@ -0,0 +1,2 @@
+import * as userActions from "../api/user-actions";
+export declare const useUserActions: () => typeof userActions;

package/runtime/composables/use-user-actions.mjs

@@ -0,0 +1,4 @@
+import * as userActions from "../api/user-actions.mjs";
+export const useUserActions = () => {
+  return userActions;
+};

package/runtime/composables/use-user.d.ts

@@ -0,0 +1,3 @@
+import { useUser } from "../api";
+export { useUser };
+export default useUser;

package/runtime/composables/use-user.mjs

@@ -0,0 +1,3 @@
+import { useUser } from "../api/index.mjs";
+export { useUser };
+export default useUser;

package/runtime/composables/use-validators.d.ts

@@ -0,0 +1,8 @@
+export declare const useValidators: () => {
+    emailValidator: (value: string) => boolean;
+    phoneValidator: (value: string) => boolean;
+    phoneOrEmailValidator: (value: string) => boolean;
+    minLengthValidator: (minLength: number) => (value: string) => boolean;
+    maxLengthValidator: (maxLength: number) => (value: string) => boolean;
+    passwordValidator: (value: string) => boolean;
+};

package/runtime/composables/use-validators.mjs

@@ -0,0 +1,17 @@
+const EMAIL_REGEXP = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|.(".+"))@((\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\])|(([a-z\-0-9]+\.)+[a-z]{2,}))$/i;
+const PHONE1_REGEXP = /^((?:\+7|8|7)?(\d){10})$/gm;
+const PHONE2_REGEXP = /^((?:\+7|8|7|\+7-|8-|7-)?(\d){3}-(\d){3}-(\d){2}-(\d){2})$/gm;
+const PHONE3_REGEXP = /^((?:\+7|8|7|\+7\s|8\s|7\s)?\((\d){3}\)\s?(\d){3}[-\s](\d){2}[-\s](\d){2})$/gm;
+const PASSWORD_REGEXP = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[\w!@#$%^&*()+\-=[\]{};':"\\|,.<>/?]{8,}$/;
+const emailValidator = (value) => EMAIL_REGEXP.test(value.toLowerCase());
+const phoneValidator = (value) => PHONE1_REGEXP.test(value) || PHONE2_REGEXP.test(value) || PHONE3_REGEXP.test(value);
+export const useValidators = () => {
+  return {
+    emailValidator,
+    phoneValidator,
+    phoneOrEmailValidator: (value) => phoneValidator(value) || emailValidator(value),
+    minLengthValidator: (minLength) => (value) => value.length >= minLength,
+    maxLengthValidator: (maxLength) => (value) => value.length <= maxLength,
+    passwordValidator: (value) => PASSWORD_REGEXP.test(value)
+  };
+};

package/runtime/middleware/auth.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").RouteMiddleware;
+export default _default;

package/runtime/middleware/auth.mjs

@@ -0,0 +1,10 @@
+import { defineNuxtRouteMiddleware, navigateTo } from "#app";
+import { useLocalePath } from "#i18n";
+import { useUser } from "../composables/use-user.mjs";
+export default defineNuxtRouteMiddleware(() => {
+  const user = useUser();
+  if (!user.value) {
+    const localePath = useLocalePath();
+    return navigateTo(localePath("/account/login"));
+  }
+});

package/runtime/middleware/guest.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").RouteMiddleware;
+export default _default;

package/runtime/middleware/guest.mjs

@@ -0,0 +1,12 @@
+import { defineNuxtRouteMiddleware, navigateTo } from "#app";
+import { useLocalePath } from "#i18n";
+import { useRuntimeConfig } from "#imports";
+import { useUser } from "../composables/use-user.mjs";
+export default defineNuxtRouteMiddleware(() => {
+  const user = useUser();
+  if (user.value) {
+    const localePath = useLocalePath();
+    const baseURL = useRuntimeConfig().public.baseURL ?? "";
+    return navigateTo(localePath(baseURL));
+  }
+});

package/runtime/middleware/index.d.ts

@@ -0,0 +1,4 @@
+import authMiddleware from "./auth";
+import guestMiddleware from "./guest";
+import localeMiddleware from "./locale.global";
+export { authMiddleware, guestMiddleware, localeMiddleware };

package/runtime/middleware/index.mjs

@@ -0,0 +1,4 @@
+import authMiddleware from "./auth.mjs";
+import guestMiddleware from "./guest.mjs";
+import localeMiddleware from "./locale.global.mjs";
+export { authMiddleware, guestMiddleware, localeMiddleware };

package/runtime/middleware/locale.global.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").RouteMiddleware;
+export default _default;

package/runtime/middleware/locale.global.mjs

@@ -0,0 +1,13 @@
+import { defineNuxtRouteMiddleware, navigateTo } from "#app";
+import { useCookie, useRuntimeConfig } from "#imports";
+import { useUser } from "../composables/use-user.mjs";
+export default defineNuxtRouteMiddleware((to) => {
+  if (import.meta.server) return;
+  const user = useUser();
+  const { value: localeCookie } = useCookie("locale");
+  const locale = user.value?.locale ?? localeCookie ?? "en";
+  const { routingStrategy, defaultLocale } = useRuntimeConfig().public;
+  if (routingStrategy === "prefix" && to.path === `/${defaultLocale}` && locale !== defaultLocale) {
+    return navigateTo(`/${locale}`);
+  }
+});

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

@@ -0,0 +1,8 @@
+import { type User } from "./use-user";
+import type { Fetch, FetchConfig, FetchExtraOptions as FetchOptions } from "./types";
+export declare const setUser: (newUser?: User | null) => void;
+export declare const updateUser: (newUser: Partial<User>) => void;
+export declare const getToken: () => string | null | undefined;
+export declare const setToken: (newToken?: string | null) => void;
+export declare const flush: () => void;
+export declare const createApiFetch: (fetch: Fetch, config: FetchConfig) => (url: string, options?: FetchOptions) => Promise<any>;

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

@@ -0,0 +1,150 @@
+import { useLocalStorage } from "@vueuse/core";
+import bus from "./bus.mjs";
+import { newCometClient } from "./comet-client.mjs";
+import { getVisitor } from "./get-visitor.mjs";
+import { apiHelper, once } from "./helpers/index.mjs";
+import { useApiActions } from "./use-api-actions.mjs";
+import { useUser } from "./use-user.mjs";
+let token = null;
+export const setUser = (newUser) => {
+  const user = useUser();
+  user.value = newUser;
+  bus.publish("user:onUpdated", user.value);
+};
+export const updateUser = (newUser) => {
+  const user = useUser();
+  if (user.value && newUser) {
+    setUser({ ...user.value, ...newUser });
+  }
+};
+export const getToken = () => {
+  return token;
+};
+export const setToken = (newToken) => {
+  token = newToken;
+};
+export const flush = () => {
+  setToken(null);
+  setUser(null);
+  const loggedIn = useLocalStorage("lin", "no");
+  loggedIn.value = "no";
+};
+const eventHandler = (requestID, eventName) => {
+  return new Promise((resolve, reject) => {
+    const subscription = bus.subscribe(eventName, (data) => {
+      if (requestID !== data?.requestID) {
+        return;
+      }
+      subscription?.unsubscribe();
+      resolve(data);
+    });
+    setTimeout(() => {
+      if (subscription?.closed) {
+        return;
+      }
+      subscription?.unsubscribe();
+      reject(new Error("Event Response Timeout"));
+    }, 1e4);
+  });
+};
+const successHandler = async (response, options = {}) => {
+  const eventNameResult = options.headers?.event;
+  const checkResponse = options.checkResponse;
+  if (typeof eventNameResult === "string" && Boolean(eventNameResult)) {
+    const requestID = response?._data?.RequestID;
+    const data = await eventHandler(requestID, eventNameResult);
+    return resolveData(data);
+  } else {
+    return resolveData(response?._data);
+  }
+  function resolveData(resData) {
+    const data = apiHelper.convertToClient(resData);
+    if (import.meta.env.MODE !== "production" && checkResponse && !checkResponse(data)?.success) {
+      console.error(checkResponse(data).error);
+    }
+    return data;
+  }
+};
+const errorHandler = (error) => {
+  const { _data } = error?.response ?? { status: 500, _data: {} };
+  const data = apiHelper.convertToClient(_data.data ?? _data);
+  let message = "";
+  if (typeof data === "string") {
+    message = data.trim();
+  }
+  return new Error(message);
+};
+const optionsHandler = (options = {}, config) => {
+  const { apiBaseURL, appClientID, appClientSecret, isMobileApp, isDesktopApp, getHostname } = config;
+  const baseURL = "/api";
+  const headers = {};
+  const visitor = { platform: "web", hostname: getHostname() };
+  if (token) {
+    headers.authorization = `JWT ${token}`;
+  } else if (typeof window !== "undefined" && appClientID && appClientSecret) {
+    const credentials = btoa(`${appClientID}:${appClientSecret}`);
+    headers.authorization = `Basic ${credentials}`;
+  }
+  if (isMobileApp) {
+    options.baseURL = apiBaseURL;
+    visitor.platform = "mobile";
+  }
+  if (isDesktopApp) {
+    options.baseURL = apiBaseURL;
+    visitor.platform = "desktop";
+  }
+  if (typeof window !== "undefined") {
+    visitor.hostname = location.hostname;
+  }
+  const { platform, hostname } = visitor;
+  const visitorIdentifier = getVisitor();
+  if (visitorIdentifier) {
+    const { id, ip, device, appName } = visitorIdentifier;
+    headers.visitor = btoa(`${platform}|:|${hostname}|:|${id}|:|${ip}|:|${device}|:|${appName}`);
+  } else {
+    headers.visitor = btoa(`${platform}|:|${hostname}`);
+  }
+  return {
+    baseURL,
+    ...options,
+    body: apiHelper.convertToServer(options.body),
+    headers: { ...options.headers, ...headers }
+  };
+};
+const fetchRequest = (url, options = {}, fetch, config) => {
+  const request = async () => {
+    const opts = optionsHandler(options, config);
+    try {
+      const response = await fetch.raw(url, opts);
+      return await successHandler(response, options);
+    } catch (error) {
+      const { status } = error?.response ?? { status: 500 };
+      if (status === 401 && url !== "/account/1/offline") {
+        const apiActions = useApiActions();
+        await apiActions.value?.refreshToken?.();
+        return request();
+      }
+      throw errorHandler(error);
+    }
+  };
+  return request();
+};
+export const createApiFetch = once((fetch, config) => {
+  if (typeof window !== "undefined") {
+    const cometServerURL = config.cometServerURL;
+    let cometClient;
+    bus.subscribe("user:onUpdated", (user) => {
+      if (user) {
+        cometClient || (cometClient = newCometClient(user, cometServerURL));
+        if (!cometClient.isStarted) {
+          cometClient.start();
+          cometClient.isStarted = true;
+        }
+      } else if (cometClient) {
+        cometClient.stop();
+        cometClient.isStarted = false;
+      }
+    });
+  }
+  return (url, options) => fetchRequest(url, options, fetch, config);
+});

package/runtime/packages/api/bus.d.ts

@@ -0,0 +1,7 @@
+export type { Subscription } from "rxjs";
+declare const _default: {
+    publish<T>(eventName: string, data: T): void;
+    subscribe<T>(eventName: string, func: (data: T) => void): import("rxjs").Subscription;
+    unsubscribeAll(): void;
+};
+export default _default;

package/runtime/packages/api/bus.mjs

@@ -0,0 +1,22 @@
+import { Subject } from "rxjs";
+const hasOwnProp = {}.hasOwnProperty;
+let subjects = {};
+export default {
+  publish(eventName, data) {
+    subjects[eventName] || (subjects[eventName] = new Subject());
+    subjects[eventName]?.next(data);
+  },
+  subscribe(eventName, func) {
+    subjects[eventName] || (subjects[eventName] = new Subject());
+    return subjects[eventName]?.subscribe(func);
+  },
+  unsubscribeAll() {
+    const _subjects = subjects;
+    for (const eventName in _subjects) {
+      if (hasOwnProp.call(_subjects, eventName)) {
+        _subjects[eventName]?.unsubscribe();
+      }
+    }
+    subjects = {};
+  }
+};

package/runtime/packages/api/comet-client.d.ts

@@ -0,0 +1,11 @@
+import type { User } from "./use-user";
+declare global {
+    interface Window {
+        wsPublish: (eventName: string, data: unknown) => void;
+    }
+}
+export declare function newCometClient(user: User, cometServerURL: string): {
+    isStarted: boolean;
+    start: () => void;
+    stop: () => void;
+};

package/runtime/packages/api/comet-client.mjs

@@ -0,0 +1,73 @@
+import { Centrifuge } from "centrifuge";
+import { getToken } from "./api-client.mjs";
+import bus from "./bus.mjs";
+import { apiHelper } from "./helpers/index.mjs";
+import { useApiActions } from "./use-api-actions.mjs";
+if (typeof window !== "undefined" && import.meta.env.MODE !== "production") {
+  window.wsPublish = (eventName, data) => {
+    setTimeout(() => bus.publish(`WS.${eventName}`, data), 0);
+  };
+}
+export function newCometClient(user, cometServerURL) {
+  const transports = [
+    {
+      transport: "websocket",
+      endpoint: `wss://${cometServerURL}/connection/websocket`
+    },
+    {
+      transport: "http_stream",
+      endpoint: `https//${cometServerURL}/connection/http_stream`
+    },
+    {
+      transport: "sse",
+      endpoint: `https//${cometServerURL}/connection/sse`
+    }
+  ];
+  const centrifuge = new Centrifuge(transports, {
+    token: getToken() ?? "",
+    debug: import.meta.env.MODE !== "production",
+    getToken: async () => {
+      const apiActions = useApiActions();
+      return await apiActions.value?.refreshToken?.() ?? "";
+    }
+  });
+  const publish = (eventName, data) => () => {
+    bus.publish(`WS.${eventName}`, apiHelper.convertToClient(data));
+  };
+  let userSubscription;
+  return {
+    isStarted: false,
+    start: () => {
+      userSubscription || (userSubscription = centrifuge.newSubscription(`personal:user#${user?.id}`));
+      if (userSubscription.state === "subscribed") {
+        return;
+      }
+      const publicationHandler = (message) => {
+        if (message?.data && Array.isArray(message.data)) {
+          message.data.forEach((event) => {
+            const eventName = event.NotificationName;
+            const data = event.Data;
+            if (import.meta.env.MODE !== "production") {
+              console.log("IO event handled:", eventName, data);
+              if (!eventName) {
+                console.log(`[${/* @__PURE__ */ new Date()}] Comet: no name event`);
+                return;
+              }
+            }
+            setTimeout(publish(eventName, data), 400);
+          });
+        }
+      };
+      userSubscription.on("publication", publicationHandler);
+      userSubscription.subscribe();
+      centrifuge.connect();
+    },
+    stop: () => {
+      if (userSubscription) {
+        userSubscription.unsubscribe();
+        userSubscription.removeAllListeners();
+      }
+      centrifuge.disconnect();
+    }
+  };
+}

package/runtime/packages/api/get-user.d.ts

@@ -0,0 +1,8 @@
+import { type User } from "./use-user";
+import type { Fetch, FetchConfig } from "./types";
+type GetUserResponse = {
+    token?: string | null;
+    user?: User | null;
+};
+export declare const createApiGetUser: (fetch: Fetch, config: FetchConfig) => () => Promise<GetUserResponse>;
+export {};

package/runtime/packages/api/get-user.mjs

@@ -0,0 +1,54 @@
+import { useLocalStorage } from "@vueuse/core";
+import { flush, getToken, setUser } from "./api-client.mjs";
+import { once } from "./helpers/index.mjs";
+import { useApiActions } from "./use-api-actions.mjs";
+import { useUser } from "./use-user.mjs";
+let gettingUserInProgress = false;
+let gettingUserPromise = null;
+function getUser(fetch, config) {
+  if (gettingUserInProgress && gettingUserPromise) {
+    return gettingUserPromise;
+  }
+  return gettingUserStart(fetch, config);
+}
+function gettingUserStart(fetch, config) {
+  gettingUserInProgress = true;
+  gettingUserPromise = getUserRequest(fetch, config).finally(() => {
+    gettingUserInProgress = false;
+    gettingUserPromise = null;
+  });
+  return gettingUserPromise;
+}
+async function getUserRequest(fetch, config) {
+  const token = getToken();
+  const user = useUser();
+  if (token && user.value) {
+    return { token, user: user.value };
+  }
+  if (!token) {
+    const loggedIn = useLocalStorage("lin", "no");
+    if (loggedIn.value !== "yes") {
+      flush();
+      return { token: null, user: null };
+    }
+    try {
+      const apiActions = useApiActions();
+      await apiActions.value?.getVisitorIdentifier?.();
+      await apiActions.value?.refreshToken?.();
+    } catch {
+      flush();
+      return { token: null, user: null };
+    }
+  }
+  try {
+    const user2 = await fetch("/account", config.useRequestHeaders?.(["cookie", "authorization"]));
+    setUser(user2);
+    return { token, user: user2 };
+  } catch {
+    flush();
+    return { token: null, user: null };
+  }
+}
+export const createApiGetUser = once((fetch, config) => {
+  return () => getUser(fetch, config);
+});

package/runtime/packages/api/get-visitor.d.ts

@@ -0,0 +1,11 @@
+import type { FetchConfig } from "./types";
+export declare type Visitor = {
+    id?: string;
+    ip?: string;
+    device?: string;
+    appName?: string;
+};
+export declare const getVisitorId: () => string | undefined;
+export declare const getVisitor: () => Visitor | null;
+export declare const getVisitorIdentifier: (config: FetchConfig) => Promise<void>;
+export declare const createApiGetVisitorIdentifier: (config: FetchConfig) => () => Promise<void>;

package/runtime/packages/api/get-visitor.mjs

@@ -0,0 +1,32 @@
+import { hashComponents, load } from "@fingerprintjs/fingerprintjs";
+import { ofetch } from "ofetch";
+import { once } from "./helpers/index.mjs";
+let visitor = null;
+export const getVisitorId = () => {
+  return visitor?.id;
+};
+export const getVisitor = () => {
+  return visitor;
+};
+const setVisitor = (newVisitor) => {
+  visitor = !visitor ? newVisitor : { ...visitor, ...newVisitor };
+};
+export const getVisitorIdentifier = async (config) => {
+  if (typeof window === "undefined" || visitor) {
+    return;
+  }
+  const fp = await load();
+  const result = await fp.get();
+  const { canvas, colorDepth, hdr, languages, screenFrame, screenResolution, ...components } = result.components;
+  const id = hashComponents(components);
+  const ip = "unknown";
+  ofetch("https://api.ipify.org?format=json").then((data) => {
+    setVisitor({ ip: data?.ip ?? "unknown" });
+  });
+  const device = await config.getDevice() || "unknown";
+  const appName = config.appName || "unknown";
+  setVisitor({ id, ip, device, appName });
+};
+export const createApiGetVisitorIdentifier = once((config) => {
+  return () => getVisitorIdentifier(config);
+});

package/runtime/packages/api/helpers/api-helper.d.ts

@@ -0,0 +1,6 @@
+export declare function convertToClient(data: unknown): any;
+export declare function convertToServer(data: unknown): any;
+export declare const apiHelper: {
+    convertToClient: typeof convertToClient;
+    convertToServer: typeof convertToServer;
+};