@inzombieland/nuxt-common 0.0.2 → 0.0.5

package/runtime/packages/api/helpers/date-helper.mjs

@@ -0,0 +1,231 @@
+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.getTime());
+  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)
+    // eslint-disable-line no-mixed-operators
+  };
+  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/runtime/packages/api/helpers/index.d.ts

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

package/runtime/packages/api/helpers/index.mjs

@@ -0,0 +1,15 @@
+export { apiHelper } from "./api-helper.mjs";
+export { dateHelper } from "./date-helper.mjs";
+export { device } from "./current-device.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/runtime/packages/api/index.d.ts

@@ -0,0 +1,26 @@
+import type { ActiveSession, Fetch, FetchConfig } from "./types";
+export type { ActiveSession, Fetch, FetchConfig };
+export { useUser, type User } from "./use-user";
+export { getVisitor, getVisitorId, type Visitor } from "./get-visitor";
+export declare function initApiFetch($fetch: Fetch, config: FetchConfig): {
+    fetch: Fetch;
+    getUser: () => Promise<{
+        token?: string | null;
+        user?: import("src/runtime/api").User | null;
+    }>;
+    getVisitorIdentifier: () => Promise<void>;
+    useApiFetch: () => Fetch;
+    userActions: {
+        signIn: (body: {
+            username: string;
+            password: string;
+            rememberMe: boolean;
+        }) => Promise<{
+            token?: string | null;
+            user?: import("src/runtime/api").User | null;
+        } | {
+            key: string;
+        }>;
+        logout: () => Promise<void>;
+    };
+};

package/runtime/packages/api/index.mjs

@@ -0,0 +1,50 @@
+import { createApiFetch, flush, setToken } from "./api-client.mjs";
+import { createApiGetUser } from "./get-user.mjs";
+import { createApiGetVisitorIdentifier } from "./get-visitor.mjs";
+import { createApiRefreshToken } from "./refresh-token.mjs";
+import { useApiActions } from "./use-api-actions.mjs";
+import { useUser } from "./use-user.mjs";
+export { useUser } from "./use-user.mjs";
+export { getVisitor, getVisitorId } from "./get-visitor.mjs";
+const apiActions = useApiActions();
+export function initApiFetch($fetch, config) {
+  const fetch = createApiFetch($fetch, config);
+  const getUser = createApiGetUser(fetch, config);
+  const getVisitorIdentifier = createApiGetVisitorIdentifier(config);
+  const refreshToken = createApiRefreshToken(fetch, config);
+  apiActions.value = {
+    initialized: true,
+    getVisitorIdentifier,
+    refreshToken
+  };
+  const useApiFetch = () => fetch;
+  const userActions = {
+    signIn: async (body) => {
+      const response = await fetch("/account/0/signin", {
+        body,
+        method: "POST",
+        ...config.useRequestHeaders?.(["cookie"]) ?? {}
+      });
+      const { accessToken, key, ...rest } = response;
+      if (!accessToken) {
+        if (key) {
+          return { key };
+        }
+        throw rest;
+      }
+      setToken(accessToken);
+      return await getUser();
+    },
+    logout: async () => {
+      const user = useUser();
+      try {
+        if (user.value) {
+          await fetch("/account/1/logout", { method: "POST" });
+        }
+      } finally {
+        flush();
+      }
+    }
+  };
+  return { fetch, getUser, getVisitorIdentifier, useApiFetch, userActions };
+}

package/runtime/packages/api/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@inzombieland/api",
+  "version": "1.15.0",
+  "type": "module",
+  "license": "ISC",
+  "main": "./index.mjs",
+  "types": "./index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@fingerprintjs/fingerprintjs": "^4.6.2",
+    "@vueuse/core": "^12.8.2",
+    "centrifuge": "^5.3.4",
+    "ofetch": "^1.4.1",
+    "rxjs": "^7.8.2",
+    "vue": "^3.5.13",
+    "zod": "^3.24.2"
+  }
+}

package/runtime/packages/api/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/runtime/packages/api/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/runtime/packages/api/types.d.ts

