@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/foundation/clipboard/ClipboardResult.d.ts

@@ -1,28 +1,9 @@
-/**
- * The ways a clipboard operation ends without producing a payload. Shared by {@link ClipboardWriteResult} and
- * both read results, so one `switch` renders every error path in the slice.
- *
- * - `denied` — the platform refused: permission not granted, the paste prompt dismissed, or no user gesture
- *   behind the call.
- * - `unsupported` — no Clipboard API here: SSR, a non-secure context, or an engine without the method. A
- *   capability fact, not a failure — nothing went wrong, the road is simply not there.
- * - `failed` — anything else, carrying the normalized `Error`.
- */
-export type ClipboardFailure = {
-    readonly status: 'denied';
-    readonly error: Error;
-} | {
-    readonly status: 'unsupported';
-} | {
-    readonly status: 'failed';
-    readonly error: Error;
-};
-/** The outcome of a clipboard write — `copied` on success, otherwise a {@link ClipboardFailure}. */
-export type ClipboardWriteResult = {
-    readonly status: 'copied';
-} | ClipboardFailure;
+import { ClipboardFailure } from './models/ClipboardFailure';
+import { Result } from '../results';
+export type { ClipboardFailure } from './models/ClipboardFailure';
+export type { ClipboardWriteResult } from './models/ClipboardWriteResult';
 /** The `status` discriminant of a {@link ClipboardWriteResult} — for a consumer's own switch or status→copy map. */
