@zenify-omni/chat-js 0.1.0

package/utils/emoticon.js

@@ -0,0 +1,134 @@
+const EMOTICON_MAP = [
+  // 9-character (Zalo)
+  [":handclap", "\u{1F44F}"],
+  // 8-character (Zalo)
+  ["/-thanks", "\u{1F64F}"],
+  ["/-strong", "\u{1F44D}"],
+  // 7-character (Zalo)
+  ["/-heart", "\u2764\uFE0F"],
+  ["/-share", "\u{1F4E4}"],
+  ["/-break", "\u{1F494}"],
+  ["/-punch", "\u{1F44A}"],
+  ["/-loveu", "\u{1F970}"],
+  // 6-character (Zalo)
+  ["/-bome", "\u{1F4A3}"],
+  ["/-beer", "\u{1F37A}"],
+  ["/-weak", "\u{1F44E}"],
+  ["/-rose", "\u{1F339}"],
+  ["/-shit", "\u{1F4A9}"],
+  ["/-fade", "\u{1F635}"],
+  // 5-character (Zalo)
+  [":-bye", "\u{1F44B}"],
+  ["/-bad", "\u{1F44E}"],
+  [":-dig", "\u{1F924}"],
+  [":wipe", "\u{1F605}"],
+  // 4-character
+  [">:-(", "\u{1F621}"],
+  [":)))", "\u{1F601}"],
+  [":(((", "\u{1F62D}"],
+  [":-))", "\u{1F604}"],
+  ["/-ok", "\u{1F44C}"],
+  ["/-no", "\u{1F645}"],
+  ["/-li", "\u2600\uFE0F"],
+  ["/-bd", "\u{1F382}"],
+  [":-((", "\u{1F62D}"],
+  ["_()_", "\u{1F64F}"],
+  [":--|", "\u{1F610}"],
+  // 3-character
+  ["/-v", "\u270C\uFE0F"],
+  [">:(", "\u{1F621}"],
+  [":'(", "\u{1F62D}"],
+  [":')", "\u{1F602}"],
+  ["=))", "\u{1F602}"],
+  [":))", "\u{1F604}"],
+  [":((", "\u{1F622}"],
+  [";))", "\u{1F60F}"],
+  [":-)", "\u{1F642}"],
+  [":-(", "\u{1F614}"],
+  [":-P", "\u{1F61B}"],
+  [":-p", "\u{1F61B}"],
+  [":-*", "\u{1F618}"],
+  [":-|", "\u{1F610}"],
+  [":-D", "\u{1F604}"],
+  [":-O", "\u{1F62E}"],
+  [":-o", "\u{1F62E}"],
+  [":-h", "\u{1F620}"],
+  [":-f", "\u{1F923}"],
+  [":-l", "\u{1F611}"],
+  [":-r", "\u{1F60F}"],
+  [":-<", "\u{1F61E}"],
+  [";-/", "\u{1F615}"],
+  [";xx", "\u{1F60D}"],
+  [";-d", "\u{1F601}"],
+  [";-a", "\u{1F628}"],
+  [";-s", "\u{1F633}"],
+  [";-x", "\u{1F910}"],
+  ["p-(", "\u{1F623}"],
+  ["--b", "\u{1F613}"],
+  ["x-)", "\u{1F60E}"],
+  ["b-)", "\u{1F60E}"],
+  ["8-)", "\u{1F913}"],
+  ["|-)", "\u{1F634}"],
+  ["&-(", "\u{1F630}"],
+  [">-|", "\u{1F624}"],
+  ["$-)", "\u{1F911}"],
+  ["B-)", "\u{1F60E}"],
+  [";-)", "\u{1F609}"],
+  ["O_O", "\u{1F633}"],
+  ["o_o", "\u{1F633}"],
+  ["T_T", "\u{1F62D}"],
+  ["T.T", "\u{1F62D}"],
+  ["^_^", "\u{1F60A}"],
+  ["*_*", "\u{1F929}"],
+  ["-_-", "\u{1F611}"],
+  ["~_~", "\u{1F634}"],
+  ["o.O", "\u{1F928}"],
+  ["O.O", "\u{1F633}"],
+  ["</3", "\u{1F494}"],
+  // 2-character
+  [":>", "\u{1F604}"],
+  [":D", "\u{1F604}"],
+  [":)", "\u{1F642}"],
+  [":(", "\u{1F61E}"],
+  [";)", "\u{1F609}"],
+  [":P", "\u{1F61B}"],
+  [":p", "\u{1F61B}"],
+  [":O", "\u{1F62E}"],
+  [":o", "\u{1F62E}"],
+  [":*", "\u{1F618}"],
+  [":|", "\u{1F610}"],
+  [":v", "\u{1F605}"],
+  [":3", "\u{1F63A}"],
+  ["=)", "\u{1F642}"],
+  ["=(", "\u{1F61E}"],
+  ["=P", "\u{1F61C}"],
+  ["=p", "\u{1F61C}"],
+  ["=*", "\u{1F617}"],
+  ["=D", "\u{1F601}"],
+  ["^^", "\u{1F60A}"],
+  ["<3", "\u2764\uFE0F"],
+  ["B)", "\u{1F60E}"],
+  ["8)", "\u{1F60E}"]
+  // ['XD', '😆'],
+  // ['xD', '😆'],
+];
+const EMOTICON_REGEX = new RegExp(
+  "(?<=^|\\s)(?:" + EMOTICON_MAP.map(([e]) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(
+    "|"
+  ) + ")(?=\\s|$)",
+  "g"
+);
+const EMOTICON_LOOKUP = new Map(EMOTICON_MAP);
+const URL_LIKE = /https?:\/\/\S+|[-\w.]{2,256}\.[a-z]{2,7}\S*/gi;
+function replaceEmoticons(html) {
+  if (!html) return html;
+  return html.split(/(<[^>]*>)/).map((part, i) => {
+    if (i % 2 !== 0) return part;
+    return part.replace(URL_LIKE, "\0$&\0").split("\0").map(
+      (seg, j) => j % 2 === 0 ? seg.replace(EMOTICON_REGEX, (m) => EMOTICON_LOOKUP.get(m) ?? m) : seg
+    ).join("");
+  }).join("");
+}
+export {
+  replaceEmoticons
+};

package/utils/export.js

@@ -0,0 +1,7 @@
+import * as FileSaver from "file-saver";
+import "../config/env.js";
+let xlsxPromise = null;
+const ensureXLSX = () => {
+  if (!xlsxPromise) xlsxPromise = import("xlsx-js-style");
+  return xlsxPromise;
+};

package/utils/field-layout.js

@@ -0,0 +1,33 @@
+function asKeyList(value) {
+  return Array.isArray(value) ? value : [];
+}
+function normalizeFieldOverride(raw) {
+  if (Array.isArray(raw)) return { items: raw, hiddenKeys: [] };
+  if (raw && Array.isArray(raw.items)) {
+    return {
+      items: raw.items,
+      hiddenKeys: asKeyList(raw.hiddenKeys)
+    };
+  }
+  return null;
+}
+function mergeFieldOrder(rawOverride, liveDefaultKeys) {
+  const override = normalizeFieldOverride(rawOverride);
+  const defaultKeys = asKeyList(liveDefaultKeys);
+  if (!override) return defaultKeys;
+  const known = /* @__PURE__ */ new Set([...override.items, ...override.hiddenKeys]);
+  const kept = override.items.filter((key) => defaultKeys.includes(key));
+  const added = defaultKeys.filter((key) => !known.has(key));
+  return [...kept, ...added];
+}
+function toFieldOverride(shownKeys, hiddenByKey) {
+  return {
+    items: asKeyList(shownKeys),
+    hiddenKeys: Object.keys(hiddenByKey || {}).filter((k) => hiddenByKey[k])
+  };
+}
+export {
+  mergeFieldOrder,
+  normalizeFieldOverride,
+  toFieldOverride
+};

package/utils/filter-adapters.js

@@ -0,0 +1,9 @@
+import { allUser as getAllUsers } from "../api/user.js";
+const handleSearchUsers = async (keyword) => {
+  if (keyword.length < 2) return [];
+  const { data } = await getAllUsers({ keyword });
+  return data?.list?.map((user) => ({
+    value: user._id,
+    label: user.name
+  })) ?? [];
+};

package/utils/filter.js

@@ -0,0 +1,18 @@
+const toOptionId = (value) => {
+  if (value && typeof value === "object") {
+    return value.value?.toString();
+  }
+  return value?.toString();
+};
+const isEmptyRuleValue = (value) => {
+  if (value === null || value === void 0 || value === "") return true;
+  if (Array.isArray(value)) return value.length === 0;
+  if (value instanceof Date) return false;
+  if (typeof value === "object") {
+    return Object.values(value).every(
+      (item) => item === null || item === void 0 || item === ""
+    );
+  }
+  return false;
+};
+const SYSTEM_FILTER_FIELD_KEYS = /* @__PURE__ */ new Set(["ticket_form_id"]);

package/utils/formatters.js

@@ -0,0 +1,6 @@
+const formatNumber = (value) => {
+  return new Intl.NumberFormat("vi-VN").format(value);
+};
+export {
+  formatNumber
+};

package/utils/image-compression.js

@@ -0,0 +1,169 @@
+import imageCompression from "browser-image-compression";
+const QUALITY_FLOOR = 0.5;
+const DIMENSION_FLOOR = 0.7;
+const QUALITY_STEPS = [
+  0.9,
+  0.85,
+  0.8,
+  0.75,
+  0.7,
+  0.65,
+  0.6,
+  0.55,
+  QUALITY_FLOOR
+];
+const DIMENSION_STEPS = [0.95, 0.9, 0.85, 0.8, 0.75, DIMENSION_FLOOR];
+const ALPHA_SAMPLE_TARGET = 1e5;
+const MAX_OUTPUT_EDGE = 2048;
+const ALPHA_CAPABLE_TYPES = ["image/png", "image/webp"];
+async function detectTransparency(file) {
+  if (!ALPHA_CAPABLE_TYPES.includes(file.type)) return false;
+  try {
+    const bitmap = await createImageBitmap(file);
+    const canvas = document.createElement("canvas");
+    canvas.width = bitmap.width;
+    canvas.height = bitmap.height;
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(bitmap, 0, 0);
+    bitmap.close();
+    const { data } = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    const pixelCount = data.length / 4;
+    const stride = Math.max(1, Math.floor(pixelCount / ALPHA_SAMPLE_TARGET));
+    for (let p = 0; p < pixelCount; p += stride) {
+      if (data[p * 4 + 3] < 255) return true;
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function getLargestEdge(file) {
+  try {
+    const bitmap = await createImageBitmap(file);
+    const edge = Math.max(bitmap.width, bitmap.height);
+    bitmap.close();
+    return edge;
+  } catch {
+    return 0;
+  }
+}
+function normalizeOutput(file, type) {
+  const ext = type === "image/png" ? "png" : "jpg";
+  const base = (file.name || "image").replace(/\.[^.]+$/, "");
+  const newName = `${base}.${ext}`;
+  if (file instanceof File && file.name === newName && file.type === type) {
+    return file;
+  }
+  return new File([file], newName, { type });
+}
+async function flattenOnWhite(file) {
+  const bitmap = await createImageBitmap(file);
+  const canvas = document.createElement("canvas");
+  canvas.width = bitmap.width;
+  canvas.height = bitmap.height;
+  const ctx = canvas.getContext("2d");
+  ctx.fillStyle = "#ffffff";
+  ctx.fillRect(0, 0, canvas.width, canvas.height);
+  ctx.drawImage(bitmap, 0, 0);
+  bitmap.close();
+  const blob = await new Promise(
+    (resolve) => canvas.toBlob(resolve, "image/jpeg", 0.92)
+  );
+  if (!blob) throw new Error("canvas.toBlob returned null");
+  const base = (file.name || "image").replace(/\.[^.]+$/, "");
+  return new File([blob], `${base}.jpg`, { type: "image/jpeg" });
+}
+async function compressOnce(file, { quality, maxWidthOrHeight, fileType }) {
+  const options = {
+    maxSizeMB: Number.MAX_SAFE_INTEGER,
+    initialQuality: quality,
+    useWebWorker: true,
+    preserveExif: false,
+    fileType,
+    alwaysKeepResolution: maxWidthOrHeight == null
+  };
+  if (maxWidthOrHeight != null) options.maxWidthOrHeight = maxWidthOrHeight;
+  const out = await imageCompression(file, options);
+  return normalizeOutput(out, fileType);
+}
+async function compressImageForChannel(file, { maxSizeBytes, maxEdge = MAX_OUTPUT_EDGE }) {
+  const originalSize = file.size;
+  let working = file;
+  const largestEdge = await getLargestEdge(working);
+  const needsEdgeReduce = largestEdge > 0 && maxEdge > 0 && largestEdge > maxEdge;
+  const withinSize = !maxSizeBytes || working.size <= maxSizeBytes;
+  const isSafeFormat = working.type === "image/jpeg" || working.type === "image/png";
+  if (isSafeFormat && withinSize && !needsEdgeReduce) {
+    return {
+      file: working,
+      wasCompressed: working !== file,
+      stillTooLarge: false,
+      originalSize,
+      finalSize: working.size
+    };
+  }
+  let outputType = "image/jpeg";
+  if (await detectTransparency(working)) {
+    try {
+      working = await flattenOnWhite(working);
+    } catch {
+      outputType = "image/png";
+    }
+  }
+  const measuredEdge = largestEdge > 0 ? largestEdge : maxEdge;
+  const baseEdge = needsEdgeReduce ? maxEdge : measuredEdge;
+  const fits = (size) => !maxSizeBytes || size <= maxSizeBytes;
+  let smallest = working;
+  try {
+    for (const quality of QUALITY_STEPS) {
+      const out = await compressOnce(working, {
+        quality,
+        maxWidthOrHeight: baseEdge > 0 ? baseEdge : void 0,
+        fileType: outputType
+      });
+      if (out.size < smallest.size) smallest = out;
+      if (fits(out.size)) {
+        return {
+          file: out,
+          wasCompressed: true,
+          stillTooLarge: false,
+          originalSize,
+          finalSize: out.size
+        };
+      }
+    }
+    if (baseEdge > 0) {
+      for (const scale of DIMENSION_STEPS) {
+        const out = await compressOnce(working, {
+          quality: QUALITY_FLOOR,
+          maxWidthOrHeight: Math.round(baseEdge * scale),
+          fileType: outputType
+        });
+        if (out.size < smallest.size) smallest = out;
+        if (fits(out.size)) {
+          return {
+            file: out,
+            wasCompressed: true,
+            stillTooLarge: false,
+            originalSize,
+            finalSize: out.size
+          };
+        }
+      }
+    }
+  } catch {
+  }
+  return {
+    file: smallest,
+    wasCompressed: smallest !== file,
+    stillTooLarge: maxSizeBytes ? smallest.size > maxSizeBytes : false,
+    originalSize,
+    finalSize: smallest.size
+  };
+}
+export {
+  DIMENSION_FLOOR,
+  MAX_OUTPUT_EDGE,
+  QUALITY_FLOOR,
+  compressImageForChannel
+};

package/utils/leads.js

@@ -0,0 +1,13 @@
+import { UserRole } from "../constants/user.js";
+import { getUser } from "./auth.js";
+const isLeadEditableByUser = (lead) => {
+  const user = getUser();
+  if (!lead || !user) return false;
+  if ([UserRole.ADMINISTRATOR, UserRole.SUPERVISOR].includes(user.role)) {
+    return true;
+  }
+  return String(user._id) === String(lead.lead_owner_id);
+};
+export {
+  isLeadEditableByUser
+};

package/utils/microlink.js

@@ -0,0 +1,20 @@
+const fetchMicrolinkPreview = async (url) => {
+  const fullUrl = url?.startsWith("http") ? url : `https://${url}`;
+  const response = await fetch(
+    `https://api.microlink.io?url=${encodeURIComponent(fullUrl)}`
+  );
+  if (!response.ok) {
+    throw new Error(`Microlink API error: ${response.status}`);
+  }
+  const json = await response.json();
+  return json?.data ?? null;
+};
+const LINK_PREVIEW_QUERY_OPTIONS = {
+  staleTime: Infinity,
+  gcTime: 30 * 60 * 1e3,
+  retry: 1
+};
+export {
+  LINK_PREVIEW_QUERY_OPTIONS,
+  fetchMicrolinkPreview
+};

package/utils/org-tree.js

@@ -0,0 +1,108 @@
+function eqId(a, b) {
+  if (a == null || b == null) return false;
+  return Number(a) === Number(b);
+}
+function normalizeNode(n) {
+  return {
+    ...n,
+    id: Number(n.id),
+    parent_id: Number(n.parent_id) || 0,
+    path: n.path || String(n.id)
+  };
+}
+function buildTree(list) {
+  if (!list?.length) return [];
+  const nodes = list.map(normalizeNode);
+  const idSet = new Set(nodes.map((n) => n.id));
+  const ROOT = 0;
+  const byParent = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const parentKey = n.parent_id === 0 || !idSet.has(n.parent_id) ? ROOT : n.parent_id;
+    const arr = byParent.get(parentKey) || [];
+    arr.push(n);
+    byParent.set(parentKey, arr);
+  }
+  const make = (parentId) => {
+    const children = byParent.get(parentId) || [];
+    return children.slice().sort((a, b) => a.name.localeCompare(b.name, "vi")).map((n) => {
+      const kids = make(Number(n.id));
+      return { ...n, children: kids.length > 0 ? kids : void 0 };
+    });
+  };
+  return make(ROOT);
+}
+function findNode(list, id) {
+  if (!list?.length || id == null) return null;
+  return list.find((n) => eqId(n.id, id)) || null;
+}
+function getDescendants(list, id) {
+  if (!list?.length || id == null) return [];
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const n of list) {
+    const p = Number(n.parent_id);
+    if (!childrenByParent.has(p)) childrenByParent.set(p, []);
+    childrenByParent.get(p).push(n);
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [...childrenByParent.get(Number(id)) || []];
+  while (stack.length) {
+    const node = stack.pop();
+    const nid = Number(node.id);
+    if (seen.has(nid)) continue;
+    seen.add(nid);
+    out.push(node);
+    const kids = childrenByParent.get(nid);
+    if (kids) stack.push(...kids);
+  }
+  return out;
+}
+function getPathIds(node) {
+  if (!node) return [];
+  const raw = node.path || String(node.id);
+  return raw.split(",").map((s) => Number(s)).filter((n) => !Number.isNaN(n));
+}
+function getPathLabels(list, node, separator = " \u203A ") {
+  if (!node) return "";
+  return getPathIds(node).map((id) => findNode(list, id)?.name).filter(Boolean).join(separator);
+}
+function getGroupDisplayName(groupId, list, fallbackName = "") {
+  if (groupId == null) return fallbackName || "";
+  if (!list?.length) return fallbackName || "";
+  const node = findNode(list, groupId);
+  if (!node) return fallbackName || "";
+  return getPathLabels(list, node);
+}
+function getGroupNodeName(groupId, list, fallbackName = "") {
+  if (groupId == null) return fallbackName || "";
+  if (!list?.length) return fallbackName || "";
+  const node = findNode(list, groupId);
+  return node?.name || fallbackName || "";
+}
+function filterBySearch(list, query) {
+  if (!query?.trim()) return null;
+  const q = query.trim().toLowerCase();
+  const matched = list.filter((n) => n.name?.toLowerCase().includes(q));
+  if (!matched.length) return /* @__PURE__ */ new Set();
+  const visible = /* @__PURE__ */ new Set();
+  for (const node of matched) {
+    visible.add(Number(node.id));
+    for (const id of getPathIds(node)) visible.add(id);
+    for (const child of getDescendants(list, node.id)) {
+      visible.add(Number(child.id));
+    }
+  }
+  return visible;
+}
+export {
+  buildTree,
+  eqId,
+  filterBySearch,
+  findNode,
+  getDescendants,
+  getGroupDisplayName,
+  getGroupNodeName,
+  getPathIds,
+  getPathLabels,
+  normalizeNode
+};