@inzombieland/core 0.0.1 → 1.18.0

package/helpers/date-helper.mjs

@@ -0,0 +1,230 @@
+const isoExp = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)((-(\d{2}):(\d{2})|Z)?)$/;
+export function stringToDate(dateString) {
+  if (typeof dateString === "string") {
+    if (dateString === "0001-01-01T00:00:00Z") {
+      return;
+    }
+    let date = new Date(Number.NaN);
+    const parts = isoExp.exec(dateString);
+    if (parts) {
+      date = parts.at(-1) === "Z" ? new Date(
+        Date.UTC(
+          Number(parts[1]),
+          Number(parts[2]) - 1,
+          Number(parts[3]),
+          Number(parts[4]),
+          Number(parts[5]),
+          Number(parts[6])
+        )
+      ) : new Date(
+        Number(parts[1]),
+        Number(parts[2]) - 1,
+        Number(parts[3]),
+        Number(parts[4]),
+        Number(parts[5]),
+        Number(parts[6])
+      );
+    }
+    return date;
+  }
+  return void 0;
+}
+const masks = {
+  default: "dd mmm yyyy",
+  "default:R": "dd mmmm:R yyyy",
+  "default:RC": "dd mmmm:R yyyy:C",
+  defaultshortday: "d mmm yyyy",
+  "defaultshortday:C": "d mmm yyyy:C",
+  "defaultshortday:R": "d mmmm:R yyyy",
+  "defaultshortday:RC": "d mmmm:R yyyy:C",
+  shortDate: "m/d/yy",
+  mediumDate: "mmm d, yyyy",
+  longDate: "mmmm d, yyyy",
+  fullDate: "dddd, mmmm d, yyyy",
+  shortTime: "h:MM TT",
+  mediumTime: "h:MM:ss TT",
+  longTime: "h:MM:ss TT Z",
+  isoDate: "yyyy-mm-dd",
+  isoTime: "HH:MM:ss",
+  isoDateTime: "yyyy-mm-dd'T'HH:MM:ss",
+  isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'",
+  time: "HH:MM",
+  dateTime: "dd.mm.yyyy HH:MM",
+  clever: "clever"
+};
+const i18n = {
+  en: {
+    dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+    dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+    monthName: [
+      "January",
+      "February",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "August",
+      "September",
+      "October",
+      "November",
+      "December"
+    ],
+    yesterday: "'Yesterday'",
+    today: "'Today'"
+  },
+  ru: {
+    dayNames: ["\u0432\u043E\u0441\u043A\u0440\u0435\u0441\u0435\u043D\u044C\u0435", "\u043F\u043E\u043D\u0435\u0434\u0435\u043B\u044C\u043D\u0438\u043A", "\u0432\u0442\u043E\u0440\u043D\u0438\u043A", "\u0441\u0440\u0435\u0434\u0430", "\u0447\u0435\u0442\u0432\u0435\u0440\u0433", "\u043F\u044F\u0442\u043D\u0438\u0446\u0430", "\u0441\u0443\u0431\u0431\u043E\u0442\u0430"],
+    dayNamesShort: ["\u0412\u0441", "\u041F\u043D", "\u0412\u0442", "\u0421\u0440", "\u0427\u0442", "\u041F\u0442", "\u0421\u0431"],
+    monthName: [
+      "\u044F\u043D\u0432\u0430\u0440\u044C",
+      "\u0444\u0435\u0432\u0440\u0430\u043B\u044C",
+      "\u043C\u0430\u0440\u0442",
+      "\u0430\u043F\u0440\u0435\u043B\u044C",
+      "\u043C\u0430\u0439",
+      "\u0438\u044E\u043D\u044C",
+      "\u0438\u044E\u043B\u044C",
+      "\u0430\u0432\u0433\u0443\u0441\u0442",
+      "\u0441\u0435\u043D\u0442\u044F\u0431\u0440\u044C",
+      "\u043E\u043A\u0442\u044F\u0431\u0440\u044C",
+      "\u043D\u043E\u044F\u0431\u0440\u044C",
+      "\u0434\u0435\u043A\u0430\u0431\u0440\u044C"
+    ],
+    yesterday: "'\u0412\u0447\u0435\u0440\u0430'",
+    today: "'\u0421\u0435\u0433\u043E\u0434\u043D\u044F'"
+  }
+};
+const token = /d{1,4}:?C?|m{1,4}:?[RC]?|yy(?:yy|y)?:?[RC]?|([HhMsTt])\1?|[LloZ]|"[^"]*"|'[^']*'/g;
+const timezone = /\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\d{4})?)\b/g;
+const timezoneClip = /[^-+\dA-Z]/g;
+const pad = (value, len = 2) => {
+  let val = String(value);
+  while (val.length < len) {
+    val = `0${val}`;
+  }
+  return val;
+};
+const createOnlyDate = (date) => {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+};
+const countCalendarDayBetween = (date1, date2) => {
+  const day1 = createOnlyDate(date1);
+  const day2 = createOnlyDate(date2);
+  const dayCount = (day1.getTime() - day2.getTime()) / (24 * 60 * 60 * 1e3);
+  return Math.abs(dayCount);
+};
+const checkIsYesterday = (now, date) => {
+  return now > date && countCalendarDayBetween(now, date) === 1;
+};
+const getDayName = (day, locale, short = false) => {
+  return short ? i18n[locale].dayNamesShort[day] : i18n[locale].dayNames[day];
+};
+const monthDeclination = (month, locale) => {
+  return month === 3 || month === 8 ? `${i18n[locale].monthName[month - 1]}\u0430` : `${i18n[locale].monthName[month - 1].slice(0, -1)}\u044F`;
+};
+const getMonthName = (month, locale, countChar = 0, declination = false) => {
+  const monthName = locale === "ru" && declination ? monthDeclination(month, locale) : i18n[locale].monthName[month - 1];
+  if (countChar && countChar > 0) {
+    return monthName.slice(0, 3);
+  }
+  return monthName;
+};
+const getMask = (format, locale, isCurrentDay, isYesterday, isCurrentYear) => {
+  const defaultFormat = {
+    en: "mmmm d, yyyy",
+    ru: "d mmmm:R yyyy"
+  };
+  const formats = {
+    default: defaultFormat,
+    get clever() {
+      if (isCurrentDay) {
+        return {
+          en: `${i18n.en.today} 'at' H:MM TT`,
+          ru: `${i18n.ru.today}, HH:MM`
+        };
+      } else if (isYesterday) {
+        return {
+          en: `${i18n.en.yesterday} 'at' H:MM TT`,
+          ru: `${i18n.ru.yesterday}, HH:MM`
+        };
+      } else if (isCurrentYear) {
+        return {
+          en: "mmmm d",
+          ru: "d mmmm:R"
+        };
+      } else {
+        return defaultFormat;
+      }
+    }
+  };
+  let mask = String(masks[format] ?? (format || masks.default));
+  if (mask.startsWith("UTC:")) {
+    mask = mask.slice(4);
+  }
+  if (formats[format]?.[locale]) {
+    return formats[format]?.[locale] ?? "";
+  }
+  return mask;
+};
+export function dateFormat(date = /* @__PURE__ */ new Date(), format = "default", locale = "en", dateTimeNow) {
+  date = date ? new Date(date) : /* @__PURE__ */ new Date();
+  if (Number.isNaN(date)) {
+    throw new SyntaxError("invalid date");
+  }
+  const utc = (masks[format] ?? format).startsWith("UTC:");
+  const now = dateTimeNow ?? /* @__PURE__ */ new Date();
+  const currentYear = utc ? now.getUTCFullYear() : now.getFullYear();
+  const currentMonth = utc ? now.getUTCMonth() : now.getMonth();
+  const currentDate = utc ? now.getUTCDate() : now.getDate();
+  const isYesterday = checkIsYesterday(now, date);
+  const d = utc ? date.getUTCDate() : date.getDate();
+  const D = utc ? date.getUTCDay() : date.getDay();
+  const m = utc ? date.getUTCMonth() : date.getMonth();
+  const y = utc ? date.getUTCFullYear() : date.getFullYear();
+  const isCurrentYear = y === currentYear;
+  const isCurrentDay = y === currentYear && m === currentMonth && d === currentDate;
+  const H = utc ? date.getUTCHours() : date.getHours();
+  const M = utc ? date.getUTCMinutes() : date.getMinutes();
+  const s = utc ? date.getUTCSeconds() : date.getSeconds();
+  const L = utc ? date.getUTCMilliseconds() : date.getMilliseconds();
+  const o = utc ? 0 : date.getTimezoneOffset();
+  const flags = {
+    d,
+    dd: pad(d),
+    ddd: getDayName(D, locale, true),
+    dddd: getDayName(D, locale),
+    m: m + 1,
+    mm: pad(m + 1),
+    mmm: getMonthName(m + 1, locale, 3),
+    mmmm: getMonthName(m + 1, locale),
+    "mmmm:R": getMonthName(m + 1, locale, 0, true),
+    "mm:C": isYesterday || isCurrentDay ? "" : pad(m + 1),
+    "yy:C": isCurrentYear ? "" : String(y).slice(2),
+    yy: String(y).slice(2),
+    "yyyy:C": isCurrentYear ? "" : y,
+    yyyy: y,
+    yyy: y,
+    h: H % 12 || 12,
+    hh: pad(H % 12 || 12),
+    H,
+    HH: pad(H),
+    M,
+    MM: pad(M),
+    s,
+    ss: pad(s),
+    l: pad(L, 3),
+    L: pad(L > 99 ? Math.round(L / 10) : L),
+    tt: H < 12 ? "am" : "pm",
+    TT: H < 12 ? "AM" : "PM",
+    Z: utc ? "UTC" : (String(date).match(timezone) || [""]).pop()?.replace(timezoneClip, ""),
+    o: (o > 0 ? "-" : "+") + pad(Math.floor(Math.abs(o) / 60) * 100 + Math.abs(o) % 60, 4)
+  };
+  const mask = getMask(format, locale, isCurrentDay, isYesterday, isCurrentYear);
+  const parsedDate = mask.replaceAll(token, ($0) => {
+    return $0 in flags ? String(flags[$0]) : $0.slice(1, -1);
+  });
+  return parsedDate.trim();
+}
+export const dateHelper = { stringToDate, dateFormat };