-export type ClipboardWriteStatus = ClipboardWriteResult['status'];
+export type ClipboardWriteStatus = 'copied' | ClipboardFailure['status'];
 /** One MIME-typed payload read off the system clipboard. */
 export interface ClipboardReadItem {
     /** The MIME type the platform reported — `text/plain`, `text/html`, `image/png`, … */
@@ -30,21 +11,10 @@ export interface ClipboardReadItem {
     /** The payload itself. Read it with `blob.text()` for textual types, or hand it to `URL.createObjectURL`. */
     readonly blob: Blob;
 }
-/**
- * The outcome of a clipboard text read. `read` carries the text — an empty clipboard reads as `''`, which is a
- * successful read of nothing rather than a failure.
- */
-export type ClipboardReadTextResult = {
-    readonly status: 'read';
-    readonly text: string;
-} | ClipboardFailure;
-/** The outcome of a multi-format clipboard read. `read` carries one entry per MIME type the platform offered. */
-export type ClipboardReadItemsResult = {
-    readonly status: 'read';
-    readonly items: readonly ClipboardReadItem[];
-} | ClipboardFailure;
+export type { ClipboardReadTextResult } from './models/ClipboardReadTextResult';
+export type { ClipboardReadItemsResult } from './models/ClipboardReadItemsResult';
 /** The `status` discriminant shared by both read results. */
-export type ClipboardReadStatus = ClipboardReadTextResult['status'];
+export type ClipboardReadStatus = 'read' | ClipboardFailure['status'];
 /** Tunes a clipboard read. */
 export interface ClipboardReadOptions {
     /**
@@ -67,10 +37,7 @@ export interface ClipboardCopyOptions extends ClipboardReadOptions {
     readonly legacyFallback?: boolean;
 }
 /** The shape every result family shares, so one reporter can serve every entry point. */
-type ClipboardOutcome = {
-    readonly status: string;
-    readonly error?: Error;
-};
+type ClipboardOutcome = Result<unknown, ClipboardFailure>;
 /**
  * Checks whether a caught value is the platform refusing rather than breaking — the split behind `denied`.
  * Exported for the sibling modules; absent from the barrel, where the statuses are the answer callers want.
@@ -99,4 +66,3 @@ export declare function toClipboardFailure(error: unknown): ClipboardFailure;
  * @returns `result`, unchanged — so a call site can `return reportClipboardOutcome(...)`.
  */
 export declare function reportClipboardOutcome<TResult extends ClipboardOutcome>(result: TResult, onError: ((error: Error) => void) | undefined): TResult;
-export {};

package/dist/foundation/clipboard/ClipboardSupport.d.ts

@@ -6,7 +6,18 @@ export type ClipboardItemConstructor = new (items: Record<string, Blob>) => Clip
  */
 export declare function clipboardApi(): Clipboard | undefined;
 /** The Clipboard API methods this slice calls. */
-export type ClipboardMethodName = 'writeText' | 'write' | 'readText' | 'read';
+export declare const ClipboardMethodName: {
+    /** Names `clipboard.writeText` — the plain-text write, implemented in every engine with a clipboard. */
+    readonly WriteText: "writeText";
+    /** Names `clipboard.write` — the `ClipboardItem` write, for images and multi-flavour payloads. */
+    readonly Write: "write";
+    /** Names `clipboard.readText` — the plain-text read. */
+    readonly ReadText: "readText";
+    /** Names `clipboard.read` — the `ClipboardItem` read. */
+    readonly Read: "read";
+};
+/** The Clipboard API methods this slice calls. */
+export type ClipboardMethodName = (typeof ClipboardMethodName)[keyof typeof ClipboardMethodName];
 /**
  * Resolves one of the Clipboard API's methods, bound to the clipboard object, or `undefined` when this engine
  * does not implement it. The single gate every operation passes through. Exported for the sibling modules;
@@ -39,8 +50,8 @@ export declare function canCopyItems(): boolean;
 /**
  * Whether reading from the clipboard is available — `navigator.clipboard.readText`.
  *
- * `false` in Firefox, which does not expose reading to page script at all, and under SSR. Even where it is
- * `true`, the read needs a user gesture and shows an explicit paste prompt. If all you need is the payload the
+ * Returns `false` when the method is absent, including under SSR. Even where present,
+ * reading remains subject to browser permission and user-activation requirements. If all you need is the payload the
  * user just pasted, do not read at all — handle the `paste` event with `getPasteItems`, which needs no
  * permission and no prompt.
  */

package/dist/foundation/clipboard/PasteItems.d.ts

@@ -2,10 +2,10 @@
 export interface PasteItems {
     /** The `text/plain` representation, or `undefined` when the paste carried none (a bare image paste). */
     readonly text: string | undefined;
-    /** The `text/html` representation, or `undefined`. Present when copying from a rich source — sanitize before rendering. */
+    /** The `text/html` representation, or `undefined`. Present from a rich source — sanitize before rendering. */
     readonly html: string | undefined;
     /** Files on the paste — a screenshot, an image, a document. Empty when the paste was text only. */
-    readonly files: readonly File[];
+    readonly files: ReadonlyArray<File>;
 }
 /**
  * Extracts the text, HTML, and files a `paste` event carried.

package/dist/foundation/clipboard/ReadClipboard.d.ts

@@ -3,8 +3,7 @@ import { ClipboardReadItemsResult, ClipboardReadOptions, ClipboardReadTextResult
  * Reads the clipboard's plain text.
  *
  * Requires a user gesture and, in Chromium, an explicit permission prompt the user can dismiss — a dismissal is
- * `denied`. Resolves to `unsupported` under SSR and in Firefox, which withholds clipboard reading from page
- * script entirely.
+ * `denied`. Resolves to `unsupported` when the runtime lacks the method, including under SSR.
  *
  * Prefer `getPasteItems` on a `paste` event wherever the flow is "the user pastes something": that path needs no
  * permission and works everywhere.

package/dist/foundation/clipboard/hooks/UseClipboard.d.ts

@@ -0,0 +1,25 @@
+import { MaybeRefOrGetter, ShallowRef } from 'vue';
+import { ClipboardWriteResult } from '../ClipboardResult';
+export interface UseClipboardOptions {
+    /** Reset `copied` back to false after this many ms. Default 2000. Set 0 to keep state until explicitly reset. */
+    resetAfter?: MaybeRefOrGetter<number>;
+}
+export interface ClipboardControls {
+    /** True for `resetAfter` ms after a successful copy. */
+    copied: Readonly<ShallowRef<boolean>>;
+    /** Last error from `navigator.clipboard.writeText`, if any. */
+    error: Readonly<ShallowRef<Error | null>>;
+    /** Writes text and returns the completed success or failure to the caller. */
+    copy: (text: string) => Promise<ClipboardWriteResult>;
+    /** Force-clear the `copied` flag. */
+    reset: () => void;
+}
+/**
+ * Wraps `navigator.clipboard.writeText` with a transient `copied` flag for
+ * post-action UI (icon swap, "Copied!" tooltip). Pass `resetAfter: 0` to
+ * keep `copied` true until you call `reset()`.
+ *
+ * `resetAfter` may be a ref or getter; it is read at copy time, so a window
+ * changed between copies takes effect on the next one.
+ */
+export declare function useClipboard({ resetAfter }?: UseClipboardOptions): ClipboardControls;

package/dist/foundation/clipboard/hooks/UseClipboardCopy.d.ts

@@ -0,0 +1,40 @@
+import { MaybeRefOrGetter, ShallowRef } from 'vue';
+import { ClipboardCopyOptions, ClipboardWriteResult, ClipboardWriteStatus } from '../ClipboardResult';
+/** Where a {@link useClipboardCopy} instance sits: `idle` before the first attempt, otherwise the last outcome. */
+export type ClipboardCopyState = 'idle' | ClipboardWriteStatus;
+/** Tunes a {@link useClipboardCopy} instance. */
+export interface UseClipboardCopyOptions extends ClipboardCopyOptions {
+    /**
+     * How long `status` holds the last outcome before returning to `idle`, in milliseconds. Defaults to 2000 —
+     * long enough to read "Copied!", short enough not to linger.
+     *
+     * Pass `0` to hold the status until {@link ClipboardCopyControls.reset} is called, which is what a failure
+     * message the user must acknowledge wants.
+     */
+    readonly resetAfterMs?: number;
+}
+/** What {@link useClipboardCopy} returns. */
+export interface ClipboardCopyControls {
+    /**
+     * The last outcome, or `idle` before the first attempt and after the reset window. Drives the icon swap, the
+     * "Copied!" label, and the `denied` / `unsupported` fallback copy.
+     */
+    readonly status: Readonly<ShallowRef<ClipboardCopyState>>;
+    /**
+     * Writes `text` to the clipboard and resolves to the full result — the awaiting caller branches on the
+     * outcome, while `status` drives the render. Never throws, never rejects.
+     */
+    readonly copy: (text: string) => Promise<ClipboardWriteResult>;
+    /** Returns `status` to `idle` immediately and cancels the pending auto-reset. */
+    readonly reset: () => void;
+}
+/**
+ * Wraps `copyText` in a transient status for post-action UI, without swallowing the outcome.
+ *
+ * Call `copy` from a user gesture — the platform requires transient activation, and a copy fired from a watcher
+ * or a timeout comes back `denied`.
+ *
+ * @param options Error reporting, the legacy-fallback opt-in, and the auto-reset window. Read fresh on every
+ *   call, so a ref or getter keeps them live.
+ */
+export declare function useClipboardCopy(options?: MaybeRefOrGetter<UseClipboardCopyOptions | undefined>): ClipboardCopyControls;

package/dist/foundation/clipboard/hooks/UsePasteHandler.d.ts

@@ -0,0 +1,35 @@
+import { MaybeRefOrGetter } from 'vue';
+import { PasteItems } from '../PasteItems';
+/** Tunes a {@link usePasteHandler} binding. */
+export interface UsePasteHandlerOptions {
+    /**
+     * The element to listen on. Defaults to `window`, which catches a paste anywhere on the page — the right
+     * default for a drop-zone or an editor surface that is not itself focused. Pass a ref or getter to scope the
+     * listener to one element.
+     */
+    readonly target?: MaybeRefOrGetter<HTMLElement | null | undefined>;
+    /**
+     * Whether the listener is attached. Defaults to `true`; pass `false` to suspend it without tearing down — a
+     * modal that should own pastes only while open.
+     */
+    readonly enabled?: MaybeRefOrGetter<boolean | undefined>;
+    /**
+     * Whether to call `preventDefault()` on the event, suppressing the browser's own paste. Defaults to `false`.
+     *
+     * Turn it on when the handler fully owns the paste (inserting the image itself); leave it off when the handler
+     * is a side effect and the default insert should still happen. Applied BEFORE the handler runs, so a throw
+     * from the handler cannot skip it.
+     */
+    readonly preventDefault?: MaybeRefOrGetter<boolean | undefined>;
+}
+/**
+ * Binds a `paste` listener that hands the handler the event's already-extracted text, HTML, and files.
+ *
+ * Needs no clipboard permission — see `PasteItems.ts` for why this is the path to prefer over `readText`.
+ * Detaches on scope disposal, and on any change to `enabled` / `target` / `preventDefault`.
+ *
+ * @param handler Called on every paste with the extracted payload and the original event. A throw from it is
+ *   swallowed.
+ * @param options Where to listen, whether to listen, and whether to suppress the default paste.
+ */
+export declare function usePasteHandler(handler: (items: PasteItems, event: ClipboardEvent) => void, options?: UsePasteHandlerOptions): void;

package/dist/foundation/clipboard/index.d.ts

@@ -1,10 +1,12 @@
 export { type ClipboardFailure, type ClipboardWriteResult, type ClipboardWriteStatus, type ClipboardReadItem, type ClipboardReadTextResult, type ClipboardReadItemsResult, type ClipboardReadStatus, type ClipboardReadOptions, type ClipboardCopyOptions, } from './ClipboardResult';
-export { canCopy, canCopyItems, canReadClipboard, canLegacyCopy, } from './ClipboardSupport';
+export { canCopy, canCopyItems, canReadClipboard, canLegacyCopy } from './ClipboardSupport';
 export { copyText } from './CopyText';
 export { copyItems, copyBlob, type ClipboardWriteItems } from './CopyItems';
 export { legacyCopyText } from './LegacyCopy';
 export { readText, readItems } from './ReadClipboard';
 export { getPasteItems, type PasteItems } from './PasteItems';
-export { usePasteHandler, type UsePasteHandlerOptions } from './UsePasteHandler';
-export { useClipboardCopy, type ClipboardCopyControls, type ClipboardCopyState, type UseClipboardCopyOptions, } from './UseClipboardCopy';
+export { usePasteHandler, type UsePasteHandlerOptions } from './hooks/UsePasteHandler';
+export { useClipboardCopy, type ClipboardCopyControls, type ClipboardCopyState, type UseClipboardCopyOptions, } from './hooks/UseClipboardCopy';
 export { getClipboardPermission, type ClipboardPermissionMode } from './ClipboardPermission';
+export * from './hooks/UseClipboard';
+export { ClipboardFailureCode } from './ClipboardFailureCode';

package/dist/foundation/clipboard/index.js

@@ -1,165 +1,7 @@
-import { t as toError } from "../../chunks/ToError-CyTBsmLO.js";
+import { r as reportClipboardOutcome, t as toClipboardFailure, w as withLegacyFallback, c as clipboardMethod, a as clipboardItemConstructor, b as copyText } from "../../chunks/UseClipboard-x6nEdQ9f.js";
+import { d, e, f, g, l, u } from "../../chunks/UseClipboard-x6nEdQ9f.js";
 import { watchPostEffect, toValue, shallowRef, onScopeDispose } from "vue";
-import { q as queryPermission } from "../../chunks/QueryPermission--OKfvS9c.js";
-function nameOf(value) {
-  try {
-    if (typeof value !== "object" || value === null) return void 0;
-    const name = value.name;
-    return typeof name === "string" ? name : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function isPermissionRefusal(value) {
-  const name = nameOf(value);
-  return name === "NotAllowedError" || name === "SecurityError";
-}
-function toClipboardFailure(error) {
-  const failure = toError(error);
-  return isPermissionRefusal(error) ? { status: "denied", error: failure } : { status: "failed", error: failure };
-}
-function reportClipboardOutcome(result, onError) {
-  if (onError === void 0) return result;
-  if (result.error === void 0) return result;
-  try {
-    onError(result.error);
-  } catch {
-  }
-  return result;
-}
-function member$1(source, key) {
-  try {
-    return source[key];
-  } catch {
-    return void 0;
-  }
-}
-function clipboardApi() {
-  try {
-    if (typeof navigator === "undefined") return void 0;
-    const clipboard = member$1(navigator, "clipboard");
-    if (typeof clipboard !== "object" || clipboard === null) return void 0;
-    return clipboard;
-  } catch {
-    return void 0;
-  }
-}
-function clipboardMethod(name) {
-  const clipboard = clipboardApi();
-  if (clipboard === void 0) return void 0;
-  const method = member$1(clipboard, name);
-  if (typeof method !== "function") return void 0;
-  try {
-    return method.bind(clipboard);
-  } catch {
-    return void 0;
-  }
-}
-function clipboardItemConstructor() {
-  try {
-    const constructor = member$1(globalThis, "ClipboardItem");
-    if (typeof constructor !== "function") return void 0;
-    return constructor;
-  } catch {
-    return void 0;
-  }
-}
-function canCopy() {
-  return clipboardMethod("writeText") !== void 0;
-}
-function canCopyItems() {
-  return clipboardMethod("write") !== void 0 && clipboardItemConstructor() !== void 0;
-}
-function canReadClipboard() {
-  return clipboardMethod("readText") !== void 0;
-}
-function canLegacyCopy() {
-  try {
-    if (typeof document === "undefined") return false;
-    return typeof member$1(document, "execCommand") === "function";
-  } catch {
-    return false;
-  }
-}
-const HiddenTextareaCss = "position:fixed;top:0;left:0;width:1px;height:1px;padding:0;margin:0;border:none;outline:none;box-shadow:none;background:transparent;opacity:0;pointer-events:none;";
-function restoreFocus(previous) {
-  try {
-    if (previous === null) return;
-    const focus = previous.focus;
-    if (typeof focus !== "function") return;
-    previous.focus({ preventScroll: true });
-  } catch {
-  }
-}
-function detach(element) {
-  try {
-    if (typeof element.remove === "function") {
-      element.remove();
-      return;
-    }
-    element.parentNode?.removeChild(element);
-  } catch {
-  }
-}
-function legacyCopyText(text) {
-  if (!canLegacyCopy()) return { status: "unsupported" };
-  let element;
-  let previouslyFocused = null;
-  try {
-    const body = document.body;
-    if (typeof body !== "object" || body === null) return { status: "unsupported" };
-    previouslyFocused = document.activeElement;
-    element = document.createElement("textarea");
-    element.value = text;
-    element.setAttribute("aria-hidden", "true");
-    element.setAttribute("tabindex", "-1");
-    element.setAttribute("readonly", "readonly");
-    element.style.cssText = HiddenTextareaCss;
-    body.appendChild(element);
-    element.focus({ preventScroll: true });
-    element.select();
-    element.setSelectionRange(0, text.length);
-    const copied = document.execCommand("copy");
-    return copied ? { status: "copied" } : { status: "failed", error: new Error('document.execCommand("copy") reported failure.') };
-  } catch (error) {
-    return toClipboardFailure(error);
-  } finally {
-    if (element !== void 0) detach(element);
-    restoreFocus(previouslyFocused);
-  }
-}
-function withLegacyFallback(modern, text, options) {
-  if (modern.status === "copied") return modern;
-  if (options?.legacyFallback !== true) return modern;
-  if (text === void 0) return modern;
-  const legacy = legacyCopyText(text);
-  if (legacy.status === "copied") return legacy;
-  return modern.status === "unsupported" ? legacy : modern;
-}
-async function writeTextThroughApi(text) {
-  const writeText = clipboardMethod("writeText");
-  if (writeText === void 0) return { status: "unsupported" };
-  try {
-    await writeText(text);
-    return { status: "copied" };
-  } catch (error) {
-    return toClipboardFailure(error);
-  }
-}
-async function copyText(text, options) {
-  try {
-    if (typeof text !== "string") {
-      return reportClipboardOutcome(
-        { status: "failed", error: new TypeError("copyText expects a string.") },
-        options?.onError
-      );
-    }
-    const result = withLegacyFallback(await writeTextThroughApi(text), text, options);
-    return reportClipboardOutcome(result, options?.onError);
-  } catch (error) {
-    return reportClipboardOutcome(toClipboardFailure(error), options?.onError);
-  }
-}
+import { q as queryPermission } from "../../chunks/QueryPermission-BsLR2WRk.js";
 const FallbackMimeType = "application/octet-stream";
 const PlainTextMimeType = "text/plain";
 function plainTextArm(items) {
@@ -180,39 +22,46 @@ function toBlobRecord(items) {
 async function writeItemsThroughApi(items) {
   const write = clipboardMethod("write");
   const ClipboardItemConstructor = clipboardItemConstructor();
-  if (write === void 0 || ClipboardItemConstructor === void 0) return { status: "unsupported" };
+  if (write === void 0 || ClipboardItemConstructor === void 0)
+    return { ok: false, failure: { status: "unsupported" } };
   try {
     await write([new ClipboardItemConstructor(toBlobRecord(items))]);
-    return { status: "copied" };
+    return { ok: true, value: void 0 };
   } catch (error) {
-    return toClipboardFailure(error);
+    return { ok: false, failure: toClipboardFailure(error) };
   }
 }
 async function copyItems(items, options) {
   try {
     if (typeof items !== "object" || items === null) {
       return reportClipboardOutcome(
-        { status: "failed", error: new TypeError("copyItems expects an object keyed by MIME type.") },
+        {
+          ok: false,
+          failure: { status: "failed", error: new TypeError("copyItems expects an object keyed by MIME type.") }
+        },
         options?.onError
       );
     }
     if (Object.keys(items).length === 0) {
       return reportClipboardOutcome(
-        { status: "failed", error: new Error("copyItems was given no representations to write.") },
+        {
+          ok: false,
+          failure: { status: "failed", error: new Error("copyItems was given no representations to write.") }
+        },
         options?.onError
       );
     }
     const result = withLegacyFallback(await writeItemsThroughApi(items), plainTextArm(items), options);
     return reportClipboardOutcome(result, options?.onError);
   } catch (error) {
-    return reportClipboardOutcome(toClipboardFailure(error), options?.onError);
+    return reportClipboardOutcome({ ok: false, failure: toClipboardFailure(error) }, options?.onError);
   }
 }
 async function copyBlob(blob, mimeType, options) {
   try {
     if (typeof blob !== "object" || blob === null) {
       return reportClipboardOutcome(
-        { status: "failed", error: new TypeError("copyBlob expects a Blob.") },
+        { ok: false, failure: { status: "failed", error: new TypeError("copyBlob expects a Blob.") } },
         options?.onError
       );
     }
@@ -220,7 +69,7 @@ async function copyBlob(blob, mimeType, options) {
     const type = mimeType ?? (typeof ownType === "string" && ownType.length > 0 ? ownType : FallbackMimeType);
     return await copyItems({ [type]: blob }, options);
   } catch (error) {
-    return reportClipboardOutcome(toClipboardFailure(error), options?.onError);
+    return reportClipboardOutcome({ ok: false, failure: toClipboardFailure(error) }, options?.onError);
   }
 }
 async function flattenItem(item) {
@@ -246,27 +95,33 @@ async function flattenItem(item) {
 async function readText(options) {
   try {
     const read = clipboardMethod("readText");
-    if (read === void 0) return { status: "unsupported" };
+    if (read === void 0) return { ok: false, failure: { status: "unsupported" } };
     const text = await read();
-    return typeof text === "string" ? { status: "read", text } : reportClipboardOutcome(
+    return typeof text === "string" ? { ok: true, value: text } : reportClipboardOutcome(
       {
-        status: "failed",
-        error: new TypeError("navigator.clipboard.readText resolved with a non-string.")
+        ok: false,
+        failure: {
+          status: "failed",
+          error: new TypeError("navigator.clipboard.readText resolved with a non-string.")
+        }
       },
       options?.onError
     );
   } catch (error) {
-    return reportClipboardOutcome(toClipboardFailure(error), options?.onError);
+    return reportClipboardOutcome({ ok: false, failure: toClipboardFailure(error) }, options?.onError);
   }
 }
 async function readItems(options) {
   try {
     const read = clipboardMethod("read");
-    if (read === void 0) return { status: "unsupported" };
+    if (read === void 0) return { ok: false, failure: { status: "unsupported" } };
     const raw = await read();
     if (!Array.isArray(raw)) {
       return reportClipboardOutcome(
-        { status: "failed", error: new TypeError("navigator.clipboard.read resolved with a non-array.") },
+        {
+          ok: false,
+          failure: { status: "failed", error: new TypeError("navigator.clipboard.read resolved with a non-array.") }
+        },
         options?.onError
       );
     }
@@ -275,9 +130,9 @@ async function readItems(options) {
       if (typeof entry !== "object" || entry === null) continue;
       items.push(...await flattenItem(entry));
     }
-    return { status: "read", items };
+    return { ok: true, value: items };
   } catch (error) {
-    return reportClipboardOutcome(toClipboardFailure(error), options?.onError);
+    return reportClipboardOutcome({ ok: false, failure: toClipboardFailure(error) }, options?.onError);
   }
 }
 function member(source, key) {
@@ -355,7 +210,7 @@ function getPasteItems(event) {
 function usePasteHandler(handler, options) {
   watchPostEffect((onCleanup) => {
     if ((toValue(options?.enabled) ?? true) === false) return;
-    const node = toValue(options?.target) ?? (typeof window === "undefined" ? null : window);
+    const node = options?.target !== void 0 ? toValue(options.target) ?? null : typeof window === "undefined" ? null : window;
     if (node === null || typeof node.addEventListener !== "function") return;
     const preventDefault = toValue(options?.preventDefault) ?? false;
     const listener = (event) => {
@@ -380,6 +235,7 @@ function useClipboardCopy(options) {
   const status = shallowRef("idle");
   let timer = null;
   let disposed = false;
+  let generation = 0;
   function clearTimer() {
     if (timer === null) return;
     clearTimeout(timer);
@@ -390,10 +246,12 @@ function useClipboardCopy(options) {
     clearTimer();
   });
   const copy = async (text) => {
+    const operation = ++generation;
+    clearTimer();
     const result = await copyText(text, toValue(options));
-    if (disposed) return result;
+    if (disposed || operation !== generation) return result;
     clearTimer();
-    status.value = result.status;
+    status.value = result.ok ? "copied" : result.failure.status;
     const resetAfterMs = toValue(options)?.resetAfterMs ?? DefaultResetAfterMs;
     if (resetAfterMs > 0) {
       timer = setTimeout(() => {
@@ -404,6 +262,7 @@ function useClipboardCopy(options) {
     return result;
   };
   const reset = () => {
+    generation++;
     clearTimer();
     status.value = "idle";
   };
@@ -418,19 +277,26 @@ async function getClipboardPermission(mode) {
   if (name === void 0) return "unsupported";
   return queryPermission(name);
 }
+const ClipboardFailureCode = {
+  Denied: "denied",
+  Unsupported: "unsupported",
+  Failed: "failed"
+};
 export {
-  canCopy,
-  canCopyItems,
-  canLegacyCopy,
-  canReadClipboard,
+  ClipboardFailureCode,
+  d as canCopy,
+  e as canCopyItems,
+  f as canLegacyCopy,
+  g as canReadClipboard,
   copyBlob,
   copyItems,
   copyText,
   getClipboardPermission,
   getPasteItems,
-  legacyCopyText,
+  l as legacyCopyText,
   readItems,
   readText,
+  u as useClipboard,
   useClipboardCopy,
   usePasteHandler
 };