@cgboiler/biz-basic 1.0.53 → 1.0.55

package/lib/rich-text-editor/menu-system/hooks/use-color-highlight.js

@@ -0,0 +1,185 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  COLOR_HIGHLIGHT_SHORTCUT_KEY: () => COLOR_HIGHLIGHT_SHORTCUT_KEY,
+  HIGHLIGHT_COLORS: () => HIGHLIGHT_COLORS,
+  canColorHighlight: () => canColorHighlight,
+  isColorHighlightActive: () => isColorHighlightActive,
+  removeHighlight: () => removeHighlight,
+  shouldShowButton: () => shouldShowButton,
+  useColorHighlight: () => useColorHighlight
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_tiptap_utils = require("../utils/tiptap-utils");
+var import_icons = require("../icons");
+const COLOR_HIGHLIGHT_SHORTCUT_KEY = "mod+shift+h";
+const HIGHLIGHT_COLORS = [
+  {
+    label: "Default background",
+    value: "var(--tt-bg-color)",
+    border: "var(--tt-bg-color-contrast)"
+  },
+  {
+    label: "Gray background",
+    value: "var(--tt-color-highlight-gray)",
+    border: "var(--tt-color-highlight-gray-contrast)"
+  },
+  {
+    label: "Brown background",
+    value: "var(--tt-color-highlight-brown)",
+    border: "var(--tt-color-highlight-brown-contrast)"
+  },
+  {
+    label: "Orange background",
+    value: "var(--tt-color-highlight-orange)",
+    border: "var(--tt-color-highlight-orange-contrast)"
+  },
+  {
+    label: "Yellow background",
+    value: "var(--tt-color-highlight-yellow)",
+    border: "var(--tt-color-highlight-yellow-contrast)"
+  },
+  {
+    label: "Green background",
+    value: "var(--tt-color-highlight-green)",
+    border: "var(--tt-color-highlight-green-contrast)"
+  },
+  {
+    label: "Blue background",
+    value: "var(--tt-color-highlight-blue)",
+    border: "var(--tt-color-highlight-blue-contrast)"
+  },
+  {
+    label: "Purple background",
+    value: "var(--tt-color-highlight-purple)",
+    border: "var(--tt-color-highlight-purple-contrast)"
+  },
+  {
+    label: "Pink background",
+    value: "var(--tt-color-highlight-pink)",
+    border: "var(--tt-color-highlight-pink-contrast)"
+  },
+  {
+    label: "Red background",
+    value: "var(--tt-color-highlight-red)",
+    border: "var(--tt-color-highlight-red-contrast)"
+  }
+];
+function canColorHighlight(editor) {
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!(0, import_tiptap_utils.isMarkInSchema)("highlight", editor) || (0, import_tiptap_utils.isNodeTypeSelected)(editor, ["image"]))
+    return false;
+  return editor.can().setMark("highlight");
+}
+function isColorHighlightActive(editor, highlightColor) {
+  if (!editor || !editor.isEditable)
+    return false;
+  return highlightColor ? editor.isActive("highlight", { color: highlightColor }) : editor.isActive("highlight");
+}
+function removeHighlight(editor) {
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!canColorHighlight(editor))
+    return false;
+  return editor.chain().focus().unsetMark("highlight").run();
+}
+function shouldShowButton(props) {
+  const { editor, hideWhenUnavailable } = props;
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!(0, import_tiptap_utils.isMarkInSchema)("highlight", editor))
+    return false;
+  if (hideWhenUnavailable && !editor.isActive("code")) {
+    return canColorHighlight(editor);
+  }
+  return true;
+}
+function useColorHighlight(config) {
+  const { label, highlightColor, hideWhenUnavailable = false, onApplied } = config;
+  const isVisible = (0, import_vue.ref)(true);
+  const isActive = (0, import_vue.ref)(false);
+  const canHighlight = (0, import_vue.ref)(false);
+  const getEditor = () => {
+    const editor = config.editor;
+    return editor && "value" in editor ? editor.value : editor;
+  };
+  const updateState = () => {
+    const editor = getEditor();
+    if (!editor || !editor.isEditable) {
+      isVisible.value = false;
+      isActive.value = false;
+      canHighlight.value = false;
+      return;
+    }
+    isActive.value = isColorHighlightActive(editor, highlightColor);
+    canHighlight.value = canColorHighlight(editor);
+    isVisible.value = shouldShowButton({ editor, hideWhenUnavailable });
+  };
+  (0, import_vue.watch)(
+    () => getEditor(),
+    (editor) => {
+      if (!editor)
+        return;
+      updateState();
+      editor.on("selectionUpdate", updateState);
+      editor.on("transaction", updateState);
+      (0, import_vue.onBeforeUnmount)(() => {
+        editor.off("selectionUpdate", updateState);
+        editor.off("transaction", updateState);
+      });
+    },
+    { immediate: true }
+  );
+  const handleColorHighlight = () => {
+    const editor = getEditor();
+    if (!editor || !canHighlight.value || !highlightColor || !label)
+      return;
+    if (editor.state.storedMarks) {
+      const highlightMarkType = editor.schema.marks.highlight;
+      if (highlightMarkType) {
+        editor.view.dispatch(editor.state.tr.removeStoredMark(highlightMarkType));
+      }
+    }
+    setTimeout(() => {
+      const success = editor.chain().focus().toggleMark("highlight", { color: highlightColor }).run();
+      if (success) {
+        onApplied == null ? void 0 : onApplied({ color: highlightColor, label });
+      }
+    }, 0);
+  };
+  const handleRemoveHighlight = () => {
+    const editor = getEditor();
+    const success = removeHighlight(editor);
+    if (success) {
+      onApplied == null ? void 0 : onApplied({ color: "", label: "Remove highlight" });
+    }
+  };
+  return {
+    isVisible,
+    isActive,
+    handleColorHighlight,
+    handleRemoveHighlight,
+    canHighlight,
+    label: label || "Highlight",
+    shortcutKeys: COLOR_HIGHLIGHT_SHORTCUT_KEY,
+    Icon: import_icons.HighlighterIcon
+  };
+}

