@particle-academy/fancy-term 0.3.0 → 0.4.1

package/dist/index.js

@@ -111,18 +111,120 @@ async function readClipboardText() {
   }
   return "";
 }
+var navigatorClipboard = {
+  writeText: (text) => writeClipboardText(text),
+  readText: () => readClipboardText()
+};
+function resolveClipboard(clipboard) {
+  if (clipboard === false) return { enabled: false, provider: navigatorClipboard };
+  if (clipboard && typeof clipboard === "object") return { enabled: true, provider: clipboard };
+  return { enabled: true, provider: navigatorClipboard };
+}
+async function providerWrite(provider, text) {
+  try {
+    await provider.writeText(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function providerRead(provider) {
+  try {
+    return await provider.readText() ?? "";
+  } catch {
+    return "";
+  }
+}
 
-// src/copy-keybinding.ts
-function shouldCopyEvent(e, hasSelection) {
-  if (e.type !== "keydown") return false;
-  if (e.key !== "c" && e.key !== "C") return false;
-  if (e.ctrlKey && e.shiftKey && !e.metaKey) return true;
-  if (e.metaKey && !e.ctrlKey && hasSelection) return true;
-  return false;
+// src/copy-paste-mode.ts
+function copyPasteBehavior(mode) {
+  switch (mode) {
+    case "linux":
+      return { selectToCopy: true, middleClickPaste: true, keyCopy: false, keyPaste: false };
+    case "winmac":
+      return { selectToCopy: false, middleClickPaste: false, keyCopy: true, keyPaste: true };
+    case "contextmenu":
+    default:
+      return { selectToCopy: false, middleClickPaste: false, keyCopy: false, keyPaste: false };
+  }
+}
+function resolveKeyAction(e, hasSelection, behavior) {
+  if (e.type !== "keydown") return null;
+  const key = e.key.toLowerCase();
+  if (key === "c") {
+    if (e.ctrlKey && e.shiftKey && !e.metaKey) return "copy";
+    if (e.metaKey && !e.ctrlKey && hasSelection) return "copy";
+    if (behavior.keyCopy && (e.ctrlKey || e.metaKey) && !e.shiftKey && hasSelection) return "copy";
+    return null;
+  }
+  if (key === "v" && behavior.keyPaste) {
+    if ((e.ctrlKey || e.metaKey) && !e.shiftKey) return "paste";
+    if (e.ctrlKey && e.shiftKey) return "paste";
+    return null;
+  }
+  return null;
+}
+
+// src/osc52.ts
+function encodeBase64(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  return typeof btoa === "function" ? btoa(binary) : binary;
+}
+function decodeBase64(b64) {
+  try {
+    const binary = typeof atob === "function" ? atob(b64) : b64;
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return new TextDecoder().decode(bytes);
+  } catch {
+    return "";
+  }
+}
+function parseOsc52(payload) {
+  const semi = payload.indexOf(";");
+  if (semi < 0) return null;
+  const selection = payload.slice(0, semi);
+  const pd = payload.slice(semi + 1);
+  if (pd === "?") return { selection, kind: "read", data: "" };
+  return { selection, kind: "write", data: decodeBase64(pd) };
+}
+function osc52Response(selection, text) {
+  return `\x1B]52;${selection};${encodeBase64(text)}\x07`;
+}
+function registerOsc52(term, provider, mode) {
+  if (mode() === false) return null;
+  return term.parser.registerOscHandler(52, (payload) => {
+    const m = mode();
+    if (m === false) return true;
+    const req = parseOsc52(payload);
+    if (!req) return false;
+    if (req.kind === "write") {
+      if (m === "copy" || m === "both") {
+        void Promise.resolve(provider().writeText(req.data)).catch(() => {
+        });
+      }
+      return true;
+    }
+    if (m === "read" || m === "both") {
+      void providerRead(provider()).then((text) => {
+        term.write(osc52Response(req.selection, text));
+      });
+    }
+    return true;
+  });
 }
 
 // src/hooks/use-terminal.ts
 var DEFAULT_FONT = 'ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, "Liberation Mono", monospace';
+function makeDeferred() {
+  let resolve;
+  const promise = new Promise((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+}
 function readBuffer(term) {
   if (!term) return "";
   const buf = term.buffer.active;
@@ -138,12 +240,16 @@ function useTerminal(containerRef, options = {}) {
   const fitRef = useRef(null);
   const optsRef = useRef(options);
   optsRef.current = options;
+  const readyRef = useRef(makeDeferred());
   const handleRef = useRef(null);
   if (handleRef.current === null) {
     handleRef.current = {
       get xterm() {
         return xtermRef.current;
       },
+      get ready() {
+        return readyRef.current.promise;
+      },
       write: (d) => xtermRef.current?.write(d),
       writeln: (d) => xtermRef.current?.writeln(d),
       clear: () => xtermRef.current?.clear(),
@@ -166,10 +272,10 @@ function useTerminal(containerRef, options = {}) {
       copySelection: async () => {
         const sel = xtermRef.current?.getSelection() ?? "";
         if (!sel) return false;
-        return writeClipboardText(sel);
+        return providerWrite(resolveClipboard(optsRef.current.clipboard).provider, sel);
       },
       paste: async (text) => {
-        const data = text ?? await readClipboardText();
+        const data = text ?? await providerRead(resolveClipboard(optsRef.current.clipboard).provider);
         if (data) xtermRef.current?.paste(data);
       },
       selectAll: () => xtermRef.current?.selectAll(),
@@ -211,17 +317,54 @@ function useTerminal(containerRef, options = {}) {
     const resizeSub = term.onResize(
       ({ cols, rows }) => optsRef.current.onResize?.({ cols, rows })
     );
+    const pasteFromClipboard = async () => {
+      const oo = optsRef.current;
+      if (oo.readOnly) return;
+      const text = await providerRead(resolveClipboard(oo.clipboard).provider);
+      if (text) xtermRef.current?.paste(text);
+    };
     term.attachCustomKeyEventHandler((e) => {
-      if (optsRef.current.clipboard === false) return true;
-      if (shouldCopyEvent(e, term.hasSelection())) {
-        void writeClipboardText(term.getSelection());
+      const oo = optsRef.current;
+      const clip = resolveClipboard(oo.clipboard);
+      if (!clip.enabled) return true;
+      const action = resolveKeyAction(e, term.hasSelection(), copyPasteBehavior(oo.copyPaste));
+      if (action === "copy") {
+        void providerWrite(clip.provider, term.getSelection());
+        return false;
+      }
+      if (action === "paste") {
+        void pasteFromClipboard();
         return false;
       }
       return true;
     });
+    const oscDisposable = registerOsc52(
+      term,
+      () => resolveClipboard(optsRef.current.clipboard).provider,
+      () => {
+        const oo = optsRef.current;
+        return resolveClipboard(oo.clipboard).enabled ? oo.osc52 ?? "copy" : false;
+      }
+    );
+    const selectionSub = term.onSelectionChange(() => {
+      const oo = optsRef.current;
+      const clip = resolveClipboard(oo.clipboard);
+      if (clip.enabled && copyPasteBehavior(oo.copyPaste).selectToCopy && term.hasSelection()) {
+        void providerWrite(clip.provider, term.getSelection());
+      }
+    });
+    const onMouseDown = (ev) => {
+      const oo = optsRef.current;
+      if (ev.button !== 1) return;
+      if (!resolveClipboard(oo.clipboard).enabled) return;
+      if (!copyPasteBehavior(oo.copyPaste).middleClickPaste) return;
+      ev.preventDefault();
+      void pasteFromClipboard();
+    };
+    el.addEventListener("mousedown", onMouseDown);
     const onPasteEvent = (e) => {
       const o2 = optsRef.current;
-      if (o2.clipboard === false) return;
+      if (resolveClipboard(o2.clipboard).enabled === false) return;
       if (o2.readOnly) {
         e.preventDefault();
         return;
@@ -232,13 +375,19 @@ function useTerminal(containerRef, options = {}) {
     el.addEventListener("paste", onPasteEvent, true);
     if (o.initialOutput) term.write(o.initialOutput);
     if (o.fit ?? true) handle.fit();
+    optsRef.current.onReady?.(term);
+    readyRef.current.resolve(term);
     return () => {
       el.removeEventListener("paste", onPasteEvent, true);
+      el.removeEventListener("mousedown", onMouseDown);
+      oscDisposable?.dispose();
+      selectionSub.dispose();
       dataSub.dispose();
       resizeSub.dispose();
       term.dispose();
       xtermRef.current = null;
       fitRef.current = null;
+      readyRef.current = makeDeferred();
     };
   }, [containerRef]);
   useEffect(() => {
@@ -618,6 +767,12 @@ function resolveMenuItems(config, ctx, actions) {
   const items = config === void 0 || config === true ? defaults : Array.isArray(config) ? config : config(ctx, defaults);
   return items.length > 0 ? items : null;
 }
+
+// src/selection-snapshot.ts
+function nextSelectionSnapshot(prev, event, liveSelection) {
+  if (event.type === "mousedown" && event.button === 0) return "";
+  return liveSelection || prev;
+}
 var Terminal = forwardRef(function Terminal2({
   output,
   theme,
@@ -638,6 +793,9 @@ var Terminal = forwardRef(function Terminal2({
   onShellChange,
   showShellBar = false,
   clipboard,
+  osc52,
+  copyPaste,
+  onReady,
   onPaste,
   contextMenu,
   className,
@@ -674,12 +832,32 @@ var Terminal = forwardRef(function Terminal2({
     onData,
     onResize,
     clipboard,
+    osc52,
+    copyPaste,
+    onReady,
     onPaste
   });
   useImperativeHandle(
     ref,
     () => ({
-      ...handle,
+      get xterm() {
+        return handle.xterm;
+      },
+      get ready() {
+        return handle.ready;
+      },
+      write: handle.write,
+      writeln: handle.writeln,
+      clear: handle.clear,
+      reset: handle.reset,
+      fit: handle.fit,
+      focus: handle.focus,
+      getBuffer: handle.getBuffer,
+      getSelection: handle.getSelection,
+      copySelection: handle.copySelection,
+      paste: handle.paste,
+      selectAll: handle.selectAll,
+      clearSelection: handle.clearSelection,
       setShell: selectShell,
       getShell: () => shellStateRef.current.shellId
     }),
@@ -695,25 +873,42 @@ var Terminal = forwardRef(function Terminal2({
     written.current = output;
   }, [output, handle]);
   const [menu, setMenu] = useState(null);
+  const selectionSnapshot = useRef("");
+  const trackSelection = useCallback(
+    (e) => {
+      selectionSnapshot.current = nextSelectionSnapshot(
+        selectionSnapshot.current,
+        { type: e.type, button: e.button },
+        handle.getSelection()
+      );
+    },
+    [handle]
+  );
   const openMenu = useCallback(
     (e) => {
       if (contextMenu === false) return;
       e.preventDefault();
-      const selection = handle.getSelection();
+      const selection = handle.getSelection() || selectionSnapshot.current;
       const ctx = {
         hasSelection: selection.length > 0,
         selection,
         readOnly: !!readOnly
       };
       const items = resolveMenuItems(contextMenu, ctx, {
-        copy: () => void handle.copySelection(),
+        // Copy writes the SNAPSHOTTED selection through the active clipboard
+        // provider — never a click-time re-read, which copies "" over a TUI
+        // (falling back to the live selection only when the snapshot is empty).
+        copy: (c) => {
+          const text = c.selection || handle.getSelection();
+          if (text) void providerWrite(resolveClipboard(clipboard).provider, text);
+        },
         paste: () => void handle.paste(),
         selectAll: () => handle.selectAll(),
         clear: () => handle.clear()
       });
       if (items) setMenu({ at: { x: e.clientX, y: e.clientY }, items, ctx });
     },
-    [contextMenu, handle, readOnly]
+    [contextMenu, handle, readOnly, clipboard]
   );
   const menuNode = menu ? /* @__PURE__ */ jsx(TerminalContextMenu, { at: menu.at, items: menu.items, ctx: menu.ctx, onClose: () => setMenu(null) }) : null;
   const surface = /* @__PURE__ */ jsx(
@@ -721,6 +916,8 @@ var Terminal = forwardRef(function Terminal2({
     {
       ref: containerRef,
       "data-fancy-terminal": "",
+      onMouseDownCapture: trackSelection,
+      onMouseUpCapture: trackSelection,
       onContextMenu: openMenu,
       "data-readonly": readOnly ? "" : void 0,
       "data-fancy-terminal-shell": shellId ?? void 0,
@@ -814,6 +1011,15 @@ function useTerminalSession(options) {
   return { output, sendData, append, clear, shell, switchShell };
 }
 
-export { BUILTIN_SHELLS, ShellSwitcher, Terminal, TerminalContextMenu, clampMenuPosition, defaultMenuItems, fancyDarkTheme, isImageFile, resolveMenuItems, resolveShell, shouldCopyEvent, useTerminal, useTerminalFit, useTerminalSession };
+// src/copy-keybinding.ts
+function shouldCopyEvent(e, hasSelection) {
+  if (e.type !== "keydown") return false;
+  if (e.key !== "c" && e.key !== "C") return false;
+  if (e.ctrlKey && e.shiftKey && !e.metaKey) return true;
+  if (e.metaKey && !e.ctrlKey && hasSelection) return true;
+  return false;
+}
+
+export { BUILTIN_SHELLS, ShellSwitcher, Terminal, TerminalContextMenu, clampMenuPosition, copyPasteBehavior, decodeBase64, defaultMenuItems, encodeBase64, fancyDarkTheme, isImageFile, navigatorClipboard, nextSelectionSnapshot, osc52Response, parseOsc52, registerOsc52, resolveClipboard, resolveKeyAction, resolveMenuItems, resolveShell, shouldCopyEvent, useTerminal, useTerminalFit, useTerminalSession };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map