@@ -0,0 +1,51 @@
+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>;
+    useRequestHeaders?: (include: 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/runtime/packages/api/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/runtime/packages/api/use-api-actions.mjs

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

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

@@ -0,0 +1,47 @@
+export declare 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 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/runtime/packages/api/use-user.mjs

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

package/runtime/packages/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export { phoneHelper } from "./phone-helper";
+export { stringHelper } from "./string-helper";
+export declare function once<T extends (...args: any[]) => any>(fn: T): T;

package/runtime/packages/helpers/index.mjs

@@ -0,0 +1,14 @@
+export { phoneHelper } from "./phone-helper.mjs";
+export { stringHelper } from "./string-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/runtime/packages/helpers/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@inzombieland/helpers",
+  "version": "1.15.0",
+  "type": "module",
+  "license": "ISC",
+  "main": "./index.mjs",
+  "types": "./index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  }
+}

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

@@ -0,0 +1,13 @@
+export declare function getPlainPhoneNumber(value: string): string;
+/**
+ * Преобразование номера телефона в формат: +7 (987) 777-88-99
+ * @param value - номер телефона
+ * @param addLastSymbol -
+ */
+export declare function convertToPhone(value: string, addLastSymbol?: boolean): string;
+export declare function maskPhone(phone?: string): string;
+export declare const phoneHelper: {
+    getPlainPhoneNumber: typeof getPlainPhoneNumber;
+    convertToPhone: typeof convertToPhone;
+    maskPhone: typeof maskPhone;
+};

package/runtime/packages/helpers/phone-helper.mjs

@@ -0,0 +1,58 @@
+export function getPlainPhoneNumber(value) {
+  const symbol = "+ ";
+  const tempNumber = value.replace(symbol, "").replace(symbol.trim(), "");
+  return tempNumber.replaceAll(/\D+/g, "");
+}
+export function convertToPhone(value, addLastSymbol = true) {
+  const plainNumber = getPlainPhoneNumber(value);
+  if (plainNumber.length === 0) {
+    return value;
+  }
+  const mask = getCountryMask(plainNumber);
+  return getFormattedByMask(plainNumber, mask, addLastSymbol);
+}
+function getCountryMask(value = "") {
+  if (value.length === 0) {
+    return "";
+  }
+  if (value.startsWith("7")) {
+    return "+# (###) ###-##-###########";
+  }
+  if (value.startsWith("8")) {
+    return "# (###) ###-##-###########";
+  }
+  if (value.startsWith("1")) {
+    return "+# ### ### ## ###########";
+  }
+  if (value.startsWith("375")) {
+    return "+### ## ### ## ##########";
+  }
+  if (value.startsWith("380")) {
+    return "+### ## ### ## ##########";
+  }
+  return "+####################";
+}
+function getFormattedByMask(plainNumber, mask, addLastSymbol) {
+  let number = "";
+  let symbolIterator = 0;
+  [...mask].forEach((value) => {
+    if (plainNumber.length >= symbolIterator) {
+      if (value === "#") {
+        if (plainNumber.length > symbolIterator) {
+          number += plainNumber[symbolIterator];
+        }
+        symbolIterator++;
+      } else {
+        const notPasteSymbol = symbolIterator === plainNumber.length && !addLastSymbol;
+        if (!notPasteSymbol) {
+          number += value;
+        }
+      }
+    }
+  });
+  return number;
+}
+export function maskPhone(phone = "") {
+  return `+${phone.slice(0, 1)} *****${phone.slice(-4)}`;
+}
+export const phoneHelper = { getPlainPhoneNumber, convertToPhone, maskPhone };

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

@@ -0,0 +1,4 @@
+export declare function maskEmail(email?: string): string;
+export declare const stringHelper: {
+    maskEmail: typeof maskEmail;
+};

package/runtime/packages/helpers/string-helper.mjs

@@ -0,0 +1,8 @@
+export function maskEmail(email = "") {
+  const [name, domain] = email.split("@");
+  if (name && name.length < 5) return email;
+  return `${name?.slice(0, 2)}*****${name?.slice(-2)}@${domain}`;
+}
+export const stringHelper = {
+  maskEmail
+};