package/lib/rich-text-editor/menu-system/hooks/use-cursor-visibility.d.ts

@@ -0,0 +1,7 @@
+import { type Ref } from 'vue';
+import type { Editor } from '@tiptap/vue-3';
+export interface CursorVisibilityOptions {
+    editor?: Editor | null | Ref<Editor | null | undefined>;
+    overlayHeight?: number | Ref<number>;
+}
+export declare function useCursorVisibility(options: CursorVisibilityOptions): Ref<import("./use-element-rect").RectState, import("./use-element-rect").RectState>;

package/lib/rich-text-editor/menu-system/hooks/use-cursor-visibility.js

@@ -0,0 +1,65 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  useCursorVisibility: () => useCursorVisibility
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_use_window_size = require("./use-window-size");
+var import_use_element_rect = require("./use-element-rect");
+function useCursorVisibility(options) {
+  const windowSize = (0, import_use_window_size.useWindowSizeStore)();
+  const rect = (0, import_use_element_rect.useBodyRect)({
+    enabled: true,
+    throttleMs: 100,
+    useResizeObserver: true
+  });
+  const ensureCursorVisibility = () => {
+    const editor = typeof options.editor === "function" ? options.editor() : options.editor && "value" in options.editor ? options.editor.value : options.editor;
+    const overlayHeight = options.overlayHeight && "value" in options.overlayHeight ? options.overlayHeight.value : options.overlayHeight || 0;
+    if (!editor)
+      return;
+    const { state, view } = editor;
+    if (!view.hasFocus())
+      return;
+    const { from } = state.selection;
+    const cursorCoords = view.coordsAtPos(from);
+    if (windowSize.value.height < rect.value.height && cursorCoords) {
+      const availableSpace = windowSize.value.height - cursorCoords.top;
+      if (availableSpace < overlayHeight) {
+        const targetCursorY = Math.max(windowSize.value.height / 2, overlayHeight);
+        const currentScrollY = window.scrollY;
+        const cursorAbsoluteY = cursorCoords.top + currentScrollY;
+        const newScrollY = cursorAbsoluteY - targetCursorY;
+        window.scrollTo({
+          top: Math.max(0, newScrollY),
+          behavior: "smooth"
+        });
+      }
+    }
+  };
+  (0, import_vue.watch)(
+    [windowSize, rect, () => options.overlayHeight, () => options.editor],
+    () => {
+      ensureCursorVisibility();
+    },
+    { deep: true }
+  );
+  return rect;
+}

package/lib/rich-text-editor/menu-system/hooks/use-element-rect.d.ts

@@ -0,0 +1,10 @@
+import { type Ref } from 'vue';
+export type RectState = Omit<DOMRect, 'toJSON'>;
+export interface ElementRectOptions {
+    element?: Element | Ref<Element | null> | string | null;
+    enabled?: boolean;
+    throttleMs?: number;
+    useResizeObserver?: boolean;
+}
+export declare function useElementRect(options?: ElementRectOptions): Ref<RectState>;
+export declare function useBodyRect(options?: Omit<ElementRectOptions, 'element'>): Ref<RectState>;

package/lib/rich-text-editor/menu-system/hooks/use-element-rect.js

