@zenify-omni/chat-js 0.1.0

package/utils/auth.js

@@ -0,0 +1,205 @@
+import { UserRole, UserRoleContext } from "../constants/user.js";
+import { envSet } from "../config/env.js";
+const SessionEndReason = Object.freeze({
+  // The server-side session row is gone: signed out elsewhere, kicked by the
+  // parallel-session limit, or revoked by an admin. Refreshing cannot help.
+  REVOKED: "revoked",
+  // The credential simply aged out past the refresh window.
+  EXPIRED: "expired",
+  // Token minted by the legacy be `/v2/login` (no `sid`); ended by the FE
+  // migration nudge to move the user onto a new-issuer `sid` session.
+  LEGACY: "legacy"
+});
+const SESSION_END_REASON_KEY = "sessionEndReason";
+const markSessionEnded = (reason) => {
+  try {
+    if (!sessionStorage.getItem(SESSION_END_REASON_KEY)) {
+      sessionStorage.setItem(SESSION_END_REASON_KEY, reason);
+    }
+  } catch {
+  }
+};
+const getSessionEndReason = () => {
+  try {
+    return sessionStorage.getItem(SESSION_END_REASON_KEY);
+  } catch {
+    return null;
+  }
+};
+const clearSessionEndReason = () => {
+  try {
+    sessionStorage.removeItem(SESSION_END_REASON_KEY);
+  } catch {
+  }
+};
+const login = (user) => {
+  clearSessionEndReason();
+  localStorage.setItem("zenify-sdk-user", JSON.stringify(user));
+};
+const setUser = (user) => {
+  localStorage.setItem("zenify-sdk-user", JSON.stringify(user));
+};
+const logout = () => {
+  localStorage.removeItem("zenify-sdk-user");
+  localStorage.removeItem("smartView");
+  localStorage.removeItem("queueId");
+  localStorage.removeItem("activeWorkspaceId");
+  sessionStorage.removeItem("viewAsUserData");
+};
+const DEVICE_ID_KEY = "deviceId";
+const generateDeviceId = () => typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : `web-${Date.now()}-${Math.random().toString(36).slice(2, 12)}`;
+const getDeviceId = () => {
+  let deviceId = localStorage.getItem(DEVICE_ID_KEY);
+  if (!deviceId) {
+    deviceId = generateDeviceId();
+    localStorage.setItem(DEVICE_ID_KEY, deviceId);
+  }
+  return deviceId;
+};
+const isAdmin = () => {
+  const user = getUser();
+  return !user ? false : user?.role === UserRole.ADMINISTRATOR;
+};
+const isSupervisor = () => {
+  const user = getUser();
+  return !user ? false : user?.role === UserRole.SUPERVISOR;
+};
+function isRoleTeamLeader() {
+  const user = getUser();
+  return !user ? false : user?.role === UserRole.TEAM_LEADER;
+}
+function isRoleTeamLeaderSale() {
+  const user = getUser();
+  if (!user) return false;
+  const { role, roles = [] } = user;
+  if (roles?.length > 0) {
+    return roles.includes(UserRole.SALE_TEAM_LEADER);
+  }
+  return role === UserRole.SALE_TEAM_LEADER;
+}
+function isRoleSale() {
+  const user = getUser();
+  if (!user) return false;
+  const { role, roles = [] } = user;
+  if (roles?.length > 0) {
+    return roles.includes(UserRole.SALE);
+  }
+  return role === UserRole.SALE;
+}
+function isRoleAgent() {
+  const user = getUser();
+  return !user ? false : user?.role === UserRole.AGENT;
+}
+function isRoleSaleOrSaleLeader() {
+  const user = getUser();
+  if (!user) return false;
+  const { role, roles = [] } = user;
+  if (roles?.length > 0) {
+    return roles.includes(UserRole.SALE) || roles.includes(UserRole.SALE_TEAM_LEADER);
+  }
+  return role === UserRole.SALE || role === UserRole.SALE_TEAM_LEADER;
+}
+function checkIsViewAsMode() {
+  return !!sessionStorage.getItem("viewAsUserData");
+}
+let userCache = {
+  sessionRaw: void 0,
+  localRaw: void 0,
+  hasValue: false,
+  value: null
+};
+const getUser = () => {
+  let sessionRaw = null;
+  let localRaw = null;
+  try {
+    sessionRaw = sessionStorage.getItem("viewAsUserData");
+  } catch {
+    sessionRaw = null;
+  }
+  try {
+    localRaw = localStorage.getItem("zenify-sdk-user");
+  } catch {
+    localRaw = null;
+  }
+  if (userCache.hasValue && userCache.sessionRaw === sessionRaw && userCache.localRaw === localRaw) {
+    return userCache.value;
+  }
+  let value;
+  try {
+    value = sessionRaw ? JSON.parse(sessionRaw) : JSON.parse(localRaw);
+  } catch {
+    value = null;
+  }
+  userCache = { sessionRaw, localRaw, hasValue: true, value };
+  return value;
+};
+const renderUserRoleContext = (user) => {
+  if (!user) {
+    user = getUser();
+  }
+  const { roles = [], role } = user;
+  const userRoles = roles.length > 0 ? roles : [role].filter(Boolean);
+  return [...new Set(userRoles)].map((r) => UserRoleContext[r]).filter(Boolean).join(", ");
+};
+const decodeTokenPayload = (token) => {
+  try {
+    const seg = token?.split(".")?.[1];
+    if (!seg) return null;
+    const json = atob(seg.replace(/-/g, "+").replace(/_/g, "/"));
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+};
+const getRealTokenIdentity = () => {
+  let token;
+  try {
+    token = JSON.parse(localStorage.getItem("zenify-sdk-user") || "null")?.token;
+  } catch {
+    return {};
+  }
+  const p = decodeTokenPayload(token);
+  return {
+    sid: p?.sid,
+    user_id: (p?.user_id ?? p?.sub) != null ? String(p?.user_id ?? p?.sub) : void 0,
+    tenant_id: p?.tenant_id != null ? String(p.tenant_id) : void 0
+  };
+};
+const matchNamespacePrefix = (perm, prefix) => perm === prefix || perm.startsWith(prefix + ":");
+const isHelpDeskPlanOnly = () => {
+  const user = getUser();
+  if (!user) return false;
+  return envSet("HELP_DESK_PLAN_TENANT_IDS").has(user.tenant_id);
+};
+const ASAHI_TENANT_IDS = /* @__PURE__ */ new Set([
+  "6858fc5277924f901d276d32",
+  "646ae9cffe32b43426f45165"
+]);
+const MISA_TENANT_IDS = /* @__PURE__ */ new Set(["69bcd013c49df515076b109a"]);
+const GOOGLE_TENANT_IDS = /* @__PURE__ */ new Set([
+  "68ef2ff8cc7ace4872d0641f",
+  "646ae9cffe32b43426f45165"
+]);
+export {
+  SessionEndReason,
+  checkIsViewAsMode,
+  clearSessionEndReason,
+  decodeTokenPayload,
+  getDeviceId,
+  getRealTokenIdentity,
+  getSessionEndReason,
+  getUser,
+  isAdmin,
+  isHelpDeskPlanOnly,
+  isRoleAgent,
+  isRoleSale,
+  isRoleSaleOrSaleLeader,
+  isRoleTeamLeader,
+  isRoleTeamLeaderSale,
+  isSupervisor,
+  login,
+  logout,
+  markSessionEnded,
+  renderUserRoleContext,
+  setUser
+};

package/utils/chunk-reload-guard.js

@@ -0,0 +1,4 @@
+import "../config/env.js";
+const WINDOW_MS = 1e4;
+const DYNAMIC_IMPORT_RE = /(dynamically imported module|Loading chunk .* failed|error loading dynamically imported module|Importing a module script failed)/i;
+const ROUTER_STALE_CHUNK_RE = /(Failed to load module script|reading '(component|errorComponent|pendingComponent|notFoundComponent)')/i;

package/utils/concurrency-limiter.js

@@ -0,0 +1,30 @@
+function createConcurrencyLimiter(limit) {
+  let active = 0;
+  const queue = [];
+  const next = () => {
+    if (active >= limit || queue.length === 0) return;
+    active++;
+    const { fn, resolve, reject } = queue.shift();
+    Promise.resolve().then(fn).then(resolve, reject).finally(() => {
+      active--;
+      next();
+    });
+  };
+  return (fn) => new Promise((resolve, reject) => {
+    queue.push({ fn, resolve, reject });
+    next();
+  });
+}
+function createSingleFlight() {
+  const inflight = /* @__PURE__ */ new Map();
+  return (key, fn) => {
+    if (inflight.has(key)) return inflight.get(key);
+    const p = Promise.resolve().then(fn).finally(() => inflight.delete(key));
+    inflight.set(key, p);
+    return p;
+  };
+}
+export {
+  createConcurrencyLimiter,
+  createSingleFlight
+};

package/utils/currency.js

@@ -0,0 +1,14 @@
+function formatVND(value, scale = 1) {
+  if (value == null || isNaN(value)) return "0";
+  const num = Math.floor(Number(value) * scale);
+  return `${num.toLocaleString("vi-VN")} \u20AB`;
+}
+const usdFormatter = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+});
+export {
+  formatVND
+};

