@zero-library/common 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,1402 @@
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { FileUnknownOutlined, FileZipOutlined, FileGifOutlined, FileImageOutlined, FileJpgOutlined, NotificationOutlined, VideoCameraOutlined, FilePptOutlined, FileExcelOutlined, FileWordOutlined, FilePdfOutlined, FileTextOutlined } from '@ant-design/icons';
+import { forwardRef, useState, useMemo, useEffect, lazy, Suspense, createContext, useRef, useCallback, useContext } from 'react';
+import { Spin, notification, Modal, Result, Splitter, Empty, Image, Flex, Drawer, Avatar, Alert, Form, Input, Button } from 'antd';
+import parse from 'html-react-parser';
+import { jsonrepair } from 'jsonrepair';
+import markdownit from 'markdown-it';
+import container from 'markdown-it-container';
+import { Worker, Viewer, PasswordStatus } from '@react-pdf-viewer/core';
+import { pageNavigationPlugin } from '@react-pdf-viewer/page-navigation';
+import { thumbnailPlugin } from '@react-pdf-viewer/thumbnail';
+import { zoomPlugin } from '@react-pdf-viewer/zoom';
+import '@react-pdf-viewer/core/lib/styles/index.css';
+import zh_CN from '@react-pdf-viewer/locales/lib/zh_CN.json';
+import '@react-pdf-viewer/page-navigation/lib/styles/index.css';
+import dayjs from 'dayjs';
+import relativeTime from 'dayjs/plugin/relativeTime';
+import AES from 'crypto-js/aes';
+import encUtf8 from 'crypto-js/enc-utf8';
+import Decimal from 'decimal.js';
+import axios from 'axios';
+import { message } from 'antd/lib';
+import '@react-pdf-viewer/thumbnail/lib/styles/index.css';
+import '@react-pdf-viewer/zoom/lib/styles/index.css';
+import classNames from 'classnames';
+
+// src/components/File/styles.module.less
+var styles_module_default = {
+  nsPreviewImage: "styles_module_nsPreviewImage",
+  nsPreviewPdf: "styles_module_nsPreviewPdf",
+  pdfToolbar: "styles_module_pdfToolbar",
+  nsPreviewVideo: "styles_module_nsPreviewVideo",
+  nsPreviewAudio: "styles_module_nsPreviewAudio"
+};
+var AudioPlayer_default = ({ fileUrl }) => {
+  return /* @__PURE__ */ jsxs("audio", { controls: true, className: styles_module_default.nsPreviewAudio, children: [
+    /* @__PURE__ */ jsx("source", { src: fileUrl, type: "audio/mpeg" }),
+    "\u60A8\u7684\u6D4F\u89C8\u5668\u4E0D\u652F\u6301 audio \u6807\u7B7E\u3002"
+  ] });
+};
+
+// src/utils/theme.ts
+var getPrimaryColor = () => {
+  const searchParams = new URLSearchParams(location.search);
+  const mainSource = searchParams.get("mainSource") || "cube-uc";
+  if (mainSource === "cube-uc") {
+    return "#34AFBE";
+  } else if (mainSource === "uc") {
+    return "#FA541C";
+  }
+};
+var LgPrimaryColor = getPrimaryColor();
+var themeConfig = {
+  token: { colorPrimary: LgPrimaryColor, colorLink: LgPrimaryColor },
+  cssVar: true
+};
+var FileIcon_default = ({ suffix, fontSize = 22 }) => {
+  const styles = { fontSize, color: LgPrimaryColor };
+  const Icon = useMemo(() => {
+    switch (suffix?.toUpperCase()) {
+      case "TXT":
+        return /* @__PURE__ */ jsx(FileTextOutlined, {});
+      case "PDF":
+        return /* @__PURE__ */ jsx(FilePdfOutlined, {});
+      case "DOC":
+      case "DOCX":
+        return /* @__PURE__ */ jsx(FileWordOutlined, {});
+      case "XLS":
+      case "XLSX":
+        return /* @__PURE__ */ jsx(FileExcelOutlined, {});
+      case "PPT":
+        return /* @__PURE__ */ jsx(FilePptOutlined, {});
+      case "MP4":
+      case "MOV":
+      case "AVI":
+      case "FLV":
+        return /* @__PURE__ */ jsx(VideoCameraOutlined, {});
+      case "MP3":
+        return /* @__PURE__ */ jsx(NotificationOutlined, {});
+      case "JPG":
+      case "JPEG":
+        return /* @__PURE__ */ jsx(FileJpgOutlined, {});
+      case "PNG":
+        return /* @__PURE__ */ jsx(FileImageOutlined, {});
+      case "GIF":
+        return /* @__PURE__ */ jsx(FileGifOutlined, {});
+      case "ZIP":
+      case "RAR":
+      case "7Z":
+        return /* @__PURE__ */ jsx(FileZipOutlined, {});
+      case "CATALOG":
+        return /* @__PURE__ */ jsx("i", { style: styles, className: "iconfont icon-wenjianjia" });
+      // 文件夹
+      default:
+        return /* @__PURE__ */ jsx(FileUnknownOutlined, {});
+    }
+  }, [suffix]);
+  return /* @__PURE__ */ jsx("span", { style: styles, children: Icon });
+};
+var VideoPlayer_default = ({ fileUrl }) => {
+  return /* @__PURE__ */ jsxs("video", { controls: true, className: styles_module_default.nsPreviewVideo, children: [
+    /* @__PURE__ */ jsx("source", { src: fileUrl, type: "video/mp4" }),
+    "\u60A8\u7684\u6D4F\u89C8\u5668\u4E0D\u652F\u6301 video \u6807\u7B7E\u3002"
+  ] });
+};
+var baseComponentMap = {
+  // renderMarkdown: () => import('@/components/RenderMarkdown')
+};
+var LazyComponent_default = ({ type, customComponents, ...rest }) => {
+  const componentMap = useMemo(() => {
+    return { ...baseComponentMap, ...customComponents };
+  }, [customComponents]);
+  const LazyComponent = useMemo(() => {
+    const loader = componentMap[type];
+    return loader ? lazy(loader) : null;
+  }, [type, componentMap]);
+  if (!LazyComponent) return /* @__PURE__ */ jsxs("div", { children: [
+    "\u672A\u77E5\u7C7B\u578B\uFF1A",
+    type
+  ] });
+  return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx("div", { children: "\u52A0\u8F7D\u4E2D..." }), children: /* @__PURE__ */ jsx(LazyComponent, { ...rest }) });
+};
+var md = markdownit({ html: true, breaks: true });
+md.renderer.rules.link_open = function(tokens, idx, options, env, self) {
+  const token = tokens[idx];
+  token.attrPush(["target", "_blank"]);
+  return self.renderToken(tokens, idx, options);
+};
+var replaceSpecialCharacter = (str) => {
+  return str.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+};
+function parseParams(info) {
+  const params = {};
+  const regex = /(\w+)\s*=\s*(?:(['"])(.*?)\2|(\S+))/g;
+  let match;
+  while ((match = regex.exec(info)) !== null) {
+    const key = match[1];
+    const value = match[3] ?? match[4] ?? "";
+    if (key === "data") {
+      let obj = {};
+      try {
+        obj = JSON.parse(value);
+      } catch {
+        try {
+          obj = JSON.parse(jsonrepair(value));
+        } catch {
+          obj = {};
+        }
+      }
+      params[key] = replaceSpecialCharacter(JSON.stringify(obj));
+    } else {
+      params[key] = value;
+    }
+  }
+  return params;
+}
+md.use(container, "alert", {
+  validate: (params) => /^alert/.test(params.trim()),
+  render: function(tokens, idx) {
+    const token = tokens[idx];
+    if (token.nesting === 1) {
+      const info = token.info.trim();
+      const params = parseParams(info);
+      return `<lazy-component ${Object.entries(params).map(([key, value]) => `${key}=${value}`).join(" ")}>`;
+    } else {
+      return "</lazy-component>";
+    }
+  }
+});
+function preprocess(content) {
+  return content.replace(
+    /:::alert([\s\S]*?):::/g,
+    // 匹配 :::alert ... :::
+    (match, params) => {
+      return `
+ :::alert ${params.trim()} 
+ ::: 
+`;
+    }
+  );
+}
+function highlightKeywords(html, keywords) {
+  const escaped = keywords.map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  const regex = new RegExp(`(${escaped.join("|")})`, "gi");
+  return html.replace(regex, '<span class="cube-hl">$1</span>');
+}
+var RenderMarkdown_default = ({ content = "", searchValue, customComponents, onChange, onPartialChange }) => {
+  const reactContent = useMemo(() => {
+    if (!content) return null;
+    let fixedContent = content;
+    const openCount = (fixedContent.match(/:::alert\b/g) || []).length;
+    const closeCount = (fixedContent.match(/\s*:::\s*/gm) || []).length - openCount;
+    let incomplete = false;
+    if (openCount > closeCount) {
+      incomplete = true;
+      fixedContent += ":::";
+    }
+    fixedContent = preprocess(fixedContent);
+    let rawHtml = md.render(fixedContent);
+    rawHtml = searchValue ? highlightKeywords(rawHtml, [searchValue]) : rawHtml;
+    let lazyIndex = -1;
+    const allLazyMatches = [...rawHtml.matchAll(/<lazy-component/gi)];
+    const lastLazyIndex = allLazyMatches.length - 1;
+    return parse(rawHtml, {
+      replace: (domNode) => {
+        if (domNode.name === "lazy-component") {
+          lazyIndex++;
+          const el = domNode;
+          const type = el.attribs.type;
+          const data = JSON.parse(el.attribs.data || "{}");
+          const loading = incomplete && lazyIndex === lastLazyIndex;
+          return /* @__PURE__ */ jsx(
+            LazyComponent_default,
+            {
+              type,
+              data,
+              loading,
+              customComponents,
+              onChange,
+              onPartialChange
+            },
+            `${type}${lazyIndex}`
+          );
+        }
+      }
+    });
+  }, [content, searchValue]);
+  return /* @__PURE__ */ jsx("div", { className: "ns-markdown", children: reactContent });
+};
+var MarkdownPreview_default = ({ fileUrl, searchValue }) => {
+  const [content, setContent] = useState("");
+  const [error, setError] = useState("");
+  const fetchMarkdown = async () => {
+    const res = await fetch(fileUrl);
+    if (res.status !== 200) {
+      throw new Error(`\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${res.status}`);
+    }
+    const markdownText = await res.text();
+    if (!markdownText) {
+      throw new Error("\u8FD4\u56DE\u5185\u5BB9\u4E3A\u7A7A");
+    }
+    setContent(markdownText);
+  };
+  const init = async () => {
+    setContent("");
+    setError("");
+    if (fileUrl) {
+      try {
+        await fetchMarkdown();
+      } catch (error2) {
+        setError("\u52A0\u8F7D\u6216\u89E3\u6790 Markdown \u5931\u8D25");
+      }
+    }
+  };
+  useEffect(() => {
+    init();
+  }, [fileUrl]);
+  return error ? /* @__PURE__ */ jsx(Result, { status: "error", title: error }) : /* @__PURE__ */ jsx("div", { className: "height-full", children: /* @__PURE__ */ jsx(RenderMarkdown_default, { content, searchValue }) });
+};
+function createValtioContext() {
+  const Context = createContext(null);
+  const ValtioProvider = ({ store, children }) => /* @__PURE__ */ jsx(Context.Provider, { value: store, children });
+  const useValtioStore = () => {
+    const store = useContext(Context);
+    if (!store) throw new Error("useStore must be used within Provider");
+    return store;
+  };
+  return {
+    ValtioProvider,
+    useValtioStore
+    // Context
+  };
+}
+
+// src/hooks/iframe/iframeRelay.ts
+function emit(type, data, to = "top") {
+  const payload = { type, data, to };
+  try {
+    window.parent.postMessage(payload, "*");
+  } catch (err) {
+    console.warn("emit parent failed", err);
+  }
+}
+function emitToChild(iframeWindow, type, data, origin = "*") {
+  if (!iframeWindow) {
+    console.warn("emitToChild failed: iframeWindow is null");
+    return;
+  }
+  const payload = { type, data, to: "child" };
+  try {
+    iframeWindow.postMessage(payload, origin);
+  } catch (err) {
+    console.warn("emit to child failed", err);
+  }
+}
+
+// src/utils/is.ts
+var toString = Object.prototype.toString;
+function is(val, type) {
+  return toString.call(val) === `[object ${type}]`;
+}
+function isUnDef(val) {
+  return is(val, "Undefined");
+}
+function isDef(val) {
+  return !isUnDef(val);
+}
+function isObject(val) {
+  return is(val, "Object");
+}
+function isEmptyObj(val) {
+  if (isObject(val)) {
+    return Object.keys(val).length === 0;
+  }
+  return false;
+}
+function isDate(val) {
+  return is(val, "Date");
+}
+function isNull(val) {
+  return is(val, "Null");
+}
+function isNullOrUnDef(val) {
+  return isUnDef(val) || isNull(val);
+}
+function isNumber(val) {
+  return is(val, "Number");
+}
+function isNumberNoNaN(val) {
+  return is(val, "Number") && !isNaN(val);
+}
+function isString(val) {
+  return is(val, "String");
+}
+function isFunction(val) {
+  return is(val, "Function");
+}
+function isPromise(val) {
+  return is(val, "Promise") && isObject(val) && isFunction(val.then) && isFunction(val.catch);
+}
+function isBoolean(val) {
+  return is(val, "Boolean");
+}
+function isRegExp(val) {
+  return is(val, "RegExp");
+}
+function isArray(val) {
+  return Array.isArray(val);
+}
+function isEmpty(val) {
+  if (isArray(val) || isString(val)) {
+    return val.length === 0;
+  }
+  if (isNullOrUnDef(val)) {
+    return true;
+  }
+  if (val instanceof Map || val instanceof Set) {
+    return val.size === 0;
+  }
+  return isEmptyObj(val);
+}
+function isWindow(val) {
+  return typeof window !== "undefined" && is(val, "Window");
+}
+function isElement(val) {
+  return isObject(val) && !!val.tagName;
+}
+function isMap(val) {
+  return is(val, "Map");
+}
+var isServer = typeof window === "undefined";
+var isClient = !isServer;
+var isExternal = (path) => {
+  return /^(https?:|mailto:|tel:)/.test(path);
+};
+var isBlob = (val) => {
+  return is(val, "Blob");
+};
+
+// src/hooks/iframe/useIframeRelayBridge.ts
+function useIframeRelayBridge(allowedOrigins = ["*"]) {
+  const handlers = useRef({});
+  useEffect(() => {
+    const onMessage = (evt) => {
+      const { data, source, origin } = evt;
+      if (!data || !isObject(data) || !data.type) return;
+      if (allowedOrigins[0] !== "*" && !allowedOrigins.includes(origin)) return;
+      const { type, data: params, to = "parent" } = data;
+      const isTop = window.parent === window;
+      if (to === "top" && !isTop) {
+        window.parent.postMessage(data, allowedOrigins[0] === "*" ? "*" : origin);
+        return;
+      }
+      const fns = handlers.current[type] || [];
+      fns.forEach((fn) => fn(params, source, origin));
+    };
+    window.addEventListener("message", onMessage);
+    return () => window.removeEventListener("message", onMessage);
+  }, [allowedOrigins]);
+  function on(type, handler) {
+    handlers.current[type] = handlers.current[type] || [];
+    handlers.current[type].push(handler);
+  }
+  function off(type, handler) {
+    handlers.current[type] = (handlers.current[type] || []).filter((fn) => fn !== handler);
+  }
+  return { on, off };
+}
+function useDebounce(func, wait = 400) {
+  const { current } = useRef({ func, timeOut: null });
+  useEffect(() => {
+    current.func = func;
+  }, [func]);
+  let args;
+  function debounce(..._args) {
+    args = _args;
+    if (current.timeOut) {
+      clearTimeout(current.timeOut);
+      current.timeOut = null;
+    }
+    return new Promise((resolve, reject) => {
+      current.timeOut = setTimeout(async () => {
+        try {
+          const result = await current.func.apply(null, args);
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        }
+      }, wait);
+    });
+  }
+  function cancel() {
+    if (!current.timeOut) return;
+    clearTimeout(current.timeOut);
+    current.timeOut = null;
+  }
+  function flush() {
+    cancel();
+    return current.func.apply(null, args);
+  }
+  debounce.flush = flush;
+  debounce.cancel = cancel;
+  return useCallback(debounce, []);
+}
+
+// src/utils/common.ts
+var deepCopy = (obj, isJson = true) => {
+  if (!isArray(obj) && !isObject(obj)) return obj;
+  if (isJson) return JSON.parse(JSON.stringify(obj));
+  const result = isArray(obj) ? [] : {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      result[key] = deepCopy(obj[key], isJson);
+    }
+  }
+  return result;
+};
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+  if (a instanceof RegExp && b instanceof RegExp) return a.toString() === b.toString();
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [key, val] of a.entries()) {
+      if (!b.has(key) || !deepEqual(val, b.get(key))) return false;
+    }
+    return true;
+  }
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const val of a.values()) {
+      if (!b.has(val)) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (typeof a === "function" && typeof b === "function") return a.toString() === b.toString();
+  if (isObject(a) && isObject(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    for (const key of keysA) {
+      if (!deepEqual(a[key], b[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+var deepMerge = (base, override) => {
+  const result = { ...base };
+  Object.keys(override || {}).forEach((key) => {
+    const baseValue = base[key];
+    const overrideValue = override[key];
+    if (typeof baseValue === "object" && baseValue !== null && !isArray(baseValue) && typeof overrideValue === "object" && overrideValue !== null && !isArray(overrideValue)) {
+      result[key] = deepMerge(baseValue, overrideValue);
+    } else if (overrideValue !== void 0) {
+      result[key] = overrideValue;
+    }
+  });
+  return result;
+};
+var objToOptions = (obj) => {
+  return Object.keys(obj).map((key) => ({
+    label: obj[key],
+    value: Number(key)
+  }));
+};
+var arrToObj = (arr = [], key) => {
+  const obj = {};
+  arr?.forEach((item) => {
+    obj[item[key]] = item;
+  });
+  return obj;
+};
+var nsSetInterval = (fn, t) => {
+  let timer = null;
+  let isCancelled = false;
+  const interval = () => {
+    timer = setTimeout(async () => {
+      if (isCancelled) {
+        return;
+      }
+      await fn();
+      if (!isCancelled) {
+        interval();
+      }
+    }, t);
+  };
+  interval();
+  return {
+    isRun: () => !!timer,
+    cancel: () => {
+      isCancelled = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+};
+var genNonDuplicateID = () => {
+  let idStr = Date.now().toString(36);
+  idStr += Math.random().toString(36).substr(2);
+  return idStr;
+};
+var copyText = (text) => {
+  if (navigator.clipboard && window.isSecureContext) {
+    return navigator.clipboard.writeText(text);
+  } else {
+    const textArea = document.createElement("textarea");
+    textArea.value = text;
+    textArea.style.position = "absolute";
+    textArea.style.opacity = "0";
+    textArea.style.left = "-999999px";
+    textArea.style.top = "-999999px";
+    document.body.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+    return new Promise((res, rej) => {
+      document.execCommand("copy") ? res() : rej();
+      textArea.remove();
+    });
+  }
+};
+function formatNumberWithCommas(number) {
+  const numericValue = parseFloat(number);
+  if (!isNaN(numericValue)) {
+    return numericValue.toLocaleString();
+  }
+  return number;
+}
+var generateRandomNumbers = (min, max, count) => {
+  const randomNumbers = /* @__PURE__ */ new Set();
+  while (randomNumbers.size < count) {
+    const randomNumber = Math.floor(Math.random() * (max - min + 1)) + min;
+    randomNumbers.add(randomNumber);
+  }
+  return Array.from(randomNumbers);
+};
+var getFileName = (filePath) => {
+  return filePath.split("?")[0].split("/").pop() || "";
+};
+var textAreaView = (con) => {
+  return con ? con.replace(/\r\n/g, "\n").replace(/\n/g, "<br/>") : "";
+};
+var buildUrlParams = (obj, url) => {
+  const params = Object.entries(obj).filter(([, value]) => !isNullOrUnDef(value)).map(([key, value]) => {
+    if (isArray(value)) {
+      return value.filter((v) => !isNullOrUnDef(v)).map((v) => `${encodeURIComponent(key)}=${encodeURIComponent(v)}`).join("&");
+    }
+    return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+  }).join("&");
+  if (url) {
+    const separator = url.includes("?") ? "&" : "?";
+    return `${url}${separator}${params}`;
+  }
+  return params;
+};
+var downloadFile = (url, name) => {
+  const a = document.createElement("a");
+  a.download = name || "\u56FE\u7247\u4E0B\u8F7D";
+  a.href = url;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+};
+var addUrlLastSlash = (url = "") => {
+  const u = new URL(url, "https://logosdata.cn");
+  let pathname = u.pathname;
+  if (!pathname.endsWith("/")) {
+    pathname += "/";
+  }
+  u.pathname = pathname;
+  return `${isExternal(url) ? u.origin : ""}${u.pathname}${u.search}${u.hash}`;
+};
+var getUrlMainSource = (url, preHref) => {
+  if (!preHref) return url;
+  let newUrl = "";
+  const preHrefUrl = new URL(preHref);
+  const urlParts = url.split("?");
+  const srcParams = new URLSearchParams(urlParts[1] || "");
+  if (srcParams.has("mainSource")) {
+    newUrl = url;
+  } else {
+    const mainSource = preHrefUrl.searchParams.get("mainSource");
+    if (mainSource) {
+      newUrl = buildUrlParams({ mainSource }, url);
+    } else {
+      newUrl = url;
+    }
+  }
+  return newUrl;
+};
+var getWebSocketUrl = (path, customHost) => {
+  const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+  const host = customHost || window.location.host;
+  return `${protocol}//${host}${path}`;
+};
+
+// src/hooks/useDeepEffect.ts
+function useDeepEffect(effect, deps) {
+  const prevDepsRef = useRef();
+  const depsChanged = !prevDepsRef.current || deps.length !== prevDepsRef.current.length || deps.some((dep, i) => !deepEqual(dep, prevDepsRef.current[i]));
+  useEffect(() => {
+    if (depsChanged) {
+      prevDepsRef.current = deps;
+      return effect();
+    }
+  }, [depsChanged]);
+}
+function useRefState(init) {
+  const [state, setState] = useState(init);
+  const stateRef = useRef(init);
+  const setProxy = (newVal) => {
+    stateRef.current = newVal;
+    setState(newVal);
+  };
+  const getState = () => stateRef.current;
+  return [state, setProxy, getState];
+}
+var useSyncInput = (storeValue, setStoreValue) => {
+  const [inputValue, setInputValue] = useState(storeValue);
+  useEffect(() => {
+    if (storeValue !== inputValue) {
+      setInputValue(storeValue);
+    }
+  }, [storeValue]);
+  const handleValueChange = (value) => {
+    setStoreValue(value);
+    setInputValue(value);
+  };
+  return {
+    inputValue,
+    setInputValue: handleValueChange
+  };
+};
+function useThrottle(func, wait) {
+  const { current } = useRef({ func, timeOut: null });
+  useEffect(() => {
+    current.func = func;
+  }, [func]);
+  let args;
+  function throttle(..._args) {
+    args = _args;
+    return new Promise((resolve, reject) => {
+      if (!current.timeOut) {
+        try {
+          const result = current.func.apply(null, args);
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        }
+        current.timeOut = setTimeout(() => {
+          current.timeOut = null;
+        }, wait);
+      }
+    });
+  }
+  function cancel() {
+    if (!current.timeOut) return;
+    clearTimeout(current.timeOut);
+    current.timeOut = null;
+  }
+  function flush() {
+    cancel();
+    return current.func.apply(null, args);
+  }
+  throttle.flush = flush;
+  throttle.cancel = cancel;
+  return useCallback(throttle, []);
+}
+dayjs.extend(relativeTime);
+var DateFormatType = "YYYY-MM-DD HH:mm:ss";
+var DateFormatType2 = "YYYY-MM-DD";
+var UNIT = "date";
+var getStartOfTimestamp = (date, unit = UNIT) => {
+  return dayjs(date).startOf(unit).valueOf();
+};
+var getEndOfTimestamp = (date, unit = UNIT) => {
+  return dayjs(date).endOf(unit).valueOf();
+};
+var formatDate = (date, fmt = DateFormatType) => {
+  if (date) {
+    return dayjs(date).format(fmt);
+  }
+  return "";
+};
+var getTimestamp = (date) => {
+  return dayjs(date).valueOf();
+};
+var isExpire = (date) => {
+  return dayjs(date).isBefore(getStartOfTimestamp());
+};
+var USER_KEY = "NS-USER";
+function setCurrentUser(userInfo) {
+  const cipherText = AES.encrypt(JSON.stringify(userInfo), "((#II))").toString();
+  sessionStorage.setItem(USER_KEY, cipherText);
+}
+function getCurrentUser() {
+  const userInfoJson = sessionStorage.getItem(USER_KEY);
+  if (userInfoJson) {
+    const bytes = AES.decrypt(userInfoJson, "((#II))");
+    const originalText = bytes.toString(encUtf8);
+    return JSON.parse(originalText);
+  }
+  return null;
+}
+function clearCurrentUser() {
+  sessionStorage.removeItem(USER_KEY);
+}
+var DEVICEID_KEY = "NS-DEVICE-ID";
+function getDeviceId() {
+  let deviceId = localStorage.getItem(DEVICEID_KEY);
+  if (deviceId) {
+    return deviceId;
+  }
+  deviceId = genNonDuplicateID();
+  localStorage.setItem(DEVICEID_KEY, deviceId);
+  return deviceId;
+}
+var OperatorToMethodName = {
+  "+": "plus",
+  "-": "minus",
+  "*": "times",
+  "/": "dividedBy"
+};
+var calculate = (operator, ...args) => {
+  if (args.length === 0) return "0";
+  const [arg, ...newArgs] = args;
+  return newArgs.reduce((acc, val) => acc[OperatorToMethodName[operator]](new Decimal(val)), new Decimal(arg)).toString();
+};
+var plus = (...args) => calculate("+", ...args);
+var minus = (...args) => calculate("-", ...args);
+var times = (...args) => calculate("*", ...args);
+var dividedBy = (...args) => calculate("/", ...args);
+var decimalPlaces = (arg1) => {
+  return new Decimal(arg1).decimalPlaces();
+};
+var precision = (arg1) => {
+  return new Decimal(arg1).precision(true);
+};
+var absVal = (arg1) => new Decimal(arg1).abs().toString();
+var compareNum = (arg1, arg2, type) => {
+  const x = new Decimal(arg1);
+  const y = new Decimal(arg2);
+  switch (type) {
+    case ">":
+      return x.greaterThan(y);
+    case ">=":
+      return x.greaterThanOrEqualTo(y);
+    case "<":
+      return x.lessThan(y);
+    case "<=":
+      return x.lessThanOrEqualTo(y);
+    case "==":
+      return x.equals(y);
+  }
+};
+var toFixed = (num, decimals = 2, fill = true) => {
+  const x = new Decimal(num);
+  if (fill) {
+    return x.toFixed(decimals, Decimal.ROUND_HALF_UP);
+  } else {
+    return x.toDecimalPlaces(decimals, Decimal.ROUND_HALF_UP).toString();
+  }
+};
+var isInteger = (num) => {
+  return new Decimal(num).isInteger();
+};
+var isNegative = (num) => {
+  return new Decimal(num).isNegative();
+};
+var cacheMessage = () => {
+  const contents = {};
+  return ({ title = "\u63D0\u793A", content, type = "warning", duration = 3, onClose, isCache = true, isOnly = false }) => {
+    if (!content) return;
+    const key = isOnly ? "cache-key" : content;
+    const onClose2 = () => {
+      delete contents[key];
+      onClose?.();
+    };
+    if (isCache && contents[key]) ; else {
+      if (isCache) {
+        contents[key] = getTimestamp();
+      }
+      if (duration) {
+        if (content.length > 30) {
+          notification[type]({
+            message: title,
+            description: content,
+            placement: "top",
+            duration,
+            onClose: onClose2
+          });
+        } else {
+          message[type]({
+            content,
+            duration,
+            onClose: onClose2
+          });
+        }
+      } else {
+        Modal[type]({
+          title,
+          content,
+          okButtonProps: { style: { background: LgPrimaryColor, outline: "none" } },
+          afterClose: onClose2
+        });
+      }
+    }
+  };
+};
+var showMessage = cacheMessage();
+
+// src/utils/session.ts
+var TOKEN_KEY = "NS-TOKEN";
+function setToken(accessToken) {
+  localStorage.setItem(TOKEN_KEY, accessToken);
+}
+function getUrlToken() {
+  const searchParams = new URLSearchParams(location.search);
+  const token = searchParams.get(TOKEN_KEY);
+  return token || "";
+}
+function getToken() {
+  const token = getUrlToken();
+  if (!token) {
+    const token2 = localStorage.getItem(TOKEN_KEY);
+    return token2 || "";
+  } else {
+    setToken(token);
+    return token;
+  }
+}
+function clearToken() {
+  localStorage.removeItem(TOKEN_KEY);
+}
+var SIGNPATH = "SIGNPATH";
+function getSignPath() {
+  const path = localStorage.getItem(SIGNPATH);
+  return `${path || "/sign-in"}`;
+}
+
+// src/utils/request.ts
+var OK = 200;
+var OK2 = "S0000";
+var ERROR = 500;
+var MISSING_PARAMETER = 400;
+var UNAUTHORIZED = 401;
+var FORBIDDEN = 403;
+var NOT_FOUND = 404;
+var ILLEGAL_PARAMETER = 901;
+var PERMISSION_DENIED = 13001;
+var LoginPastCode = 11200;
+var FacePastCode = 11201;
+var formType = "form";
+var jsonType = "json";
+var parseOptions = (options) => {
+  const headers = {};
+  if (options?.reqType && options.reqType === formType) {
+    headers["Content-Type"] = "application/x-www-form-urlencoded";
+  }
+  return { headers, ...options };
+};
+var redirectUrl = () => {
+  emit("jumpLink", { url: `/uc${getSignPath()}` });
+};
+axios.interceptors.request.use(
+  function(config) {
+    config.headers[TOKEN_KEY] = getToken();
+    if (config.url && !config.url.startsWith("/api/")) {
+      config.baseURL = "/api";
+    }
+    config.timeout = config.timeout || 6e4;
+    return config;
+  },
+  function(error) {
+    return Promise.reject(error);
+  }
+);
+axios.interceptors.response.use(
+  function(response) {
+    if (response.data?.code !== OK && response.data?.code !== OK2) {
+      const isPermission = response.data?.code === PERMISSION_DENIED;
+      if (response.config?.showError !== false) {
+        showMessage({
+          title: isPermission ? "" : void 0,
+          content: response.data.message,
+          duration: isPermission ? 0 : 3
+        });
+      }
+      return Promise.reject(response.data);
+    }
+    return response;
+  },
+  function(err) {
+    const showError = err?.config?.showError !== false;
+    if (!err.response) {
+      if (showError) showMessage({ content: "\u7F51\u7EDC\u5F02\u5E38\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC", type: "error" });
+    } else {
+      switch (err.response?.status) {
+        case UNAUTHORIZED:
+          if (showError) showMessage({ content: err.response?.data.message, type: "error" });
+          redirectUrl();
+          break;
+        case FORBIDDEN:
+        case NOT_FOUND:
+        case ERROR:
+        case MISSING_PARAMETER:
+        case ILLEGAL_PARAMETER:
+          if (showError) showMessage({ content: err.response?.data.message, type: "error" });
+          break;
+        default:
+          if (showError) showMessage({ content: "\u8BF7\u6C42\u6570\u636E\u53D1\u751F\u9519\u8BEF\uFF01", type: "info" });
+      }
+    }
+    return Promise.reject(err);
+  }
+);
+var get = async (url, params, options) => {
+  const res = await axios({ method: "get", url, params, ...options });
+  return res.data;
+};
+var post = async (url, data, options) => {
+  const res = await axios({
+    method: "post",
+    url,
+    data,
+    ...parseOptions(options)
+  });
+  return res.data;
+};
+var put = async (url, data, options) => {
+  const res = await axios({ method: "put", url, data, ...parseOptions(options) });
+  return res.data;
+};
+var del = async (url, data, options) => {
+  const reqConfig = {
+    method: "delete",
+    url,
+    ...parseOptions(options)
+  };
+  const params = options?.reqType === formType ? { params: data } : { data };
+  const res = await axios({ ...reqConfig, ...params });
+  return res.data;
+};
+var request_default = {
+  get,
+  post,
+  put,
+  delete: del
+};
+
+// src/hooks/useWebSocket.ts
+var useWebSocket = ({
+  url,
+  onMessage,
+  onClose,
+  heartbeatInterval = 3e4,
+  heartbeatMessage = "ping",
+  clientHeartbeat = true,
+  reconnectInterval = 5e3,
+  // 默认重连间隔为 5 秒
+  maxReconnectAttempts,
+  // 不设置默认值为无限重连
+  isReconnect = true
+  // 默认开启重连机制
+}) => {
+  const socketRef = useRef(null);
+  const heartbeatIntervalRef = useRef(null);
+  const [socketReadyState, setSocketReadyState] = useState(null);
+  const reconnectIntervalRef = useRef(null);
+  const reconnectAttempts = useRef(0);
+  const documentHide = useRef(document.visibilityState === "hidden");
+  const isDestroy = useRef(false);
+  const onMessageEctype = useCallback(onMessage, [onMessage]);
+  const startHeartbeat = (currentSocket) => {
+    if (!clientHeartbeat) {
+      return;
+    }
+    const intervalId = setInterval(() => {
+      if (currentSocket.readyState === WebSocket.OPEN) {
+        currentSocket.send(heartbeatMessage);
+      }
+    }, heartbeatInterval);
+    heartbeatIntervalRef.current = intervalId;
+  };
+  const stopHeartbeat = () => {
+    if (heartbeatIntervalRef.current) {
+      clearInterval(heartbeatIntervalRef.current);
+    }
+  };
+  const stopReconnectTimer = () => {
+    if (reconnectIntervalRef.current) {
+      clearTimeout(reconnectIntervalRef.current);
+      reconnectIntervalRef.current = null;
+    }
+  };
+  const tryReconnect = () => {
+    if (isDestroy.current) return;
+    if (isReconnect && !documentHide.current) {
+      if ((!isNumber(maxReconnectAttempts) || reconnectAttempts.current < maxReconnectAttempts) && isNullOrUnDef(reconnectIntervalRef.current)) {
+        reconnectIntervalRef.current = setTimeout(() => {
+          console.log(`\u5C1D\u8BD5\u7B2C ${reconnectAttempts.current + 1} \u6B21\u91CD\u8FDE...`, url);
+          reconnectAttempts.current = reconnectAttempts.current + 1;
+          createAndListenWebSocket();
+          stopReconnectTimer();
+        }, reconnectInterval);
+      } else {
+        if (isNumber(maxReconnectAttempts)) {
+          console.log("\u8FBE\u5230\u6700\u5927\u91CD\u8FDE\u5C1D\u8BD5\u6B21\u6570\uFF0C\u505C\u6B62\u91CD\u8FDE");
+        }
+      }
+    }
+  };
+  const handleOpen = (newSocket) => {
+    console.log("WebSocket \u8FDE\u63A5\u5DF2\u6253\u5F00");
+    setSocketReadyState(newSocket.readyState);
+    startHeartbeat(newSocket);
+    reconnectAttempts.current = 0;
+  };
+  const handleMessage = (event) => {
+    if (isString(event.data)) {
+      try {
+        const parsedData = JSON.parse(event.data);
+        onMessageEctype?.(parsedData);
+        stopHeartbeat();
+        startHeartbeat(socketRef.current);
+      } catch (error) {
+        console.error("\u89E3\u6790\u6D88\u606F\u6570\u636E\u65F6\u51FA\u9519:", error);
+      }
+    }
+  };
+  const handleClose = (event) => {
+    console.log("WebSocket \u8FDE\u63A5\u5DF2\u5173\u95ED", event.code, event.reason);
+    setSocketReadyState(event.code);
+    stopHeartbeat();
+    onClose?.();
+    tryReconnect();
+  };
+  const handleError = (error) => {
+    console.error("WebSocket \u53D1\u751F\u9519\u8BEF:", error);
+    setSocketReadyState(null);
+    stopHeartbeat();
+    tryReconnect();
+  };
+  const createAndListenWebSocket = () => {
+    const newSocket = new WebSocket(url);
+    socketRef.current = newSocket;
+    setSocketReadyState(newSocket.readyState);
+    newSocket.onopen = () => handleOpen(newSocket);
+    newSocket.onmessage = handleMessage;
+    newSocket.onclose = handleClose;
+    newSocket.onerror = handleError;
+  };
+  const handleVisibilityChange = () => {
+    documentHide.current = document.visibilityState === "hidden";
+    if (socketRef.current?.readyState !== WebSocket.OPEN) {
+      tryReconnect();
+    }
+  };
+  useEffect(() => {
+    isDestroy.current = false;
+    createAndListenWebSocket();
+    window.addEventListener("visibilitychange", handleVisibilityChange);
+    return () => {
+      window.removeEventListener("visibilitychange", handleVisibilityChange);
+      isDestroy.current = true;
+      if (socketRef.current) {
+        socketRef.current.close();
+        return;
+      }
+      stopHeartbeat();
+      stopReconnectTimer();
+    };
+  }, [url]);
+  const sendMessage = (message2) => {
+    if (socketRef.current?.readyState === WebSocket.OPEN) {
+      socketRef.current.send(message2);
+      stopHeartbeat();
+      startHeartbeat(socketRef.current);
+    }
+  };
+  return {
+    sendMessage,
+    socketReadyState
+  };
+};
+var useWebSocket_default = useWebSocket;
+var ProtectedView = ({
+  passwordStatus,
+  verifyPassword,
+  onVerifyPasswordEnd
+}) => {
+  const [form] = Form.useForm();
+  const onSubmit = () => {
+    form.validateFields().then((values) => {
+      if (values) {
+        verifyPassword(values.password);
+        onVerifyPasswordEnd(values.password);
+      }
+    });
+  };
+  return /* @__PURE__ */ jsx(Flex, { justify: "center", align: "center", className: "height-full", children: /* @__PURE__ */ jsxs("div", { style: { width: 300 }, children: [
+    passwordStatus === PasswordStatus.WrongPassword && /* @__PURE__ */ jsx(Alert, { message: "\u5BC6\u7801\u65E0\u6548\u3002\u8BF7\u518D\u8BD5\u4E00\u6B21\uFF01", type: "error" }),
+    /* @__PURE__ */ jsxs(Form, { form, size: "large", className: "m-t-24", children: [
+      /* @__PURE__ */ jsx(Form.Item, { name: "password", rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u5BC6\u7801" }], children: /* @__PURE__ */ jsx(Input.Password, { autoComplete: "new-password", placeholder: "\u8BF7\u8F93\u5165\u5BC6\u7801" }) }),
+      /* @__PURE__ */ jsx(Flex, { justify: "center", children: /* @__PURE__ */ jsx(Button, { type: "primary", onClick: onSubmit, children: "\u63D0 \u4EA4" }) })
+    ] })
+  ] }) });
+};
+var PdfPreview_default = ({ password, fileUrl, pageNo = 1, scale = 1, isHasThumbnails = true, onSetPassword, onSetPageNo }) => {
+  const embedRef = useRef(null);
+  const [sizes, setSizes] = useState([0]);
+  const [, setDocLoaded, getDocLoaded] = useRefState(false);
+  const [currentPage, setCurrentPage, getCurrentPage] = useRefState(void 0);
+  const [temporaryPassword, setTemporaryPassword] = useState("");
+  const jumpToPageNo = useRef();
+  const onVerifyPasswordEnd = (password2) => {
+    setTemporaryPassword(password2);
+  };
+  const pageNavigationPluginInstance = pageNavigationPlugin({ enableShortcuts: true });
+  const thumbnailPluginInstance = thumbnailPlugin({
+    thumbnailWidth: sizes[0] - 70
+    // 不会自适应
+  });
+  const zoomPluginInstance = zoomPlugin();
+  const { Thumbnails } = thumbnailPluginInstance;
+  const { ZoomIn, ZoomOut } = zoomPluginInstance;
+  const Toolbar = () => /* @__PURE__ */ jsxs(Flex, { gap: 6, align: "center", className: styles_module_default.pdfToolbar, children: [
+    /* @__PURE__ */ jsx(ZoomIn, {}),
+    /* @__PURE__ */ jsx(ZoomOut, {})
+  ] });
+  const onJumpToPage = (pageNo2) => {
+    if (getDocLoaded()) {
+      if (pageNo2 && pageNo2 - 1 !== getCurrentPage()) {
+        jumpToPageNo.current = pageNo2 - 1;
+        pageNavigationPluginInstance.jumpToPage(jumpToPageNo.current);
+      }
+    }
+  };
+  const handleDocumentLoad = () => {
+    setSizes([400]);
+    setDocLoaded(true);
+    onJumpToPage(pageNo);
+    if (temporaryPassword) {
+      onSetPassword?.(temporaryPassword);
+      setTemporaryPassword("");
+    }
+  };
+  useEffect(() => {
+    setCurrentPage(void 0);
+    setDocLoaded(false);
+    setSizes([0]);
+  }, [fileUrl]);
+  useEffect(() => {
+    setTimeout(() => {
+      onJumpToPage(pageNo);
+    }, 0);
+  }, [pageNo]);
+  const renderError = (error) => {
+    let message2 = "";
+    switch (error.name) {
+      case "InvalidPDFException":
+        message2 = "\u6587\u4EF6\u65E0\u6548\u6216\u5DF2\u635F\u574F";
+        break;
+      case "MissingPDFException":
+        message2 = "\u6587\u4EF6\u4E0D\u5B58\u5728";
+        break;
+      case "UnexpectedResponseException":
+        message2 = "\u610F\u5916\u7684\u670D\u52A1\u5668\u54CD\u5E94";
+        break;
+      // case 'CMapReaderFactory not initialized':
+      //   message = '字体映射文件加载失败，请刷新页面重试'
+      //   break
+      default:
+        message2 = "\u65E0\u6CD5\u52A0\u8F7D\u6587\u6863";
+        break;
+    }
+    return /* @__PURE__ */ jsx(Flex, { className: "height-full", justify: "center", align: "center", children: /* @__PURE__ */ jsx(Alert, { message: message2, type: "error", showIcon: true }) });
+  };
+  const onPageChange = (e) => {
+    let newCurrentPage = e.currentPage;
+    if (isNumber(jumpToPageNo.current)) {
+      newCurrentPage = jumpToPageNo.current;
+      setTimeout(() => {
+        jumpToPageNo.current = void 0;
+      }, 1e3);
+    }
+    setCurrentPage(newCurrentPage);
+  };
+  useEffect(() => {
+    if (!(embedRef.current && isNumber(currentPage))) return;
+    setTimeout(() => {
+      const pages = embedRef.current?.querySelectorAll(".rpv-core__viewer .rpv-core__page-layer");
+      pages?.forEach((page) => {
+        if (Number(page.getAttribute("data-virtual-index")) === currentPage) {
+          page.classList.add("current-page-highlight");
+        } else {
+          page.classList.remove("current-page-highlight");
+        }
+      });
+    }, 500);
+    onSetPageNo?.(currentPage + 1);
+  }, [currentPage]);
+  return /* @__PURE__ */ jsx("div", { ref: embedRef, className: styles_module_default.nsPreviewPdf, children: /* @__PURE__ */ jsx(Worker, { workerUrl: `/uc/pdf/pdf.worker.min.js`, children: /* @__PURE__ */ jsxs(Splitter, { onResize: setSizes, children: [
+    isHasThumbnails && /* @__PURE__ */ jsx(Splitter.Panel, { resizable: false, size: sizes[0], min: 250, max: 500, collapsible: true, children: /* @__PURE__ */ jsx(Thumbnails, {}) }),
+    /* @__PURE__ */ jsx(Splitter.Panel, { children: /* @__PURE__ */ jsxs("div", { className: "height-full", children: [
+      /* @__PURE__ */ jsx(
+        Viewer,
+        {
+          localization: zh_CN,
+          withCredentials: true,
+          onDocumentAskPassword: (e) => {
+            setTemporaryPassword("");
+            e.verifyPassword(password || "");
+          },
+          transformGetDocumentParams: (options) => {
+            return Object.assign({}, options, {
+              // disableRange: false,
+              disableStream: true,
+              // 建议传入是否加密字段来控制
+              httpHeaders: { "Cache-Control": "no-cache" },
+              // 启用 CMap 支持，解决中文字体显示问题
+              // cMapUrl: 指定 CMap 文件的 URL，用于处理非拉丁字符（如中文）
+              // cMapPacked: 使用压缩的 CMap 文件以提高性能
+              cMapUrl: "/uc/pdf/pdfjs-dist@3.2.146/cmaps/",
+              // 使用可用的源
+              cMapPacked: true,
+              // 禁用字体子集化，确保完整字体加载
+              disableFontFace: false,
+              // 启用标准字体支持
+              standardFontDataUrl: "/uc/pdf/pdfjs-dist@3.2.146/standard_fonts/",
+              // 设置字体回退策略
+              fallbackFontName: "Helvetica"
+            });
+          },
+          fileUrl,
+          defaultScale: scale,
+          plugins: [
+            pageNavigationPluginInstance,
+            thumbnailPluginInstance,
+            zoomPluginInstance
+            // printPluginInstance,
+            // rotatePluginInstance,
+            // searchPluginInstance,
+          ],
+          onPageChange,
+          renderError,
+          onDocumentLoad: handleDocumentLoad,
+          renderProtectedView: (renderProps) => /* @__PURE__ */ jsx(ProtectedView, { onVerifyPasswordEnd, ...renderProps })
+        }
+      ),
+      /* @__PURE__ */ jsx(Toolbar, {})
+    ] }) })
+  ] }) }) });
+};
+var FilePreview_default = ({ suffix, fileUrl, pdfParams, password, searchValue }) => {
+  const Preview = useMemo(() => {
+    if (!fileUrl) {
+      return /* @__PURE__ */ jsx(Empty, {});
+    }
+    switch (suffix?.toUpperCase()) {
+      case "PNG":
+      case "JPG":
+      case "JPEG":
+      case "GIF":
+        return /* @__PURE__ */ jsx(Image, { rootClassName: styles_module_default.nsPreviewImage, src: fileUrl, alt: "\u9884\u89C8\u56FE\u7247" });
+      case "PDF":
+        return /* @__PURE__ */ jsx(PdfPreview_default, { fileUrl, ...pdfParams, password });
+      // onSetPassword={onSetPassword}
+      case "MP4":
+        return /* @__PURE__ */ jsx(VideoPlayer_default, { fileUrl });
+      case "MP3":
+        return /* @__PURE__ */ jsx(AudioPlayer_default, { fileUrl });
+      case "MD":
+      case "MARKDOWN":
+        return /* @__PURE__ */ jsx(MarkdownPreview_default, { fileUrl, searchValue });
+      default:
+        return /* @__PURE__ */ jsx(Result, { subTitle: `\u6682\u4E0D\u652F\u6301 ${suffix || ""} \u6587\u4EF6\u7684\u9884\u89C8` });
+    }
+  }, [suffix, fileUrl, pdfParams]);
+  return /* @__PURE__ */ jsx(Flex, { justify: "center", align: "center", className: "height-full", children: Preview });
+};
+var FilePreviewDrawer_default = ({ open, fileUrl, suffix, title = "\u6587\u4EF6\u9884\u89C8", onClose, password, fileParams, pdfParams, onSetPassSuccess }) => {
+  return /* @__PURE__ */ jsx(Drawer, { title, push: false, width: "100%", open, onClose, children: /* @__PURE__ */ jsx(
+    FilePreview_default,
+    {
+      fileUrl,
+      suffix,
+      password,
+      fileParams,
+      pdfParams,
+      onSetPassSuccess
+    }
+  ) });
+};
+
+// src/components/Iframe/styles.module.less
+var styles_module_default2 = {
+  iframe: "styles_module_iframe"
+};
+var Iframe_default = forwardRef(({ id, src, className, onLoad }, ref) => {
+  const [loading, setLoading] = useState(false);
+  const finalSrc = useMemo(() => {
+    return buildUrlParams({ v: Date.now() }, addUrlLastSlash(getUrlMainSource(src, location.href)));
+  }, [src]);
+  const onHandleLoad = () => {
+    setLoading(false);
+    onLoad?.();
+  };
+  useEffect(() => {
+    setLoading(true);
+  }, [src]);
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(Spin, { spinning: loading, wrapperClassName: "full-spin", tip: "\u52A0\u8F7D\u4E2D...", children: /* @__PURE__ */ jsx("iframe", { id, ref, src: finalSrc, className: classNames(styles_module_default2.iframe, className), onLoad: onHandleLoad }) }) });
+});
+function isRenderFn(node) {
+  return isFunction(node) || isObject(node) && !isNull(node) && "$$typeof" in node && node.$$typeof === Symbol.for("react.forward_ref");
+}
+function renderDefault(DefaultComponent, props) {
+  if (!DefaultComponent) return null;
+  return isRenderFn(DefaultComponent) ? /* @__PURE__ */ jsx(DefaultComponent, { ...props }) : DefaultComponent;
+}
+function RenderWrapper({ control = true, ctx, DefaultComponent }) {
+  if (control === false || isNull(control)) return null;
+  if (control === true || control === void 0) {
+    return renderDefault(DefaultComponent);
+  }
+  const { visible = true, render, props } = control;
+  if (!visible) return null;
+  if (render) {
+    return typeof render === "function" ? render(ctx) : render;
+  }
+  return renderDefault(DefaultComponent, props);
+}
+var shouldRender = (control) => control != null && (isBoolean(control) ? control : control?.visible !== false);
+function propsMerge(control, props) {
+  if (control === true || control === void 0) {
+    return {
+      props
+    };
+  }
+  if (isObject(control) && (control?.visible === true || control?.visible === void 0)) {
+    return {
+      props: {
+        ...props,
+        ...control?.props
+      }
+    };
+  }
+  return null;
+}
+var UserAvatar_default = ({ size, avatarSrc, userName }) => {
+  return avatarSrc ? /* @__PURE__ */ jsx(Avatar, { size, src: avatarSrc }) : /* @__PURE__ */ jsx(Avatar, { size, className: "cursor-pointer", style: { backgroundColor: LgPrimaryColor }, children: userName?.slice(0, 1)?.toLocaleUpperCase() });
+};
+
+export { AudioPlayer_default as AudioPlayer, DateFormatType, DateFormatType2, ERROR, FORBIDDEN, FacePastCode, FileIcon_default as FileIcon, FilePreview_default as FilePreview, FilePreviewDrawer_default as FilePreviewDrawer, ILLEGAL_PARAMETER, Iframe_default as Iframe, LazyComponent_default as LazyComponent, LgPrimaryColor, LoginPastCode, MISSING_PARAMETER, MarkdownPreview_default as MarkdownPreview, NOT_FOUND, OK, OK2, PERMISSION_DENIED, PdfPreview_default as PdfPreview, RenderMarkdown_default as RenderMarkdown, RenderWrapper, TOKEN_KEY, UNAUTHORIZED, UserAvatar_default as UserAvatar, VideoPlayer_default as VideoPlayer, absVal, addUrlLastSlash, arrToObj, buildUrlParams, calculate, clearCurrentUser, clearToken, compareNum, copyText, createValtioContext, decimalPlaces, deepCopy, deepEqual, deepMerge, dividedBy, downloadFile, emit, emitToChild, formType, formatDate, formatNumberWithCommas, genNonDuplicateID, generateRandomNumbers, getCurrentUser, getDeviceId, getEndOfTimestamp, getFileName, getSignPath, getStartOfTimestamp, getTimestamp, getToken, getUrlMainSource, getUrlToken, getWebSocketUrl, is, isArray, isBlob, isBoolean, isClient, isDate, isDef, isElement, isEmpty, isEmptyObj, isExpire, isExternal, isFunction, isInteger, isMap, isNegative, isNull, isNullOrUnDef, isNumber, isNumberNoNaN, isObject, isPromise, isRegExp, isServer, isString, isUnDef, isWindow, jsonType, minus, nsSetInterval, objToOptions, plus, precision, propsMerge, request_default as request, setCurrentUser, setToken, shouldRender, textAreaView, themeConfig, times, toFixed, useDebounce, useDeepEffect, useIframeRelayBridge, useRefState, useSyncInput, useThrottle, useWebSocket_default as useWebSocket };
+//# sourceMappingURL=index.esm.js.map
+//# sourceMappingURL=index.esm.js.map