package/helpers/device-helper.d.ts

@@ -0,0 +1,43 @@
+export interface Device {
+    mobile: () => boolean;
+    tablet: () => boolean;
+    desktop: () => boolean;
+    ios: () => boolean;
+    macos: () => boolean;
+    ipad: () => boolean;
+    iphone: () => boolean;
+    ipod: () => boolean;
+    android: () => boolean;
+    androidPhone: () => boolean;
+    androidTablet: () => boolean;
+    blackberry: () => boolean;
+    blackberryPhone: () => boolean;
+    blackberryTablet: () => boolean;
+    windows: () => boolean;
+    windowsPhone: () => boolean;
+    windowsTablet: () => boolean;
+    fxos: () => boolean;
+    fxosPhone: () => boolean;
+    fxosTablet: () => boolean;
+    meego: () => boolean;
+    television: () => boolean;
+    isMobileApp: boolean;
+    mobileApp: () => boolean;
+    iosMobileApp: () => boolean;
+    androidMobileApp: () => boolean;
+    tabletApp: () => boolean;
+    iosTabletApp: () => boolean;
+    androidTabletApp: () => boolean;
+    landscape: () => boolean;
+    portrait: () => boolean;
+    onChangeOrientation: (cb: (newOrientation: DeviceOrientation) => void) => void;
+    noConflict: (currentDevice: Device) => void;
+    type: DeviceType;
+    orientation: DeviceOrientation;
+    os: DeviceOs;
+    osName: () => string;
+}
+export type DeviceType = "mobile" | "tablet" | "desktop" | "unknown";
+export type DeviceOrientation = "landscape" | "portrait" | "unknown";
+export type DeviceOs = "ios" | "macos" | "iphone" | "ipad" | "ipod" | "android" | "blackberry" | "windows" | "fxos" | "meego" | "television" | "unknown";
+export declare const deviceHelper: () => Device;

