@zenify-omni/chat-ui-react-js 0.1.0

package/hooks/use-chat-permission.js

@@ -0,0 +1,68 @@
+import { useLayoutEffect, useMemo } from "react";
+import { getUser } from "@zenify-omni/chat-js/utils/auth.js";
+import useChatStore from "../store/chat-store.js";
+import {
+  isReceivedChat,
+  isClosedChat
+} from "../store/chat-store-helpers.js";
+import {
+  isZaloPersonal,
+  checkIsSpecialTenant,
+  checkCanChatSpecialTenant,
+  getTopPriorityTicket
+} from "../components/chat-route/util.js";
+import { useAllFieldTicket } from "./use-setting-common.js";
+function useChatPermission({ chatRoom, chatRoomId, isZaloConnected }) {
+  const user = getUser();
+  const setIsChatAllowed = useChatStore((state) => state.setIsChatAllowed);
+  const isSpecialTenant = checkIsSpecialTenant();
+  const ticketFields = useAllFieldTicket("all", { enabled: isSpecialTenant });
+  const canChatSpecialTenant = useMemo(
+    () => checkCanChatSpecialTenant({
+      ticketFields,
+      ticketList: chatRoom?.tickets
+    }),
+    [ticketFields, chatRoom?.tickets]
+  );
+  const topPriorityTicket = useMemo(
+    () => getTopPriorityTicket({ ticketList: chatRoom?.tickets, ticketFields }),
+    [ticketFields, chatRoom?.tickets]
+  );
+  const inRoomIds = useMemo(
+    () => (chatRoom?.users_in_room || []).map((x) => x._id) || [],
+    [chatRoom]
+  );
+  const isInRoomInSession = inRoomIds.includes(user?._id);
+  const isInRoomInTicket = (chatRoom?.tickets || []).some(
+    (ticket) => [...ticket?.cc_users || [], ticket.assign_agent_id].includes(user?._id)
+  );
+  const isChatAllowed = useMemo(() => {
+    if (chatRoom?._id !== chatRoomId) return false;
+    if (isClosedChat(chatRoom)) return false;
+    if (user?.can_take_over && chatRoom?.extra_data?.pzalo_type !== "personal")
+      return true;
+    if (isZaloPersonal(chatRoom)) {
+      if (!isZaloConnected) return false;
+      return isSpecialTenant ? canChatSpecialTenant && isReceivedChat(chatRoom) : (isInRoomInSession || isInRoomInTicket) && isReceivedChat(chatRoom);
+    }
+    return isSpecialTenant ? canChatSpecialTenant && isReceivedChat(chatRoom) : (isInRoomInSession || isInRoomInTicket) && isReceivedChat(chatRoom);
+  }, [
+    chatRoomId,
+    canChatSpecialTenant,
+    chatRoom,
+    isInRoomInSession,
+    isInRoomInTicket,
+    isSpecialTenant,
+    isZaloConnected,
+    user?.can_take_over
+  ]);
+  useLayoutEffect(() => {
+    setIsChatAllowed(isChatAllowed);
+  }, [isChatAllowed, setIsChatAllowed, chatRoom?._id]);
+  return { isChatAllowed, topPriorityTicket, canChatSpecialTenant };
+}
+var use_chat_permission_default = useChatPermission;
+export {
+  use_chat_permission_default as default,
+  useChatPermission
+};

package/hooks/use-chat-room-detail.js