@@ -0,0 +1,149 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  useBodyRect: () => useBodyRect,
+  useElementRect: () => useElementRect
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_use_throttled_callback = require("./use-throttled-callback");
+const initialRect = {
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0
+};
+const isSSR = typeof window === "undefined";
+const hasResizeObserver = !isSSR && typeof ResizeObserver !== "undefined";
+function useElementRect(options = {}) {
+  const { element, enabled = true, throttleMs = 100, useResizeObserver = true } = options;
+  const rect = (0, import_vue.ref)(initialRect);
+  const getTargetElement = () => {
+    if (!enabled || isSSR)
+      return null;
+    if (!element) {
+      return document.body;
+    }
+    if (typeof element === "string") {
+      return document.querySelector(element);
+    }
+    if (element && "value" in element) {
+      return element.value;
+    }
+    return element;
+  };
+  const updateRect = (0, import_use_throttled_callback.useThrottledCallback)(
+    () => {
+      if (!enabled || isSSR)
+        return;
+      const targetElement = getTargetElement();
+      if (!targetElement) {
+        rect.value = initialRect;
+        return;
+      }
+      const newRect = targetElement.getBoundingClientRect();
+      rect.value = {
+        x: newRect.x,
+        y: newRect.y,
+        width: newRect.width,
+        height: newRect.height,
+        top: newRect.top,
+        right: newRect.right,
+        bottom: newRect.bottom,
+        left: newRect.left
+      };
+    },
+    throttleMs,
+    { leading: true, trailing: true }
+  );
+  let resizeObserver = null;
+  const cleanup = () => {
+    if (resizeObserver) {
+      resizeObserver.disconnect();
+      resizeObserver = null;
+    }
+    window.removeEventListener("scroll", updateRect);
+    window.removeEventListener("resize", updateRect);
+  };
+  (0, import_vue.onMounted)(() => {
+    if (!enabled || isSSR)
+      return;
+    const targetElement = getTargetElement();
+    if (!targetElement)
+      return;
+    updateRect();
+    if (useResizeObserver && hasResizeObserver) {
+      resizeObserver = new ResizeObserver(() => {
+        window.requestAnimationFrame(updateRect);
+      });
+      resizeObserver.observe(targetElement);
+    }
+    window.addEventListener("scroll", updateRect, { passive: true });
+    window.addEventListener("resize", updateRect, { passive: true });
+  });
+  (0, import_vue.onBeforeUnmount)(() => {
+    cleanup();
+  });
+  if (element && "value" in element) {
+    (0, import_vue.watch)(
+      () => element.value,
+      (newVal) => {
+        cleanup();
+        if (newVal && enabled && !isSSR) {
+          updateRect();
+          if (useResizeObserver && hasResizeObserver) {
+            resizeObserver = new ResizeObserver(() => {
+              window.requestAnimationFrame(updateRect);
+            });
+            resizeObserver.observe(newVal);
+          }
+          window.addEventListener("scroll", updateRect, { passive: true });
+          window.addEventListener("resize", updateRect, { passive: true });
+        }
+      }
+    );
+  }
+  return rect;
+}
+function useBodyRect(options = {}) {
+  return useElementRect(__spreadProps(__spreadValues({}, options), {
+    element: isSSR ? null : document.body
+  }));
+}

package/lib/rich-text-editor/menu-system/hooks/use-file-upload.d.ts

