@inzombieland/core 0.0.1 → 1.18.0

package/AppProvider.vue

@@ -0,0 +1,36 @@
+<script setup lang="ts">
+import { onBeforeMount, onMounted, ref } from "vue"
+import bus from "./bus"
+import { useThemeMode, useUser } from "./index"
+import type { ConfigProviderTheme } from "vant"
+import "@vant/touch-emulator"
+
+const theme = useThemeMode()
+const user = useUser()
+const appLoading = ref(Boolean(user.value))
+
+onBeforeMount(() => {
+	bus.publish("app:beforeMount", true)
+})
+
+onMounted(() => {
+	appLoading.value = false
+})
+</script>
+
+<template>
+	<div
+		class="h-full"
+		:class="{ app: appLoading }"
+	>
+		<slot />
+		<van-config-provider
+			v-if="theme?.value"
+			:theme="theme?.value as ConfigProviderTheme"
+		/>
+	</div>
+</template>
+
+<style scoped>
+.app{height:0;width:0}.app:after{background:#5a5a5a url(/images/loading.gif) no-repeat 50%;content:"";height:100%;left:0;position:absolute;top:0;transition:.5s;width:100%;z-index:10000}
+</style>

package/LICENSE

@@ -0,0 +1,8 @@
+ISC License:
+
+Copyright (c) 2004-2010 by Internet Systems Consortium, Inc. ("ISC")
+Copyright (c) 1995-2003 by Internet Software Consortium
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/api-client.d.ts

@@ -0,0 +1,7 @@
+import type { Fetch, FetchConfig, FetchExtraOptions as FetchOptions, User } 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/api-client.mjs

@@ -0,0 +1,130 @@
+import bus from "./bus.mjs";
+import { useApiActions } from "./composables/use-api-actions.mjs";
+import { useUser } from "./composables/use-user.mjs";
+import { getVisitor } from "./get-visitor.mjs";
+import { apiHelper, once } from "./helpers/index.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 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) => {
+  return (url, options) => fetchRequest(url, options, fetch, config);
+});

package/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/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/comet-client.d.ts

@@ -0,0 +1,11 @@
+import type { User } from "./types";
+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/comet-client.mjs

@@ -0,0 +1,73 @@
+import { Centrifuge } from "centrifuge";
+import { getToken } from "./api-client.mjs";
+import bus from "./bus.mjs";
+import { useApiActions } from "./composables/use-api-actions.mjs";
+import { apiHelper } from "./helpers/index.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/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/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/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/composables/use-api-actions.mjs

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

package/composables/use-app-locale.d.ts

@@ -0,0 +1 @@
+export declare const useAppLocale: () => import("@vueuse/shared").RemovableRef<any>;

package/composables/use-app-locale.mjs

@@ -0,0 +1,13 @@
+import { useLocalStorage } from "@vueuse/core";
+export const useAppLocale = () => {
+  return useLocalStorage(
+    "app-preferences-locale",
+    { value: "en" },
+    {
+      serializer: {
+        read: (v) => v ? JSON.parse(v) : null,
+        write: (v) => JSON.stringify(v)
+      }
+    }
+  );
+};

package/composables/use-subscribe.d.ts

@@ -0,0 +1,10 @@
+import { type Subscription } from "../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/composables/use-subscribe.mjs

@@ -0,0 +1,22 @@
+import { onMounted, onUnmounted } from "vue";
+import bus from "../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/composables/use-theme-mode.d.ts

@@ -0,0 +1 @@
+export declare const useThemeMode: () => import("@vueuse/shared").RemovableRef<any>;

package/composables/use-theme-mode.mjs

@@ -0,0 +1,14 @@
+import { useLocalStorage, usePreferredDark } from "@vueuse/core";
+export const useThemeMode = () => {
+  const isDark = usePreferredDark();
+  return useLocalStorage(
+    "app-preferences-theme",
+    { value: isDark.value ? "dark" : "light" },
+    {
+      serializer: {
+        read: (v) => v ? JSON.parse(v) : null,
+        write: (v) => JSON.stringify(v)
+      }
+    }
+  );
+};

package/composables/use-user.d.ts

@@ -0,0 +1,32 @@
+import type { User } from "../types";
+export declare function useUser(): import("vue").Ref<{
+    id: string;
+    firstName: string;
+    lastName: string;
+    middleName: string;
+    email: string;
+    emailVerified: boolean;
+    phone: string;
+    phoneVerified: boolean;
+    gender: "" | "male" | "female";
+    birthday: Date;
+    passwordLastSet: Date;
+    theme: "light" | "dark";
+    locale: string;
+    avatar: string;
+} | null | undefined, User | {
+    id: string;
+    firstName: string;
+    lastName: string;
+    middleName: string;
+    email: string;
+    emailVerified: boolean;
+    phone: string;
+    phoneVerified: boolean;
+    gender: "" | "male" | "female";
+    birthday: Date;
+    passwordLastSet: Date;
+    theme: "light" | "dark";
+    locale: string;
+    avatar: string;
+} | null | undefined>;

package/composables/use-user.mjs

@@ -0,0 +1,5 @@
+import { ref } from "vue";
+const user = ref(null);
+export function useUser() {
+  return user;
+}

package/get-user.d.ts

@@ -0,0 +1,2 @@
+import type { Fetch, FetchConfig, GetUserResponse } from "./types";
+export declare const createApiGetUser: (fetch: Fetch, config: FetchConfig) => () => Promise<GetUserResponse>;

package/get-user.mjs

@@ -0,0 +1,55 @@
+import { useLocalStorage } from "@vueuse/core";
+import { flush, getToken, setUser } from "./api-client.mjs";
+import { useApiActions } from "./composables/use-api-actions.mjs";
+import { useUser } from "./composables/use-user.mjs";
+import { once } from "./helpers/index.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);
+    const token2 = getToken();
+    return { token: token2, user: user2 };
+  } catch {
+    flush();
+    return { token: null, user: null };
+  }
+}
+export const createApiGetUser = once((fetch, config) => {
+  return () => getUser(fetch, config);
+});

package/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 getVisitorRequest: (config: FetchConfig) => Promise<void>;
+export declare const createApiGetVisitorIdentifier: (config: FetchConfig) => () => Promise<void>;

package/get-visitor.mjs

@@ -0,0 +1,48 @@
+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 };
+};
+let gettingInProgress = false;
+let gettingPromise = null;
+function getVisitorIdentifier(config) {
+  if (gettingInProgress && gettingPromise) {
+    return gettingPromise;
+  }
+  return gettingVisitorStart(config);
+}
+function gettingVisitorStart(config) {
+  gettingInProgress = true;
+  gettingPromise = getVisitorRequest(config).finally(() => {
+    gettingInProgress = false;
+    gettingPromise = null;
+  });
+  return gettingPromise;
+}
+export const getVisitorRequest = 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/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;
+};