@qy_better_lib/hooks 0.2.5 → 0.2.7

package/lib/index.mjs

@@ -0,0 +1,935 @@
+import mitt from "mitt";
+import { onMounted, onUnmounted, ref, shallowRef } from "vue";
+import { guid, on, off, get_window_size, get_element, is_object, download_file, to_base64, compress_image } from "@qy_better_lib/core";
+function createAsyncEmitter() {
+  if (typeof mitt === "undefined") {
+    return {};
+  }
+  const emitter2 = mitt();
+  emitter2.emitAsync = async function(type, ...args) {
+    const handlers = this.all?.get(type);
+    if (!handlers || handlers.length === 0) {
+      return [];
+    }
+    const promises = handlers.map((handler) => {
+      try {
+        const result = handler(...args);
+        return result instanceof Promise ? result : Promise.resolve(result);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+    return Promise.all(promises);
+  };
+  emitter2.emit;
+  emitter2.emit = function(type, ...args) {
+    const handlers = this.all?.get(type);
+    if (!handlers || handlers.length === 0) {
+      return void 0;
+    }
+    let lastResult;
+    handlers.forEach((handler) => {
+      try {
+        lastResult = handler(...args);
+      } catch (error) {
+        console.error(`Error in event handler for ${type}:`, error);
+      }
+    });
+    return lastResult;
+  };
+  return emitter2;
+}
+const emitter = createAsyncEmitter();
+function use_emit(event_list) {
+  if (typeof mitt === "undefined") return { emitter: {} };
+  onMounted(() => {
+    if (event_list && event_list.length > 0) {
+      for (const event of event_list) {
+        emitter.on(event.key, event.value);
+      }
+    }
+  });
+  onUnmounted(() => {
+    if (event_list && event_list.length > 0) {
+      for (const event of event_list) {
+        emitter.off(event.key, event.value);
+      }
+    }
+  });
+  return {
+    emitter
+  };
+}
+function use_print() {
+  let preview_container = null;
+  let print_in_progress = false;
+  function get_style(custom_style, options) {
+    const page_size = options?.page_size || "A4";
+    const page_orientation = options?.page_orientation || "portrait";
+    const margin = options?.margin || "1cm";
+    const print_background = options?.print_background ? "true" : "false";
+    const default_style = `#print-container {
+            display: none;
+        }
+        #preview-container {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(0, 0, 0, 0.8);
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            z-index: 9999;
+            overflow: auto;
+        }
+        #preview-content {
+            background: white;
+            width: 80%;
+            max-width: 800px;
+            padding: 20px;
+            box-shadow: 0 0 20px rgba(0, 0, 0, 0.3);
+            position: relative;
+        }
+        #preview-close {
+            position: absolute;
+            top: 10px;
+            right: 10px;
+            background: #333;
+            color: white;
+            border: none;
+            border-radius: 50%;
+            width: 30px;
+            height: 30px;
+            cursor: pointer;
+            font-size: 16px;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+        #preview-print {
+            margin-top: 20px;
+            padding: 10px 20px;
+            background: #007bff;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 16px;
+        }
+        @media print {
+            body > :not(#print-container) {
+                display: none;
+            }
+            html,
+            body {
+                display: block !important;
+                margin: 0;
+                padding: 0;
+                width: 100%;
+                height: 100%;
+                -webkit-print-color-adjust: ${print_background};
+                print-color-adjust: ${print_background};
+            }
+            #print-container {
+                display: block;
+                padding: 20px;
+                width: 100%;
+                height: 100%;
+                box-sizing: border-box;
+            }
+        }
+        @page {
+            size: ${page_size} ${page_orientation};
+            margin: ${margin};
+        }`;
+    const style = document.createElement("style");
+    style.innerHTML = custom_style || default_style;
+    return style;
+  }
+  function clean_print() {
+    const existing_container = document.getElementById("print-container");
+    if (existing_container) {
+      try {
+        document.body.removeChild(existing_container);
+      } catch (error) {
+        console.error("清理打印容器失败:", error);
+      }
+    }
+  }
+  function clean_preview() {
+    const existing_preview = document.getElementById("preview-container");
+    if (existing_preview) {
+      try {
+        document.body.removeChild(existing_preview);
+        preview_container = null;
+      } catch (error) {
+        console.error("清理预览容器失败:", error);
+      }
+    }
+  }
+  function get_container(html_content) {
+    clean_print();
+    const container = document.createElement("div");
+    container.setAttribute("id", "print-container");
+    container.innerHTML = html_content;
+    return container;
+  }
+  function get_load_promise(container) {
+    if (!container || typeof container.querySelectorAll !== "function") {
+      return Promise.resolve();
+    }
+    const img_elements = container.querySelectorAll("img");
+    const imgs = Array.from(img_elements);
+    if (imgs.length === 0) {
+      return Promise.resolve();
+    }
+    let finished_count = 0;
+    return new Promise((resolve, reject) => {
+      function check() {
+        finished_count++;
+        if (finished_count === imgs.length) {
+          resolve();
+        }
+      }
+      imgs.forEach((img) => {
+        if (img.complete) {
+          check();
+        } else {
+          img.addEventListener("load", check);
+          img.addEventListener("error", check);
+        }
+      });
+      setTimeout(() => {
+        reject(new Error("图片加载超时"));
+      }, 1e4);
+    });
+  }
+  async function print(html_content, options) {
+    if (print_in_progress) {
+      console.warn("打印已在进行中");
+      return;
+    }
+    try {
+      print_in_progress = true;
+      const style = get_style(options?.custom_style, options);
+      const container = get_container(html_content);
+      document.body.appendChild(style);
+      document.body.appendChild(container);
+      await get_load_promise(container);
+      window.print();
+      setTimeout(() => {
+        try {
+          if (style.parentNode) {
+            style.parentNode.removeChild(style);
+          }
+          if (container.parentNode) {
+            container.parentNode.removeChild(container);
+          }
+          print_in_progress = false;
+          options?.on_complete?.();
+        } catch (error) {
+          console.error("清理打印元素失败:", error);
+          options?.on_error?.(error);
+        }
+      }, 100);
+    } catch (error) {
+      console.error("打印失败:", error);
+      print_in_progress = false;
+      options?.on_error?.(error);
+    }
+  }
+  async function preview(html_content, options) {
+    try {
+      clean_preview();
+      const style = get_style(options?.custom_style, options);
+      const content = document.createElement("div");
+      content.innerHTML = html_content;
+      await get_load_promise(content);
+      const preview_wrapper = document.createElement("div");
+      preview_wrapper.setAttribute("id", "preview-container");
+      const preview_content = document.createElement("div");
+      preview_content.setAttribute("id", "preview-content");
+      preview_content.appendChild(content);
+      const close_button = document.createElement("button");
+      close_button.setAttribute("id", "preview-close");
+      close_button.textContent = "×";
+      close_button.addEventListener("click", () => {
+        clean_preview();
+        options?.on_cancel?.();
+      });
+      const print_button = document.createElement("button");
+      print_button.setAttribute("id", "preview-print");
+      print_button.textContent = "打印";
+      print_button.addEventListener("click", () => {
+        clean_preview();
+        print(html_content, options);
+      });
+      preview_content.appendChild(close_button);
+      preview_content.appendChild(print_button);
+      preview_wrapper.appendChild(preview_content);
+      document.body.appendChild(style);
+      document.body.appendChild(preview_wrapper);
+      preview_container = preview_wrapper;
+    } catch (error) {
+      console.error("预览失败:", error);
+      options?.on_error?.(error);
+    }
+  }
+  async function print_html(dom_selector, options) {
+    try {
+      const target_element = document.querySelector(dom_selector);
+      if (target_element) {
+        if (options?.preview) {
+          await preview(target_element.innerHTML, options);
+        } else {
+          await print(target_element.innerHTML, options);
+        }
+      } else {
+        throw new Error(`未找到DOM节点: ${dom_selector}`);
+      }
+    } catch (error) {
+      console.error("打印DOM元素失败:", error);
+      options?.on_error?.(error);
+    }
+  }
+  async function print_html_element(element_array, options) {
+    try {
+      if (!element_array || element_array.length === 0) {
+        throw new Error("元素数组为空");
+      }
+      let html_content = "";
+      for (const element of element_array) {
+        html_content += element.outerHTML;
+      }
+      if (!html_content) {
+        throw new Error("元素内容为空");
+      }
+      if (options?.preview) {
+        await preview(html_content, options);
+      } else {
+        await print(html_content, options);
+      }
+    } catch (error) {
+      console.error("打印元素数组失败:", error);
+      options?.on_error?.(error);
+    }
+  }
+  function preview_html(dom_selector, options) {
+    try {
+      const target_element = document.querySelector(dom_selector);
+      if (target_element) {
+        preview(target_element.innerHTML, options);
+      } else {
+        throw new Error(`未找到DOM节点: ${dom_selector}`);
+      }
+    } catch (error) {
+      console.error("预览DOM元素失败:", error);
+      options?.on_error?.(error);
+    }
+  }
+  function preview_html_element(element_array, options) {
+    try {
+      if (!element_array || element_array.length === 0) {
+        throw new Error("元素数组为空");
+      }
+      let html_content = "";
+      for (const element of element_array) {
+        html_content += element.outerHTML;
+      }
+      if (!html_content) {
+        throw new Error("元素内容为空");
+      }
+      preview(html_content, options);
+    } catch (error) {
+      console.error("预览元素数组失败:", error);
+      options?.on_error?.(error);
+    }
+  }
+  function close_preview() {
+    clean_preview();
+  }
+  return {
+    print_html,
+    print_html_element,
+    preview_html,
+    preview_html_element,
+    close_preview
+  };
+}
+function use_water_mark() {
+  const id = guid();
+  let current_options = null;
+  let resize_handler = null;
+  function get_wrapper(wrapper) {
+    return wrapper ? get_element(wrapper) || document.body : document.body;
+  }
+  function create_watermark_canvas(options) {
+    const { text1, text2, font_size = 16, font_family = "Avenir,Helvetica,Arial,sans-serif", rotate = -15, text_color = "#999", opacity = 0.1, size = { width: 250, height: 150 } } = options;
+    try {
+      const canvas = document.createElement("canvas");
+      canvas.width = size.width;
+      canvas.height = size.height;
+      const ctx = canvas.getContext("2d");
+      if (ctx) {
+        ctx.font = `${font_size}px ${font_family}`;
+        ctx.fillStyle = text_color.replace(/\,\s(1|(0\.\d+)\))/, `, ${opacity}`);
+        ctx.textAlign = "left";
+        ctx.textBaseline = "middle";
+        ctx.rotate(rotate * Math.PI / 180);
+        ctx.fillText(text1, 0, canvas.height / 2);
+        if (text2) {
+          const text1_width = ctx.measureText(text1).width;
+          ctx.fillText(text2, text1_width + 16, canvas.height / 2);
+        }
+      }
+      return canvas;
+    } catch (error) {
+      console.error("创建水印画布失败:", error);
+      const canvas = document.createElement("canvas");
+      canvas.width = 0;
+      canvas.height = 0;
+      return canvas;
+    }
+  }
+  function create_watermark_element(options) {
+    const {
+      wrapper,
+      z_index = 1e5,
+      position = "fixed",
+      spacing = 0,
+      size = { width: 250, height: 150 }
+    } = options;
+    const wrapper_element = get_wrapper(wrapper);
+    const existing_element = document.getElementById(id);
+    if (existing_element) {
+      try {
+        wrapper_element.removeChild(existing_element);
+      } catch (error) {
+        console.error("移除旧水印失败:", error);
+      }
+    }
+    const canvas = create_watermark_canvas(options);
+    const div = document.createElement("div");
+    div.id = id;
+    div.style.pointerEvents = "none";
+    div.style.top = "0px";
+    div.style.left = "0px";
+    div.style.position = position;
+    div.style.zIndex = z_index.toString();
+    const window_size = get_window_size();
+    div.style.width = window_size.width + "px";
+    div.style.height = window_size.height + "px";
+    div.style.background = `url(${canvas.toDataURL("image/png")}) left top repeat`;
+    if (spacing > 0) {
+      div.style.backgroundSize = `${size.width + spacing}px ${size.height + spacing}px`;
+    }
+    try {
+      wrapper_element.appendChild(div);
+    } catch (error) {
+      console.error("添加水印失败:", error);
+    }
+  }
+  function handle_resize() {
+    if (current_options) {
+      create_watermark_element(current_options);
+    }
+  }
+  function create_water_mark(options) {
+    current_options = options;
+    create_watermark_element(options);
+    if (options.responsive) {
+      if (!resize_handler) {
+        resize_handler = handle_resize;
+        on(window, "resize", resize_handler);
+      }
+    } else if (resize_handler) {
+      off(window, "resize", resize_handler);
+      resize_handler = null;
+    }
+  }
+  function remove_water_mark() {
+    const existing_element = document.getElementById(id);
+    if (existing_element) {
+      try {
+        const parent = existing_element.parentElement;
+        if (parent) {
+          parent.removeChild(existing_element);
+        }
+      } catch (error) {
+        console.error("移除水印失败:", error);
+      }
+    }
+    if (resize_handler) {
+      off(window, "resize", resize_handler);
+      resize_handler = null;
+    }
+    current_options = null;
+  }
+  function update_water_mark(options) {
+    if (current_options) {
+      const new_options = { ...current_options, ...options };
+      create_water_mark(new_options);
+    } else {
+      console.warn("水印未初始化，请先调用 create_water_mark");
+    }
+  }
+  function has_water_mark() {
+    return document.getElementById(id) !== null;
+  }
+  return {
+    create_water_mark,
+    remove_water_mark,
+    update_water_mark,
+    has_water_mark
+  };
+}
+function use_web_socket(options) {
+  const {
+    server,
+    receive,
+    max_reconnect_attempts = 5,
+    reconnect_interval = 5e3,
+    heartbeat_interval = 3e4,
+    heartbeat_message = "ping",
+    on_open,
+    on_error,
+    on_close,
+    auto_reconnect = true,
+    auto_connect = true,
+    max_message_queue_size = 100
+  } = options;
+  let reconnect_count = 0;
+  let lock_reconnect = false;
+  let ws = void 0;
+  let reconnect_timer = null;
+  let heartbeat_timer = null;
+  let message_queue = [];
+  let last_heartbeat_time = 0;
+  const heartbeat_timeout = heartbeat_interval * 1.5;
+  if (typeof window !== "undefined") {
+    window.onbeforeunload = () => {
+      close();
+    };
+  }
+  function create() {
+    try {
+      console.log("正在连接WebSocket:", server);
+      ws = new WebSocket(server);
+      init_event_handlers();
+    } catch (error) {
+      console.error("WebSocket连接建立异常:", error);
+      on_error?.(error);
+      if (auto_reconnect) {
+        reconnect();
+      }
+    }
+  }
+  function init_event_handlers() {
+    if (!ws) return;
+    ws.onopen = () => {
+      console.log("WebSocket连接成功:", server);
+      reconnect_count = 0;
+      last_heartbeat_time = Date.now();
+      start_heartbeat();
+      flush_message_queue();
+      on_open?.();
+    };
+    ws.onerror = (error) => {
+      console.error("WebSocket连接错误:", error);
+      on_error?.(error);
+    };
+    ws.onclose = (event) => {
+      console.log("WebSocket连接关闭:", (/* @__PURE__ */ new Date()).toLocaleTimeString(), "原因:", event.code, event.reason);
+      stop_heartbeat();
+      on_close?.();
+      if (auto_reconnect && !event.wasClean) {
+        reconnect();
+      }
+    };
+    ws.onmessage = (event) => {
+      try {
+        last_heartbeat_time = Date.now();
+        receive(event);
+      } catch (error) {
+        console.error("WebSocket消息处理错误:", error);
+        console.log("原始消息:", event.data);
+      }
+    };
+  }
+  function reconnect() {
+    if (reconnect_count >= max_reconnect_attempts) {
+      console.error("WebSocket重连失败次数过多，停止重连");
+      close();
+      return;
+    }
+    if (lock_reconnect) return;
+    lock_reconnect = true;
+    console.log(`WebSocket尝试重连 ${reconnect_count + 1}/${max_reconnect_attempts}...`);
+    reconnect_timer = setTimeout(() => {
+      create();
+      reconnect_count++;
+      lock_reconnect = false;
+      clear_reconnect_timer();
+    }, reconnect_interval);
+  }
+  function clear_reconnect_timer() {
+    if (reconnect_timer) {
+      clearTimeout(reconnect_timer);
+      reconnect_timer = null;
+    }
+  }
+  function start_heartbeat() {
+    stop_heartbeat();
+    heartbeat_timer = setInterval(() => {
+      send_heartbeat();
+      check_heartbeat_timeout();
+    }, heartbeat_interval);
+  }
+  function stop_heartbeat() {
+    if (heartbeat_timer) {
+      clearInterval(heartbeat_timer);
+      heartbeat_timer = null;
+    }
+  }
+  function send_heartbeat() {
+    if (ws?.readyState === WebSocket.OPEN) {
+      try {
+        const heartbeat_msg = is_object(heartbeat_message) ? JSON.stringify(heartbeat_message) : heartbeat_message;
+        ws.send(heartbeat_msg);
+      } catch (error) {
+        console.error("发送心跳消息失败:", error);
+      }
+    }
+  }
+  function check_heartbeat_timeout() {
+    const now = Date.now();
+    if (now - last_heartbeat_time > heartbeat_timeout) {
+      console.error("WebSocket心跳超时，尝试重连");
+      reconnect();
+    }
+  }
+  function send_message(msg) {
+    if (ws?.readyState === WebSocket.OPEN) {
+      try {
+        const message = is_object(msg) ? JSON.stringify(msg) : msg;
+        ws.send(message);
+        return true;
+      } catch (error) {
+        console.error("发送消息失败:", error);
+        add_to_message_queue(msg);
+        return false;
+      }
+    } else {
+      console.warn("WebSocket未连接，消息已加入队列");
+      add_to_message_queue(msg);
+      return false;
+    }
+  }
+  function add_to_message_queue(msg) {
+    if (message_queue.length >= max_message_queue_size) {
+      const removed_msg = message_queue.shift();
+      console.warn("消息队列已满，移除最旧的消息:", removed_msg);
+    }
+    message_queue.push(msg);
+    console.log(`消息已加入队列，当前队列大小: ${message_queue.length}/${max_message_queue_size}`);
+  }
+  function flush_message_queue() {
+    if (ws?.readyState === WebSocket.OPEN && message_queue.length > 0) {
+      console.log(`发送队列中的 ${message_queue.length} 条消息`);
+      while (message_queue.length > 0) {
+        const msg = message_queue.shift();
+        send_message(msg);
+      }
+    }
+  }
+  function close() {
+    stop_heartbeat();
+    clear_reconnect_timer();
+    if (ws) {
+      try {
+        ws.close();
+      } catch (error) {
+        console.error("关闭WebSocket失败:", error);
+      }
+      ws = void 0;
+    }
+    message_queue = [];
+  }
+  function get_status() {
+    if (!ws) return "CLOSED";
+    switch (ws.readyState) {
+      case WebSocket.CONNECTING:
+        return "CONNECTING";
+      case WebSocket.OPEN:
+        return "OPEN";
+      case WebSocket.CLOSING:
+        return "CLOSING";
+      case WebSocket.CLOSED:
+        return "CLOSED";
+      default:
+        return "UNKNOWN";
+    }
+  }
+  if (auto_connect) {
+    create();
+  }
+  return {
+    ws,
+    create,
+    close,
+    send_message,
+    get_status,
+    reconnect,
+    start_heartbeat,
+    stop_heartbeat
+  };
+}
+var EImageType = /* @__PURE__ */ ((EImageType2) => {
+  EImageType2["PNG"] = "image/png";
+  EImageType2["JPEG"] = "image/jpeg";
+  EImageType2["GIF"] = "image/gif";
+  return EImageType2;
+})(EImageType || {});
+function use_image() {
+  function check_image_type(type) {
+    return Object.values(EImageType).includes(type);
+  }
+  async function canvas_to_data_url(canvas, quality = 0.92, type = EImageType.JPEG) {
+    if (!check_image_type(type)) {
+      type = EImageType.JPEG;
+    }
+    return canvas.toDataURL(type, quality);
+  }
+  async function canvas_to_file(canvas, file_name = "image", quality = 0.92, type = EImageType.JPEG) {
+    const data_url = await canvas_to_data_url(canvas, quality, type);
+    return data_url_to_file(data_url, type, file_name);
+  }
+  async function data_url_to_file(data_url, type = EImageType.JPEG, file_name = "image") {
+    if (!check_image_type(type)) {
+      type = EImageType.JPEG;
+    }
+    const arr = data_url.split(",");
+    const mime = arr[0].match(/:(.*?);/)?.[1] || type;
+    const bstr = atob(arr[1]);
+    let n = bstr.length;
+    const u8arr = new Uint8Array(n);
+    while (n--) {
+      u8arr[n] = bstr.charCodeAt(n);
+    }
+    const extension = mime.split("/")[1];
+    const full_name = `${file_name}.${extension}`;
+    return new File([u8arr], full_name, { type: mime });
+  }
+  async function data_url_to_image(data_url) {
+    return new Promise((resolve, reject) => {
+      const image = new Image();
+      image.onload = () => resolve(image);
+      image.onerror = reject;
+      image.src = data_url;
+    });
+  }
+  function download_file$1(blob, file_name = "download") {
+    const url = URL.createObjectURL(blob);
+    download_file({ path: url, name: file_name });
+    URL.revokeObjectURL(url);
+  }
+  async function file_to_data_url(file) {
+    const result = await to_base64(file);
+    if (!result) {
+      throw new Error("转换文件为DataURL失败");
+    }
+    return result;
+  }
+  async function image_to_canvas(image, config = {}) {
+    const canvas = document.createElement("canvas");
+    const context = canvas.getContext("2d");
+    if (!context) {
+      throw new Error("创建Canvas上下文失败");
+    }
+    const width = config.width || image.width;
+    const height = config.height || image.height;
+    const scale = config.scale || 1;
+    canvas.width = width * scale;
+    canvas.height = height * scale;
+    context.scale(scale, scale);
+    context.drawImage(image, 0, 0, width, height);
+    return canvas;
+  }
+  async function url_to_blob(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`获取图片失败: ${response.statusText}`);
+    }
+    return response.blob();
+  }
+  async function url_to_image(url) {
+    return new Promise((resolve, reject) => {
+      const image = new Image();
+      image.onload = () => resolve(image);
+      image.onerror = reject;
+      image.src = url;
+    });
+  }
+  async function compress(file, config = {}) {
+    if (!(file instanceof Blob)) {
+      throw new Error("compress(): 第一个参数必须是Blob对象或File对象");
+    }
+    const quality = Math.max(0, Math.min(1, isNaN(Number(config.quality)) ? 0.92 : Number(config.quality)));
+    config.quality = quality;
+    const data_url = await file_to_data_url(file);
+    const original_mime = data_url.split(",")[0].match(/:(.*?);/)?.[1];
+    let mime = EImageType.JPEG;
+    if (check_image_type(config.type)) {
+      mime = config.type;
+    }
+    const image = await data_url_to_image(data_url);
+    const canvas = await image_to_canvas(image, config);
+    const compress_data_url = await canvas_to_data_url(canvas, config.quality, mime);
+    const compress_file = await data_url_to_file(compress_data_url, original_mime || mime);
+    if (compress_file.size > file.size) {
+      return file;
+    }
+    return compress_file;
+  }
+  async function compress_accurately(file, config = {}) {
+    if (!(file instanceof Blob)) {
+      throw new Error("compressAccurately(): 第一个参数必须是Blob对象或File对象");
+    }
+    const size = Math.max(0, isNaN(Number(config.size)) ? 0 : Number(config.size));
+    config.size = size;
+    const accuracy = Math.max(0.8, Math.min(0.99, isNaN(Number(config.accuracy)) ? 0.95 : Number(config.accuracy)));
+    config.accuracy = accuracy;
+    if (isNaN(config.size)) {
+      return file;
+    }
+    if (config.size * 1024 > file.size) {
+      return file;
+    }
+    if (!config.accuracy || config.accuracy < 0.8 || config.accuracy > 0.99) {
+      config.accuracy = 0.95;
+    }
+    const result_size = {
+      max: config.size * (2 - config.accuracy) * 1024,
+      accurate: config.size * 1024,
+      min: config.size * config.accuracy * 1024
+    };
+    const data_url = await file_to_data_url(file);
+    const original_mime = data_url.split(",")[0].match(/:(.*?);/)?.[1];
+    let mime = EImageType.JPEG;
+    if (check_image_type(config.type)) {
+      mime = config.type;
+    }
+    const image = await data_url_to_image(data_url);
+    const canvas = await image_to_canvas(image, config);
+    const proportion = 0.75;
+    let image_quality = 1;
+    let compress_data_url = "";
+    const temp_data_urls = [];
+    for (let x = 1; x <= 7; x++) {
+      compress_data_url = await canvas_to_data_url(canvas, image_quality, mime);
+      const calculation_size = compress_data_url.length * proportion;
+      if (x === 7) {
+        if (result_size.max < calculation_size || result_size.min > calculation_size) {
+          compress_data_url = [compress_data_url, ...temp_data_urls].filter(Boolean).sort(
+            (a, b) => Math.abs(a.length * proportion - result_size.accurate) - Math.abs(b.length * proportion - result_size.accurate)
+          )[0];
+        }
+        break;
+      }
+      if (result_size.max < calculation_size) {
+        temp_data_urls[1] = compress_data_url;
+        image_quality -= 0.5 ** (x + 1);
+      } else if (result_size.min > calculation_size) {
+        temp_data_urls[0] = compress_data_url;
+        image_quality += 0.5 ** (x + 1);
+      } else {
+        break;
+      }
+    }
+    const compress_file = await data_url_to_file(
+      compress_data_url,
+      original_mime || mime
+    );
+    if (compress_file.size > file.size) {
+      return file;
+    }
+    return compress_file;
+  }
+  async function compress_image$1(file, max_width = 800, max_height = 800, quality = 0.8) {
+    return compress_image(file, max_width, max_height, quality);
+  }
+  return {
+    // 压缩功能
+    compress,
+    compress_accurately,
+    compress_image: compress_image$1,
+    // 转换功能
+    canvas_to_data_url,
+    canvas_to_file,
+    data_url_to_file,
+    data_url_to_image,
+    file_to_data_url,
+    image_to_canvas,
+    url_to_blob,
+    url_to_image,
+    // 工具功能
+    download_file: download_file$1
+  };
+}
+function use_fullscreen(selector) {
+  const full = ref(false);
+  const container = shallowRef(null);
+  function fullscreen_change() {
+    full.value = document.fullscreenElement === container.value;
+  }
+  onMounted(() => {
+    container.value = get_element(selector);
+    if (container.value) {
+      on(container.value, "fullscreenchange", fullscreen_change);
+    }
+  });
+  onUnmounted(() => {
+    if (container.value) {
+      off(container.value, "fullscreenchange", fullscreen_change);
+    }
+  });
+  function enter_fullscreen() {
+    if (!full.value && container.value?.requestFullscreen) {
+      container.value.requestFullscreen().catch((error) => {
+        console.error("进入全屏失败:", error);
+      });
+    }
+  }
+  function exit_fullscreen() {
+    if (document.exitFullscreen) {
+      document.exitFullscreen().catch((error) => {
+        console.error("退出全屏失败:", error);
+      });
+    }
+  }
+  function toggle_fullscreen() {
+    if (full.value) {
+      exit_fullscreen();
+    } else {
+      enter_fullscreen();
+    }
+  }
+  return {
+    container,
+    full,
+    toggle_fullscreen,
+    enter_fullscreen,
+    exit_fullscreen
+  };
+}
+export {
+  EImageType,
+  use_emit,
+  use_fullscreen,
+  use_image,
+  use_print,
+  use_water_mark,
+  use_web_socket
+};