package/helpers/device-helper.mjs

@@ -0,0 +1,15 @@
+import { device as currentDevice } from "./current-device.mjs";
+export const deviceHelper = () => {
+  const device = currentDevice;
+  const isMobileApp = import.meta.env.VITE_IS_MOBILE_APP === "true" || import.meta.env.VITE_IS_MOBILE_APP === true;
+  return {
+    ...device,
+    isMobileApp,
+    mobileApp: () => isMobileApp && device.mobile(),
+    iosMobileApp: () => isMobileApp && device.mobile() && device.ios(),
+    androidMobileApp: () => isMobileApp && device.androidPhone(),
+    tabletApp: () => isMobileApp && device.tablet(),
+    iosTabletApp: () => isMobileApp && device.tablet() && device.ios(),
+    androidTabletApp: () => isMobileApp && device.androidTablet()
+  };
+};

package/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export { apiHelper } from "./api-helper";
+export { dateHelper } from "./date-helper";
+export { deviceHelper, type Device } from "./device-helper";
+export declare function once<T extends (...args: any[]) => any>(fn: T): T;

package/helpers/index.mjs

@@ -0,0 +1,15 @@
+export { apiHelper } from "./api-helper.mjs";
+export { dateHelper } from "./date-helper.mjs";
+export { deviceHelper } from "./device-helper.mjs";
+export function once(fn) {
+  let executed = false;
+  let result;
+  return function(...args) {
+    if (!executed) {
+      executed = true;
+      result = fn(...args);
+      return result;
+    }
+    return result;
+  };
+}