package/utils/customers.js

@@ -0,0 +1,42 @@
+import i18n from "../lib/i18n/index.js";
+import { UserRole } from "../constants/user.js";
+import { getUser } from "./auth.js";
+const sourceDetailNames = {
+  get CALL_INBOUND() {
+    return i18n.t("common:label.customerCalling", {
+      defaultValue: "Kh\xE1ch g\u1ECDi \u0111i\u1EC7n"
+    });
+  },
+  CALL_INTERNAL: "",
+  get CALL_OUTBOUND() {
+    return i18n.t("common:action.makeOutboundCall", {
+      defaultValue: "G\u1ECDi \u0111i\u1EC7n ra"
+    });
+  },
+  get chat() {
+    return i18n.t("common:label.webMessage", { defaultValue: "Tin nh\u1EAFn web" });
+  },
+  email: "Email",
+  get facebook() {
+    return i18n.t("common:label.facebookChannel", {
+      defaultValue: "K\xEAnh Facebook"
+    });
+  },
+  get hand() {
+    return i18n.t("common:action.addNew", { defaultValue: "Th\xEAm m\u1EDBi" });
+  },
+  import: "",
+  sms: "",
+  zalo: "Zalo"
+};
+const isCustomerEditableByUser = (customer) => {
+  const user = getUser();
+  if (!customer || !user) return false;
+  if ([UserRole.ADMINISTRATOR, UserRole.SUPERVISOR].includes(user.role)) {
+    return true;
+  }
+  return String(user._id) === String(customer.contact_owner_id);
+};
+export {
+  isCustomerEditableByUser
+};