@@ -0,0 +1,44 @@
+import { useQuery } from "@tanstack/react-query";
+import QUERY_KEY from "@zenify-omni/chat-js/constants/use-query-key.js";
+import { getChatRoomDetail } from "@zenify-omni/chat-js/api/chatroom.js";
+import useChatStore from "../store/chat-store.js";
+function useChatRoomDetail(chatRoomId) {
+  const lastRefreshTimeTicketPage = useChatStore(
+    (state) => state.lastRefreshTimeTicketPage
+  );
+  const {
+    data: chatRoom,
+    isLoading,
+    isFetching
+  } = useQuery({
+    queryKey: [
+      QUERY_KEY.GET_CHAT_ROOM_DETAIL,
+      { chatRoomId, last_refresh_time: lastRefreshTimeTicketPage }
+    ],
+    queryFn: async ({ signal }) => {
+      const { data } = await getChatRoomDetail(
+        chatRoomId,
+        { ignore_state: true },
+        signal
+      );
+      const nextAssignedId = data?.session?.assigned_id;
+      const store = useChatStore.getState();
+      const existingChat = store.chatList.find((c) => c._id === chatRoomId);
+      if (existingChat && nextAssignedId && nextAssignedId !== existingChat.assigned?._id) {
+        const inRoom = data?.users_in_room?.find((u) => u._id === nextAssignedId);
+        store.updateChatDetail(chatRoomId, {
+          assigned: { _id: nextAssignedId, name: inRoom?.name }
+        });
+      }
+      return data;
+    },
+    placeholderData: (prev) => prev,
+    enabled: !!chatRoomId
+  });
+  return { chatRoom, isLoading, isFetching };
+}
+var use_chat_room_detail_default = useChatRoomDetail;
+export {
+  use_chat_room_detail_default as default,
+  useChatRoomDetail
+};

package/hooks/use-chat-selection.js

@@ -0,0 +1,26 @@
+import { useCallback, useEffect } from "react";
+import { useShallow } from "zustand/react/shallow";
+import useChatStore from "../store/chat-store.js";
+function useChatSelection(chatRoomId, chatRoom) {
+  const [isSelectMode, selectedMessages, setSelectMode, setForwardMessage] = useChatStore(
+    useShallow((state) => [
+      state.isSelectMode,
+      state.selectedMessages,
+      state.setSelectMode,
+      state.setForwardMessage
+    ])
+  );
+  useEffect(() => {
+    setSelectMode(false);
+  }, [chatRoomId]);
+  const forwardSelected = useCallback(() => {
+    if (selectedMessages.length === 0) return;
+    setForwardMessage({ messages: selectedMessages, ticket: chatRoom });
+  }, [selectedMessages, setForwardMessage, chatRoom]);
+  return { isSelectMode, selectedMessages, setSelectMode, forwardSelected };
+}
+var use_chat_selection_default = useChatSelection;
+export {
+  use_chat_selection_default as default,
+  useChatSelection
+};

package/hooks/use-chat-sort.js