@@ -0,0 +1,94 @@
+export interface FileItem {
+    id: string;
+    file: File;
+    progress: number;
+    status: 'uploading' | 'success' | 'error';
+    url?: string;
+    abortController?: AbortController;
+}
+export interface UploadOptions {
+    maxSize: number;
+    limit: number;
+    accept: string;
+    upload: (file: File, onProgress: (event: {
+        progress: number;
+    }) => void, signal: AbortSignal) => Promise<string>;
+    onSuccess?: (url: string) => void;
+    onError?: (error: Error) => void;
+}
+export declare function useFileUpload(options: UploadOptions): {
+    fileItems: import("vue").Ref<{
+        id: string;
+        file: {
+            readonly lastModified: number;
+            readonly name: string;
+            readonly webkitRelativePath: string;
+            readonly size: number;
+            readonly type: string;
+            arrayBuffer: () => Promise<ArrayBuffer>;
+            bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+            slice: (start?: number, end?: number, contentType?: string) => Blob;
+            stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+            text: () => Promise<string>;
+        };
+        progress: number;
+        status: "uploading" | "success" | "error";
+        url?: string | undefined;
+        abortController?: {
+            readonly signal: {
+                readonly aborted: boolean;
+                onabort: ((this: AbortSignal, ev: Event) => any) | null;
+                readonly reason: any;
+                throwIfAborted: () => void;
+                addEventListener: {
+                    <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            };
+            abort: (reason?: any) => void;
+        } | undefined;
+    }[], FileItem[] | {
+        id: string;
+        file: {
+            readonly lastModified: number;
+            readonly name: string;
+            readonly webkitRelativePath: string;
+            readonly size: number;
+            readonly type: string;
+            arrayBuffer: () => Promise<ArrayBuffer>;
+            bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+            slice: (start?: number, end?: number, contentType?: string) => Blob;
+            stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+            text: () => Promise<string>;
+        };
+        progress: number;
+        status: "uploading" | "success" | "error";
+        url?: string | undefined;
+        abortController?: {
+            readonly signal: {
+                readonly aborted: boolean;
+                onabort: ((this: AbortSignal, ev: Event) => any) | null;
+                readonly reason: any;
+                throwIfAborted: () => void;
+                addEventListener: {
+                    <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                };
+                removeEventListener: {
+                    <K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                };
+                dispatchEvent: (event: Event) => boolean;
+            };
+            abort: (reason?: any) => void;
+        } | undefined;
+    }[]>;
+    uploadFiles: (files: File[]) => Promise<string[]>;
+    removeFileItem: (fileId: string) => void;
+    clearAllFiles: () => void;
+};

package/lib/rich-text-editor/menu-system/hooks/use-file-upload.js

@@ -0,0 +1,154 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var stdin_exports = {};
+__export(stdin_exports, {
+  useFileUpload: () => useFileUpload
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+function useFileUpload(options) {
+  const fileItems = (0, import_vue.ref)([]);
+  const uploadFile = (file) => __async(this, null, function* () {
+    var _a, _b, _c;
+    if (file.size > options.maxSize) {
+      const error = new Error(
+        `File size exceeds maximum allowed (${options.maxSize / 1024 / 1024}MB)`
+      );
+      (_a = options.onError) == null ? void 0 : _a.call(options, error);
+      return null;
+    }
+    const abortController = new AbortController();
+    const fileId = crypto.randomUUID();
+    const newFileItem = {
+      id: fileId,
+      file,
+      progress: 0,
+      status: "uploading",
+      abortController
+    };
+    fileItems.value.push(newFileItem);
+    try {
+      if (!options.upload) {
+        throw new Error("Upload function is not defined");
+      }
+      const url = yield options.upload(
+        file,
+        (event) => {
+          const item = fileItems.value.find((i) => i.id === fileId);
+          if (item) {
+            item.progress = event.progress;
+          }
+        },
+        abortController.signal
+      );
+      if (!url)
+        throw new Error("Upload failed: No URL returned");
+      if (!abortController.signal.aborted) {
+        const item = fileItems.value.find((i) => i.id === fileId);
+        if (item) {
+          item.status = "success";
+          item.url = url;
+          item.progress = 100;
+        }
+        (_b = options.onSuccess) == null ? void 0 : _b.call(options, url);
+        return url;
+      }
+      return null;
+    } catch (error) {
+      if (!abortController.signal.aborted) {
+        const item = fileItems.value.find((i) => i.id === fileId);
+        if (item) {
+          item.status = "error";
+          item.progress = 0;
+        }
+        (_c = options.onError) == null ? void 0 : _c.call(options, error instanceof Error ? error : new Error("Upload failed"));
+      }
+      return null;
+    }
+  });
+  const uploadFiles = (files) => __async(this, null, function* () {
+    var _a, _b;
+    if (!files || files.length === 0) {
+      (_a = options.onError) == null ? void 0 : _a.call(options, new Error("No files to upload"));
+      return [];
+    }
+    if (options.limit && files.length > options.limit) {
+      (_b = options.onError) == null ? void 0 : _b.call(
+        options,
+        new Error(`Maximum ${options.limit} file${options.limit === 1 ? "" : "s"} allowed`)
+      );
+      return [];
+    }
+    const uploadPromises = files.map((file) => uploadFile(file));
+    const results = yield Promise.all(uploadPromises);
+    return results.filter((url) => url !== null);
+  });
+  const removeFileItem = (fileId) => {
+    const index = fileItems.value.findIndex((item) => item.id === fileId);
+    if (index !== -1) {
+      const item = fileItems.value[index];
+      if (item.abortController) {
+        item.abortController.abort();
+      }
+      if (item.url) {
+        URL.revokeObjectURL(item.url);
+      }
+      fileItems.value.splice(index, 1);
+    }
+  };
+  const clearAllFiles = () => {
+    fileItems.value.forEach((item) => {
+      if (item.abortController) {
+        item.abortController.abort();
+      }
+      if (item.url) {
+        URL.revokeObjectURL(item.url);
+      }
+    });
+    fileItems.value = [];
+  };
+  (0, import_vue.onBeforeUnmount)(() => {
+    clearAllFiles();
+  });
+  return {
+    fileItems,
+    uploadFiles,
+    removeFileItem,
+    clearAllFiles
+  };
+}