package/index.d.ts

@@ -0,0 +1,53 @@
+import { type Ref } from "vue";
+import type { ActiveSession, Fetch, FetchConfig, User } from "./types";
+export type { ActiveSession, Fetch, FetchConfig, User };
+export { default as AppProvider } from "./AppProvider.vue";
+export { useUser } from "./composables/use-user";
+export { useSubscribe } from "./composables/use-subscribe";
+export { useActiveSessions } from "./composables/use-active-sessions";
+export { useThemeMode } from "./composables/use-theme-mode";
+export { useAppLocale } from "./composables/use-app-locale";
+export { getVisitor, getVisitorId, type Visitor } from "./get-visitor";
+export declare function initApiFetch($fetch: Fetch, config: FetchConfig): {
+    fetch: Fetch;
+    getUser: () => Promise<import("./types").GetUserResponse>;
+    useApiFetch: () => Fetch;
+    userActions: {
+        signIn: (body: {
+            username: string;
+            password: string;
+            rememberMe: boolean;
+        }) => Promise<import("./types").GetUserResponse | {
+            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/index.mjs

@@ -0,0 +1,60 @@
+import { useLocalStorage } from "@vueuse/core";
+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 { default as AppProvider } from "./AppProvider.vue";
+export { useUser } from "./composables/use-user.mjs";
+export { useSubscribe } from "./composables/use-subscribe.mjs";
+export { useActiveSessions } from "./composables/use-active-sessions.mjs";
+export { useThemeMode } from "./composables/use-theme-mode.mjs";
+export { useAppLocale } from "./composables/use-app-locale.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);
+  userActions = ref(createApiUserActions(fetch, config, getUser));
+  apiActions.value = {
+    initialized: true,
+    getVisitorIdentifier,
+    refreshToken
+  };
+  if (typeof window !== "undefined") {
+    const loggedIn = useLocalStorage("lin", "no");
+    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;
+      }
+      loggedIn.value = user ? "yes" : "no";
+    });
+    bus.subscribe("app:beforeMount", () => {
+      getVisitorIdentifier();
+      initApplication();
+    });
+  }
+  const useApiFetch = () => fetch;
+  return { fetch, getUser, useApiFetch, userActions: userActions.value };
+}
+export const useUserActions = () => {
+  return userActions;
+};

package/init-application.d.ts

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

package/init-application.mjs

@@ -0,0 +1,89 @@
+import { StyleProvider, Themes, Locale as VarletLocale } from "@varlet/ui";
+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, useAppLocale, useThemeMode, useUserActions } from "./index.mjs";
+function initApplication() {
+  const router = useRouter();
+  const user = useUser();
+  const theme = useThemeMode();
+  const locale = useAppLocale();
+  const i18n = useI18n();
+  watch(user, (user2) => {
+    if (user2 && user2.theme !== theme.value?.value) {
+      theme.value = { value: user2.theme };
+    }
+    if (user2 && user2.locale !== locale.value?.value) {
+      locale.value = { value: user2.locale };
+    }
+  });
+  watch(
+    theme,
+    (theme2) => {
+      if (theme2?.value === "dark") {
+        document.documentElement.classList.remove("light", "van-theme-light");
+        document.documentElement.classList.add("dark", "van-theme-dark");
+        StyleProvider(Themes.dark);
+      } else {
+        document.documentElement.classList.remove("dark", "van-theme-dark");
+        document.documentElement.classList.add("light", "van-theme-light");
+        StyleProvider(null);
+      }
+    },
+    { immediate: true }
+  );
+  watch(
+    locale,
+    (locale2) => {
+      if ("setLocale" in i18n && typeof i18n.setLocale === "function") {
+        i18n.setLocale(locale2?.value);
+      }
+      if (locale2?.value === "en") {
+        VantLocale.use(locale2, enUS);
+        VarletLocale.add("en-US", VarletLocale.enUS);
+      }
+      if (locale2?.value === "ru") {
+        VantLocale.use(locale2, ruRU);
+        VarletLocale.add("en-US", VarletLocale.enUS);
+      }
+    },
+    { 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();
+        await router.push({ path: "/" });
+      }
+    }
+  });
+}
+export const createInitApplication = once(() => {
+  return () => initApplication();
+});

package/package.json