package/utils/data.js

@@ -0,0 +1,178 @@
+import { DataTypes, KeyApplyTo } from "../constants/mask-data-config.js";
+import { getUser } from "./auth.js";
+import { EMAIL_REGEX } from "../constants/regex.js";
+import { replacePhonesInText } from "../lib/phone.js";
+function isInArray(value, array) {
+  if (!array || !Array.isArray(array)) {
+    return false;
+  }
+  if (array.length === 0) {
+    return false;
+  }
+  if (value === null || value === void 0) {
+    return array.some((item) => item === value);
+  }
+  if (typeof value === "object") {
+    const stringValue = JSON.stringify(value);
+    return array.some((item) => JSON.stringify(item) === stringValue);
+  }
+  return array.includes(value);
+}
+const maskDataConfigMap = /* @__PURE__ */ new Map();
+const setMaskDataConfig = (maskDataConfig = []) => {
+  if (!Array.isArray(maskDataConfig)) {
+    console.warn("maskDataConfig should be an array");
+    return;
+  }
+  maskDataConfigMap.clear();
+  maskDataConfig.forEach((config) => {
+    if (config && config.data_type) {
+      maskDataConfigMap.set(config.data_type, config);
+    }
+  });
+};
+const getMaskDataConfig = (type) => {
+  return maskDataConfigMap.get(type);
+};
+const iamRoleIdOf = (user) => {
+  const iamRole = user?.iam_role;
+  if (!iamRole) return "";
+  return String(iamRole._id ?? iamRole);
+};
+const matchUserRole = (user, values) => {
+  if (!Array.isArray(values)) return false;
+  const wanted = values.map(String);
+  if (wanted.includes(String(user.role ?? ""))) return true;
+  const iamRoleId = iamRoleIdOf(user);
+  if (iamRoleId && wanted.includes(iamRoleId)) return true;
+  return Array.isArray(user.roles) && user.roles.some((role) => wanted.includes(String(role)));
+};
+const checkMaskAppliedData = (applyTo) => {
+  const user = getUser();
+  if (!user) return false;
+  let check = false;
+  applyTo.forEach((item) => {
+    if (item.key === KeyApplyTo.USER && item?.value?.includes(user._id)) {
+      check = true;
+    }
+    if (item.key === KeyApplyTo.ROLE && matchUserRole(user, item?.value)) {
+      check = true;
+    }
+    if (item.key === KeyApplyTo.GROUP && item?.value?.map(String)?.includes(String(user.group_id))) {
+      check = true;
+    }
+    if (item.key === KeyApplyTo.ORGANIZATION && item?.value?.map(String)?.includes(String(user.organize_id))) {
+      check = true;
+    }
+  });
+  return check;
+};
+const maskPhoneNumber = (data, pattern) => {
+  if (!data || !pattern) {
+    return data;
+  }
+  const maskCount = (pattern.match(/\*/g) || []).length;
+  const visibleCount = data.length - maskCount;
+  const startsWithStar = pattern.startsWith("#");
+  const endsWithStar = pattern.endsWith("#");
+  if (pattern?.replace(/\*/g, "") === pattern) {
+    return data;
+  }
+  if (pattern?.replace(/#/g, "") === pattern) {
+    return "*".repeat(data.length);
+  }
+  const longestHashRun = Math.max(
+    ...(pattern.match(/#+/g) || [""]).map((run) => run.length)
+  );
+  if (longestHashRun >= 2) {
+    const showCount = (pattern.match(/#/g) || []).length;
+    if (showCount >= data.length) {
+      return data;
+    }
+    const hideCount = data.length - showCount;
+    if (pattern.startsWith("*")) {
+      return "*".repeat(hideCount) + data.slice(data.length - showCount);
+    }
+    return data.slice(0, showCount) + "*".repeat(hideCount);
+  }
+  if (startsWithStar && !endsWithStar) {
+    return data.substring(0, visibleCount) + "*".repeat(maskCount);
+  }
+  if (!startsWithStar && endsWithStar) {
+    return "*".repeat(maskCount) + data.substring(maskCount);
+  }
+  if (startsWithStar && endsWithStar) {
+    const leftVisible = Math.ceil(visibleCount / 2);
+    const rightVisible = visibleCount - leftVisible;
+    return data.substring(0, leftVisible) + "*".repeat(maskCount) + data.substring(data.length - rightVisible);
+  }
+  let result = "";
+  for (let i = 0; i < data.length; i++) {
+    result += pattern[i] === "*" ? "*" : data[i];
+  }
+  return result;
+};
+const maskEmail = (data, pattern) => {
+  const [local, domain] = data.split("@");
+  const atIndex = pattern.indexOf("@");
+  const leftPattern = pattern.substring(0, atIndex);
+  const rightPattern = pattern.substring(atIndex + 1);
+  const leftMaskCount = (leftPattern.match(/\*/g) || []).length;
+  const rightMaskCount = (rightPattern.match(/\*/g) || []).length;
+  let maskedLocal = local.length <= leftMaskCount ? "*".repeat(local.length) : local.slice(0, local.length - leftMaskCount) + "*".repeat(leftMaskCount);
+  let maskedDomain = domain.length <= rightMaskCount ? "*".repeat(domain.length) : "*".repeat(rightMaskCount) + domain.slice(rightMaskCount);
+  return maskedLocal + "@" + maskedDomain;
+};
+function isHasPhoneNumberMask() {
+  return !!getMaskDataConfig(DataTypes.PHONE_NUMBER);
+}
+function maskData(input) {
+  if (!input || typeof input !== "string") {
+    return input;
+  }
+  let result = input;
+  const maskingPhoneNumberConfig = getMaskDataConfig(DataTypes.PHONE_NUMBER);
+  const maskingEmailConfig = getMaskDataConfig(DataTypes.EMAIL);
+  if (maskingPhoneNumberConfig) {
+    const { masking_pattern, apply_to } = maskingPhoneNumberConfig;
+    if (checkMaskAppliedData(apply_to)) {
+      result = replacePhonesInText(result, ({ raw }) => {
+        const digits = raw.replace(/\D/g, "");
+        return maskPhoneNumber(digits, masking_pattern);
+      });
+    }
+  }
+  if (maskingEmailConfig) {
+    const { masking_pattern, apply_to } = maskingEmailConfig;
+    if (checkMaskAppliedData(apply_to) && typeof result === "string") {
+      result = result?.replace(EMAIL_REGEX, (match) => {
+        return maskEmail(match, masking_pattern);
+      });
+    }
+  }
+  return result;
+}
+function truncateText(text, maxLength = 30) {
+  if (!text) return "";
+  return text.length > maxLength ? text.slice(0, maxLength) + "..." : text;
+}
+const hasNonEmpty = (obj, keys) => {
+  if (!obj || typeof obj !== "object") return false;
+  if (!Array.isArray(keys) || keys.length === 0) return false;
+  return keys.some((key) => {
+    const val = obj[key];
+    return val !== void 0 && val !== null && val !== "";
+  });
+};
+const normalizeText = (text) => text?.toLowerCase().normalize("NFD")?.replace(/[\u0300-\u036f]/g, "").trim();
+export {
+  hasNonEmpty,
+  isHasPhoneNumberMask,
+  isInArray,
+  maskData,
+  maskEmail,
+  maskPhoneNumber,
+  normalizeText,
+  setMaskDataConfig,
+  truncateText
+};

package/utils/date.js

@@ -0,0 +1,144 @@
+import {
+  differenceInCalendarDays,
+  differenceInHours,
+  differenceInMinutes,
+  format,
+  isValid
+} from "date-fns";
+import { TZDate } from "@date-fns/tz";
+import i18n from "../lib/i18n/index.js";
+let tenantTz = "Asia/Ho_Chi_Minh";
+const isValidTz = (tz) => {
+  if (typeof tz !== "string" || !tz) return false;
+  try {
+    Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+};
+const setTenantTz = (tz) => {
+  if (isValidTz(tz)) tenantTz = tz;
+};
+const getTenantTz = () => tenantTz;
+const formatDay = (date, st) => {
+  if (!date) return "";
+  const d = new TZDate(date, tenantTz);
+  if (!isValid(d)) return "";
+  return format(d, st || "dd/MM/yyyy");
+};
+const formatDayWithTime = (date) => {
+  if (!date) return "";
+  const d = new TZDate(date, tenantTz);
+  if (!isValid(d)) return "";
+  return format(d, "dd/MM/yyyy HH:mm");
+};
+const formatTime = (date) => {
+  if (!date) return "";
+  const d = new TZDate(date, tenantTz);
+  if (!isValid(d)) return "";
+  return format(d, "HH:mm");
+};
+const formatDayWithTimeFromTimestamps = (timestamp) => {
+  if (!timestamp) return "";
+  const d = new TZDate(timestamp * 1e3, tenantTz);
+  if (!isValid(d)) return "";
+  return format(d, "dd/MM/yyyy HH:mm");
+};
+const getVNDate = (date) => new TZDate(date, tenantTz);
+const generateLastMsgTimeText = (time) => {
+  if (!time) return "";
+  const currentTime = getVNDate(/* @__PURE__ */ new Date());
+  const datedLastMsgTime = getVNDate(time);
+  if (!isValid(datedLastMsgTime)) return "";
+  const diffDays = differenceInCalendarDays(currentTime, datedLastMsgTime);
+  const diffHours = differenceInHours(currentTime, datedLastMsgTime);
+  const diffMinutes = differenceInMinutes(currentTime, datedLastMsgTime);
+  if (diffDays === 0) {
+    if (diffHours === 0) {
+      if (diffMinutes === 0) {
+        return i18n.t("common:time.justNow", { defaultValue: "V\u1EEBa xong" });
+      } else {
+        return i18n.t("common:time.minutesAgo", {
+          count: diffMinutes,
+          defaultValue: "{count} ph\xFAt tr\u01B0\u1EDBc"
+        });
+      }
+    } else if (diffHours === 1) {
+      return i18n.t("common:time.oneHourAgo", { defaultValue: "1 gi\u1EDD tr\u01B0\u1EDBc" });
+    } else if (diffHours === 2) {
+      return i18n.t("common:time.twoHoursAgo", { defaultValue: "2 gi\u1EDD tr\u01B0\u1EDBc" });
+    } else {
+      return i18n.t("common:time.today", { defaultValue: "H\xF4m nay" }) + " " + format(datedLastMsgTime, "HH:mm");
+    }
+  } else if (diffDays === 1) {
+    return i18n.t("common:time.yesterday", { defaultValue: "H\xF4m qua" }) + " " + format(datedLastMsgTime, "HH:mm");
+  } else {
+    return format(datedLastMsgTime, "dd/MM/yyyy HH:mm");
+  }
+};
+const generateReminderTimeText = (reminderTime) => {
+  if (!reminderTime) return "";
+  const currentTime = getVNDate(/* @__PURE__ */ new Date());
+  const datedReminderTime = getVNDate(reminderTime);
+  if (!isValid(datedReminderTime)) return "";
+  const diffDays = differenceInCalendarDays(datedReminderTime, currentTime);
+  const diffHours = differenceInHours(datedReminderTime, currentTime);
+  const diffMinutes = differenceInMinutes(datedReminderTime, currentTime);
+  if (diffDays === 0) {
+    if (diffHours === 0) {
+      if (diffMinutes <= 0) {
+        return format(datedReminderTime, "dd/MM/yyyy HH:mm");
+      } else {
+        return i18n.t("common:time.minutesRemaining", {
+          count: diffMinutes,
+          defaultValue: "C\xF2n {count} ph\xFAt"
+        });
+      }
+    } else if (diffHours === 1) {
+      return i18n.t("common:time.oneHourRemaining", {
+        defaultValue: "C\xF2n 1 gi\u1EDD"
+      });
+    } else if (diffHours === 2) {
+      return i18n.t("common:time.twoHoursRemaining", {
+        defaultValue: "C\xF2n 2 gi\u1EDD"
+      });
+    } else {
+      return i18n.t("common:time.today", { defaultValue: "H\xF4m nay" }) + ", " + format(datedReminderTime, "dd/MM/yyyy HH:mm");
+    }
+  } else if (diffDays === 1) {
+    return i18n.t("common:time.tomorrow", { defaultValue: "Ng\xE0y mai" }) + ", " + format(datedReminderTime, "dd/MM/yyyy HH:mm");
+  } else {
+    return format(datedReminderTime, "dd/MM/yyyy HH:mm");
+  }
+};
+const asTenant = (date) => new TZDate(date ?? /* @__PURE__ */ new Date(), getTenantTz());
+const toInstant = (tzdate) => new Date(tzdate.getTime());
+const tenantInstantFromWallClock = (date) => {
+  const d = date instanceof Date ? date : new Date(date);
+  if (!isValid(d)) return d;
+  return new Date(
+    new TZDate(
+      d.getFullYear(),
+      d.getMonth(),
+      d.getDate(),
+      d.getHours(),
+      d.getMinutes(),
+      d.getSeconds(),
+      d.getMilliseconds(),
+      getTenantTz()
+    ).getTime()
+  );
+};
+export {
+  formatDay,
+  formatDayWithTime,
+  formatDayWithTimeFromTimestamps,
+  formatTime,
+  generateLastMsgTimeText,
+  generateReminderTimeText,
+  getTenantTz,
+  getVNDate,
+  setTenantTz,
+  tenantInstantFromWallClock
+};

package/utils/debounced-invalidate.js

@@ -0,0 +1,15 @@
+const timers = /* @__PURE__ */ new Map();
+function debouncedInvalidate(queryClient, queryKey, options = {}) {
+  const { delay = 300, ...invalidateOptions } = options;
+  const mapKey = JSON.stringify(queryKey);
+  const existing = timers.get(mapKey);
+  if (existing) clearTimeout(existing);
+  const timer = setTimeout(() => {
+    timers.delete(mapKey);
+    queryClient.invalidateQueries({ queryKey, ...invalidateOptions });
+  }, delay);
+  timers.set(mapKey, timer);
+}
+export {
+  debouncedInvalidate
+};