@@ -0,0 +1,69 @@
+import { useCallback, useEffect, useState } from "react";
+import { useShallow } from "zustand/react/shallow";
+import {
+  CHAT_SORT_VALUES,
+  ChatSortValue,
+  DEFAULT_CHAT_SORT
+} from "@zenify-omni/chat-js/constants/chat-message.js";
+import useChatConfigs from "./use-chat-configs.js";
+import useUpdateUserConfig from "./use-update-user-config.js";
+import useChatStore from "../store/chat-store.js";
+import { checkIsViewAsMode, getUser } from "@zenify-omni/chat-js/utils/auth.js";
+let hydratedChatSortUserId;
+function resetChatSortHydration() {
+  hydratedChatSortUserId = void 0;
+}
+const readSavedSort = (raw) => {
+  if (typeof raw !== "string") return void 0;
+  if (CHAT_SORT_VALUES.includes(raw)) return raw;
+  try {
+    const parsed = JSON.parse(raw);
+    return CHAT_SORT_VALUES.includes(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+};
+function useChatSort() {
+  const userId = getUser()?._id ?? null;
+  const [sort, setChatSort] = useChatStore(
+    useShallow((state) => [state.chatSort, state.setChatSort])
+  );
+  const { userConfig, chatRules, isReady: isChatConfigReady } = useChatConfigs();
+  const { mutate } = useUpdateUserConfig();
+  const [hydratedUserId, setHydratedUserId] = useState(hydratedChatSortUserId);
+  const isSortReady = hydratedUserId === userId;
+  useEffect(() => {
+    if (isSortReady || !isChatConfigReady) return;
+    if (hydratedChatSortUserId !== userId) {
+      hydratedChatSortUserId = userId;
+      const saved = readSavedSort(userConfig?.chat_sort);
+      const next = saved ?? (chatRules?.sort_chat ? ChatSortValue.UnansweredFirst : DEFAULT_CHAT_SORT);
+      if (next !== sort) setChatSort(next);
+    }
+    setHydratedUserId(userId);
+  }, [
+    isSortReady,
+    userId,
+    isChatConfigReady,
+    userConfig,
+    chatRules,
+    sort,
+    setChatSort
+  ]);
+  const setSort = useCallback(
+    (value) => {
+      if (!CHAT_SORT_VALUES.includes(value)) return;
+      setChatSort(value);
+      if (checkIsViewAsMode()) return;
+      mutate({ chatSort: value });
+    },
+    [setChatSort, mutate]
+  );
+  return { sort, setSort, isSortReady };
+}
+var use_chat_sort_default = useChatSort;
+export {
+  use_chat_sort_default as default,
+  resetChatSortHydration,
+  useChatSort
+};

package/hooks/use-chat-surface.js

@@ -0,0 +1,8 @@
+import { useEffect } from "react";
+import { markChatSurface } from "../config/navigation.js";
+function useChatSurface() {
+  useEffect(() => markChatSurface(), []);
+}
+export {
+  useChatSurface as default
+};

package/hooks/use-common-filter-options.js

@@ -0,0 +1,70 @@
+import {
+  AdvanceFilterOptionType,
+  TextOperatorOptions,
+  SelectOperatorOptions,
+  DateOperatorOptions,
+  NumberOperatorOptions,
+  MultiSelectOperatorOptions
+} from "@zenify-omni/chat-js/constants/advance-filter.js";
+import { AttributeFieldType } from "@zenify-omni/chat-js/constants/setting.js";
+function buildExtraFields(extraFields) {
+  return (extraFields ?? []).filter(
+    (value) => ![AttributeFieldType.Image, AttributeFieldType.File].includes(
+      value.type
+    )
+  ).map((field) => {
+    if (field.type === AttributeFieldType.Number) {
+      return {
+        key: field.key,
+        title: field.title,
+        meta_data: {
+          control: AdvanceFilterOptionType.Number,
+          operators: NumberOperatorOptions
+        }
+      };
+    }
+    if (field.type === AttributeFieldType.Date) {
+      return {
+        key: field.key,
+        title: field.title,
+        meta_data: {
+          control: AdvanceFilterOptionType.Date,
+          operators: DateOperatorOptions
+        }
+      };
+    }
+    if (field.type === AttributeFieldType.Select) {
+      return {
+        key: field.key,
+        title: field.title,
+        meta_data: {
+          control: AdvanceFilterOptionType.Select,
+          operators: SelectOperatorOptions,
+          options: !Array.isArray(field.data) ? [] : field.data.map((value) => ({ label: value, value }))
+        }
+      };
+    }
+    if (field.type === AttributeFieldType.MultiSelect) {
+      return {
+        key: field.key,
+        title: field.title,
+        meta_data: {
+          control: AdvanceFilterOptionType.MultiSelect,
+          operators: MultiSelectOperatorOptions,
+          options: !Array.isArray(field.data) ? [] : field.data.map((value) => ({ label: value, value }))
+        }
+      };
+    }
+    return {
+      key: field.key,
+      title: field.title,
+      meta_data: {
+        control: AdvanceFilterOptionType.Text,
+        operators: TextOperatorOptions
+      }
+    };
+  });
+}
+export {
+  buildExtraFields
+};

package/hooks/use-crm-organizations-data.js

@@ -0,0 +1,23 @@
+import {
+  AdvanceFilterOptionType,
+  VALUE_INDEPENDENT_OPERATORS
+} from "@zenify-omni/chat-js/constants/advance-filter.js";
+const buildMergedConditions = (conditions, filterOptions) => {
+  const optionMap = Object.fromEntries(
+    filterOptions.map((opt) => [opt.key, opt.meta_data?.control])
+  );
+  return Object.fromEntries(
+    Object.entries(conditions || {}).map(([key, rules]) => {
+      const control = optionMap[key];
+      const mappedRules = rules.map((rule) => ({
+        ...rule,
+        ...control && { type: control },
+        ...control === AdvanceFilterOptionType.Number && rule.value !== "" && { value: Number(rule.value) }
+      })).filter((rule) => {
+        if (VALUE_INDEPENDENT_OPERATORS.includes(rule.label)) return true;
+        return rule.value !== "" && rule.value !== null && rule.value !== void 0;
+      });
+      return [key, mappedRules];
+    }).filter(([, rules]) => rules.length > 0)
+  );
+};

package/hooks/use-debounce.js

@@ -0,0 +1,14 @@
+import { useState, useEffect } from "react";
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(() => setDebouncedValue(value), delay || 500);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+export {
+  useDebounce as default
+};

package/hooks/use-dynamic-fields.js

@@ -0,0 +1,7 @@
+function hasExistingDynamicFieldValue(existingRecord, key) {
+  if (!existingRecord) return false;
+  const value = existingRecord?.[key];
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "string") return value.trim() !== "";
+  return value !== null && value !== void 0;
+}

package/hooks/use-facebook-notice.js

@@ -0,0 +1,24 @@
+import { useLayoutEffect, useRef, useState } from "react";
+import { useFacebookPageInvalid } from "../components/chat-route/chat-box/use-facebook-page-invalid.js";
+function useFacebookNotice(chatRoom) {
+  const isFacebookPageInvalid = useFacebookPageInvalid(chatRoom);
+  const noticeRef = useRef(null);
+  const [noticeHeight, setNoticeHeight] = useState(0);
+  useLayoutEffect(() => {
+    if (!isFacebookPageInvalid || !noticeRef.current) {
+      setNoticeHeight(0);
+      return;
+    }
+    const observer = new ResizeObserver(([entry]) => {
+      setNoticeHeight(entry.contentRect.height + 16);
+    });
+    observer.observe(noticeRef.current);
+    return () => observer.disconnect();
+  }, [isFacebookPageInvalid]);
+  return { isFacebookPageInvalid, noticeRef, noticeHeight };
+}
+var use_facebook_notice_default = useFacebookNotice;
+export {
+  use_facebook_notice_default as default,
+  useFacebookNotice
+};

package/hooks/use-feature-flags.js

@@ -0,0 +1,6 @@
+function useOrgTreeEnabled() {
+  return true;
+}
+export {
+  useOrgTreeEnabled
+};

package/hooks/use-field-layout-override.js

@@ -0,0 +1,46 @@
+import { useEffect, useMemo, useState } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { settingUserConfig } from "@zenify-omni/chat-js/api/settings/common.js";
+import { useUserConfig } from "./use-setting-common.js";
+import QUERY_KEY from "@zenify-omni/chat-js/constants/use-query-key.js";
+import { getUser } from "@zenify-omni/chat-js/utils/auth.js";
+import {
+  mergeFieldOrder,
+  normalizeFieldOverride,
+  toFieldOverride
+} from "@zenify-omni/chat-js/utils/field-layout.js";
+function useFieldLayoutOverride(configKey, defaultKeys) {
+  const user = getUser();
+  const queryClient = useQueryClient();
+  const userConfig = useUserConfig();
+  const raw = userConfig[configKey];
+  const [override, setOverride] = useState(null);
+  useEffect(() => {
+    if (!raw) return;
+    try {
+      setOverride(typeof raw === "string" ? JSON.parse(raw) : raw);
+    } catch (e) {
+      console.error(`Invalid JSON in ${configKey}`, e);
+    }
+  }, [raw]);
+  const shownKeys = useMemo(
+    () => mergeFieldOrder(normalizeFieldOverride(override), defaultKeys),
+    [override, defaultKeys]
+  );
+  const applyFieldLayout = async (_containerKey, nextShown, nextHiddenByKey) => {
+    const next = toFieldOverride(nextShown, nextHiddenByKey);
+    setOverride(next);
+    const { error } = await settingUserConfig({
+      data: { user_id: user._id, [configKey]: JSON.stringify(next) }
+    });
+    if (!error) {
+      queryClient.invalidateQueries({
+        queryKey: [QUERY_KEY.GET_USER_CONFIGURATION]
+      });
+    }
+  };
+  return [shownKeys, applyFieldLayout];
+}
+export {
+  useFieldLayoutOverride as default
+};

package/hooks/use-file-upload.js

@@ -0,0 +1,119 @@
+import { DEFAULT_UPLOAD_MAXSIZE as DEFAULT_UPLOAD_MAX_SIZE } from "@zenify-omni/chat-js/constants/file-upload.js";
+import { isEmpty } from "lodash-es";
+import { useRef, useCallback } from "react";
+import i18n from "@zenify-omni/chat-js/lib/i18n/index.js";
+const DEFAULT_MESSAGES = {
+  MAX_FILES_EXCEEDED: ({ maxFiles }) => i18n.t("common:message.maxFilesUpload", {
+    maxFiles,
+    defaultValue: "B\u1EA1n ch\u1EC9 c\xF3 th\u1EC3 t\u1EA3i l\xEAn t\u1ED1i \u0111a {maxFiles} t\u1EC7p."
+  }),
+  TOTAL_SIZE_EXCEEDED: ({ maxTotalSizeMB }) => i18n.t("common:message.totalFileSizeExceeded", {
+    maxTotalSizeMB,
+    defaultValue: "T\u1ED5ng dung l\u01B0\u1EE3ng c\xE1c t\u1EC7p v\u01B0\u1EE3t qu\xE1 {maxTotalSizeMB}MB."
+  }),
+  INVALID_TYPE: ({ type }) => i18n.t("common:message.fileTypeUnsupported", {
+    type,
+    defaultValue: 'Lo\u1EA1i t\u1EC7p "{type}" kh\xF4ng \u0111\u01B0\u1EE3c h\u1ED7 tr\u1EE3.'
+  }),
+  INVALID_EXTENSION: ({ ext }) => i18n.t("common:toast.fileFormatNotSupported", {
+    ext,
+    defaultValue: '\u0110\u1ECBnh d\u1EA1ng t\u1EC7p ".{ext}" kh\xF4ng \u0111\u01B0\u1EE3c h\u1ED7 tr\u1EE3.'
+  }),
+  FILE_TOO_LARGE: ({ maxFileSizeMB }) => i18n.t("common:toast.fileSizeExceeded", {
+    maxFileSizeMB,
+    defaultValue: "Dung l\u01B0\u1EE3ng t\u1EC7p v\u01B0\u1EE3t qu\xE1 {maxFileSizeMB}MB."
+  })
+};
+function useFileUpload(options = {}) {
+  const {
+    accept = [],
+    extensions = [],
+    maxFileSizeMB = DEFAULT_UPLOAD_MAX_SIZE,
+    maxTotalSizeMB,
+    maxFiles,
+    multiple = false,
+    messages = {}
+  } = options;
+  const inputRef = useRef(null);
+  const toMB = (value) => value * 1024 * 1024;
+  const getMessage = useCallback(
+    (code, payload) => {
+      const resolver = messages[code] || DEFAULT_MESSAGES[code];
+      return typeof resolver === "function" ? resolver(payload) : resolver;
+    },
+    [messages]
+  );
+  const validateFiles = useCallback(
+    (incoming, onError) => {
+      const incomingFiles = Array.from(incoming);
+      if (maxFiles && incomingFiles.length > maxFiles) {
+        onError?.({
+          code: "MAX_FILES_EXCEEDED",
+          message: getMessage("MAX_FILES_EXCEEDED", { maxFiles })
+        });
+        return;
+      }
+      let totalSize = 0;
+      const nextItems = [];
+      for (const file of incomingFiles) {
+        let error = null;
+        if (accept.length && !accept.includes(file.type)) {
+          error = {
+            code: "INVALID_TYPE",
+            message: getMessage("INVALID_TYPE", { type: file.type })
+          };
+        }
+        if (!error && extensions.length) {
+          const ext = file.name.split(".").pop().toLowerCase();
+          if (!extensions.includes(ext)) {
+            error = {
+              code: "INVALID_EXTENSION",
+              message: getMessage("INVALID_EXTENSION", { ext })
+            };
+          }
+        }
+        if (!error && file.size > toMB(maxFileSizeMB)) {
+          error = {
+            code: "FILE_TOO_LARGE",
+            message: getMessage("FILE_TOO_LARGE", {
+              maxFileSizeMB
+            })
+          };
+        }
+        totalSize += file.size;
+        nextItems.push({ file, error });
+      }
+      if (maxTotalSizeMB && totalSize > toMB(maxTotalSizeMB)) {
+        onError?.({
+          code: "TOTAL_SIZE_EXCEEDED",
+          message: getMessage("TOTAL_SIZE_EXCEEDED", {
+            maxTotalSizeMB
+          })
+        });
+        return;
+      }
+      return nextItems;
+    },
+    [maxFiles, maxTotalSizeMB, getMessage, accept, extensions, maxFileSizeMB]
+  );
+  const onChange = (e, { onError, onSuccess } = {}) => {
+    if (!e.target.files) return;
+    const items = validateFiles(e.target.files, onError);
+    if (isEmpty(items)) return;
+    onSuccess?.(items);
+  };
+  const open = () => inputRef.current?.click();
+  const reset = () => {
+    if (inputRef.current) inputRef.current.value = "";
+  };
+  return {
+    inputRef,
+    onChange,
+    open,
+    reset,
+    multiple
+  };
+}
+export {
+  useFileUpload
+};

package/hooks/use-file-viewer.js

@@ -0,0 +1,93 @@
+import { useMemo } from "react";
+const VIEWER_TYPES = {
+  PDF: "pdf",
+  DOCX: "docx",
+  SPREADSHEET: "spreadsheet",
+  CSV: "csv",
+  IMAGE: "image",
+  VIDEO: "video",
+  AUDIO: "audio",
+  MARKDOWN: "markdown",
+  CODE: "code",
+  UNSUPPORTED: "unsupported"
+};
+const EXT_MAP = {
+  pdf: VIEWER_TYPES.PDF,
+  doc: VIEWER_TYPES.DOCX,
+  docx: VIEWER_TYPES.DOCX,
+  xls: VIEWER_TYPES.SPREADSHEET,
+  xlsx: VIEWER_TYPES.SPREADSHEET,
+  csv: VIEWER_TYPES.CSV,
+  jpg: VIEWER_TYPES.IMAGE,
+  jpeg: VIEWER_TYPES.IMAGE,
+  png: VIEWER_TYPES.IMAGE,
+  gif: VIEWER_TYPES.IMAGE,
+  webp: VIEWER_TYPES.IMAGE,
+  bmp: VIEWER_TYPES.IMAGE,
+  svg: VIEWER_TYPES.IMAGE,
+  mp4: VIEWER_TYPES.VIDEO,
+  webm: VIEWER_TYPES.VIDEO,
+  mov: VIEWER_TYPES.VIDEO,
+  avi: VIEWER_TYPES.VIDEO,
+  mkv: VIEWER_TYPES.VIDEO,
+  mp3: VIEWER_TYPES.AUDIO,
+  wav: VIEWER_TYPES.AUDIO,
+  ogg: VIEWER_TYPES.AUDIO,
+  flac: VIEWER_TYPES.AUDIO,
+  m4a: VIEWER_TYPES.AUDIO,
+  md: VIEWER_TYPES.MARKDOWN,
+  markdown: VIEWER_TYPES.MARKDOWN,
+  js: VIEWER_TYPES.CODE,
+  jsx: VIEWER_TYPES.CODE,
+  ts: VIEWER_TYPES.CODE,
+  tsx: VIEWER_TYPES.CODE,
+  json: VIEWER_TYPES.CODE,
+  xml: VIEWER_TYPES.CODE,
+  html: VIEWER_TYPES.CODE,
+  css: VIEWER_TYPES.CODE,
+  py: VIEWER_TYPES.CODE,
+  java: VIEWER_TYPES.CODE,
+  go: VIEWER_TYPES.CODE,
+  rs: VIEWER_TYPES.CODE,
+  sh: VIEWER_TYPES.CODE,
+  yaml: VIEWER_TYPES.CODE,
+  yml: VIEWER_TYPES.CODE,
+  txt: VIEWER_TYPES.CODE,
+  ppt: VIEWER_TYPES.UNSUPPORTED,
+  pptx: VIEWER_TYPES.UNSUPPORTED
+};
+const MIME_MAP = {
+  "application/pdf": VIEWER_TYPES.PDF,
+  "application/msword": VIEWER_TYPES.DOCX,
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": VIEWER_TYPES.DOCX,
+  "application/vnd.ms-excel": VIEWER_TYPES.SPREADSHEET,
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": VIEWER_TYPES.SPREADSHEET,
+  "text/csv": VIEWER_TYPES.CSV,
+  "text/markdown": VIEWER_TYPES.MARKDOWN,
+  "text/x-markdown": VIEWER_TYPES.MARKDOWN,
+  "application/vnd.ms-powerpoint": VIEWER_TYPES.UNSUPPORTED,
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": VIEWER_TYPES.UNSUPPORTED
+};
+function getViewerType(mimeType, name) {
+  if (mimeType) {
+    if (mimeType.startsWith("image/")) return VIEWER_TYPES.IMAGE;
+    if (mimeType.startsWith("video/")) return VIEWER_TYPES.VIDEO;
+    if (mimeType.startsWith("audio/")) return VIEWER_TYPES.AUDIO;
+    if (mimeType.startsWith("text/") && !MIME_MAP[mimeType])
+      return VIEWER_TYPES.CODE;
+    if (MIME_MAP[mimeType]) return MIME_MAP[mimeType];
+  }
+  const ext = name?.split("?")[0].split(".").pop()?.toLowerCase();
+  return EXT_MAP[ext] ?? VIEWER_TYPES.UNSUPPORTED;
+}
+function useFileViewer(file) {
+  return useMemo(() => {
+    if (!file) return null;
+    return getViewerType(file.mimeType, file.name);
+  }, [file]);
+}
+export {
+  VIEWER_TYPES,
+  getViewerType,
+  useFileViewer
+};

package/hooks/use-frozen-columns.js

@@ -0,0 +1,29 @@
+const CONFIG_KEY_MAP = {
+  ticket: "ticket_frozen_columns",
+  lead: "lead_frozen_columns",
+  customer: "contact_frozen_columns",
+  task: "task_frozen_columns",
+  deal: "deal_frozen_columns"
+};
+const PARAM_KEY_MAP = {
+  ticket: "ticketFrozenColumns",
+  lead: "leadFrozenColumns",
+  customer: "customerFrozenColumns",
+  task: "taskFrozenColumns",
+  deal: "dealFrozenColumns"
+};
+const DEFAULT_VIEW_KEY = "default";
+function parseFrozenColumnsMap(value) {
+  if (!value) return {};
+  let parsed = value;
+  if (typeof value === "string") {
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      return {};
+    }
+  }
+  if (Array.isArray(parsed)) return { [DEFAULT_VIEW_KEY]: parsed };
+  if (parsed && typeof parsed === "object") return parsed;
+  return {};
+}