@@ -1,11 +1,22 @@
 {
   "name": "@inzombieland/core",
-  "version": "0.0.1",
+  "version": "1.18.0",
   "type": "module",
   "license": "ISC",
   "main": "./index.mjs",
   "types": "./index.d.ts",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@fingerprintjs/fingerprintjs": "^4.6.2",
+    "@vant/touch-emulator": "^1.4.0",
+    "@varlet/ui": "^3.10.5",
+    "@vueuse/core": "^12.8.2",
+    "centrifuge": "^5.3.4",
+    "ofetch": "^1.4.1",
+    "rxjs": "^7.8.2",
+    "vant": "^4.9.19",
+    "zod": "^3.24.2"
   }
 }

package/refresh-token.d.ts

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

package/refresh-token.mjs

@@ -0,0 +1,39 @@
+import { flush, setToken } from "./api-client.mjs";
+import { once } from "./helpers/index.mjs";
+let refreshingTokenInProgress = false;
+let refreshingTokenPromise = null;
+function refreshToken(fetch, config) {
+  if (refreshingTokenInProgress && refreshingTokenPromise) {
+    return refreshingTokenPromise;
+  }
+  return refreshingTokenStart(fetch, config);
+}
+function refreshingTokenStart(fetch, config) {
+  refreshingTokenInProgress = true;
+  refreshingTokenPromise = refreshTokenRequest(fetch, config).finally(() => {
+    refreshingTokenInProgress = false;
+    refreshingTokenPromise = null;
+  });
+  return refreshingTokenPromise;
+}
+async function refreshTokenRequest(fetch, config) {
+  setToken(null);
+  try {
+    const { accessToken } = await fetch(
+      "/account/0/token",
+      config.useRequestHeaders?.(["cookie"])
+    );
+    if (!accessToken) {
+      flush();
+      throw new Error("No access token");
+    }
+    setToken(accessToken);
+    return accessToken;
+  } catch (error) {
+    flush();
+    throw error;
+  }
+}
+export const createApiRefreshToken = once((fetch, config) => {
+  return () => refreshToken(fetch, config);
+});

package/types.d.ts

@@ -0,0 +1,71 @@
+import type { FetchOptions, FetchRequest, FetchResponse } from "ofetch";
+import type { ZodError } from "zod";
+export type FetchExtraOptions = FetchOptions & {
+    checkResponse?: (data: unknown) => {
+        success: boolean;
+        error?: ZodError;
+        data?: unknown;
+    };
+    headers?: HeadersInit & {
+        event?: string;
+    };
+};
+export interface ResponseMap {
+    blob: Blob;
+    text: string;
+    arrayBuffer: ArrayBuffer;
+    stream: ReadableStream<Uint8Array>;
+}
+export type ResponseType = keyof ResponseMap | "json";
+export type MappedType<R extends ResponseType, JsonType = any> = R extends keyof ResponseMap ? ResponseMap[R] : JsonType;
+export interface Fetch {
+    <T = any, R extends ResponseType = "json">(request: FetchRequest, options?: FetchOptions<R> & FetchExtraOptions): Promise<MappedType<R, T>>;
+    raw: <T = any, R extends ResponseType = "json">(request: FetchRequest, options?: FetchOptions<R> & FetchExtraOptions) => Promise<FetchResponse<MappedType<R, T>>>;
+    native: typeof globalThis.fetch;
+    create: (defaults: FetchOptions & FetchExtraOptions) => Fetch;
+}
+export type FetchConfig = {
+    apiBaseURL: string;
+    cometServerURL: string;
+    appClientID: string;
+    appClientSecret: string;
+    isMobileApp: boolean;
+    isDesktopApp: boolean;
+    appName: string;
+    getHostname: () => string;
+    getDevice: () => Promise<string> | string;
+    useRequestHeaders?: (include: string[]) => {};
+};
+export type GetUserResponse = {
+    token?: string | null;
+    user?: User | null;
+};
+export type 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;
+};
+export type ActiveSession = {
+    id: string;
+    visitorId: string;
+    device: string;
+    appName: string;
+    location: string;
+    ipAddress: string;
+    isCurrentSession?: boolean;
+    isOnline?: boolean;
+    signedOut?: boolean;
+    dateTime: Date;
+    firstSignIn: Date;
+};

package/user-actions.d.ts

@@ -0,0 +1,15 @@
+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;
+        password: string;
+        rememberMe: boolean;
+    }) => Promise<GetUserResponse | {
+        key: string;
+    }>;
+    logout: () => Promise<void>;
+    fetchActiveSessions: () => Promise<{
+        sessions: ActiveSession[];
+    }>;
+};