@qodalis/cli 2.5.0 → 2.5.2

package/public-api.mjs

@@ -518,7 +518,7 @@ var CliKeyValueStore_TOKEN = createCliToken("cli-key-value-store");
 var SyntaxHighlighterRegistry_TOKEN = createCliToken("syntax-highlighter-registry");
 
 // src/lib/version.ts
-var LIBRARY_VERSION = "2.5.0";
+var LIBRARY_VERSION = "2.5.2";
 var API_VERSION = 2;
 var ANONYMOUS = "\0anonymous";
 function aliasOwner(context2) {
@@ -21610,6 +21610,27 @@ function parseAddArgs(value) {
   }
   return {};
 }
+function sameServerUrl(a, b) {
+  const key = (url) => normalizeServerUrl(absoluteUrl(url))?.toLowerCase();
+  const left = key(a);
+  return !!left && left === key(b);
+}
+function absoluteUrl(url) {
+  const origin = globalThis.location?.origin;
+  if (!origin || /^[a-z][a-z0-9+.-]*:\/\//i.test(url.trim())) return url;
+  try {
+    return new URL(url.trim() || "/", origin).href;
+  } catch {
+    return url;
+  }
+}
+async function serverAt(manager, linked, url) {
+  for (const [name, connection] of manager.connections) {
+    if (!manager.isLinked(name) && sameServerUrl(connection.config.url, url)) return { name, byApp: true };
+  }
+  const saved = (await linked.list()).find((server) => sameServerUrl(server.url, url));
+  return saved ? { name: saved.name, byApp: false } : void 0;
+}
 async function replaceConnection(manager, config) {
   const current = [...manager.connections.keys()].find((n) => n.toLowerCase() === config.name.toLowerCase());
   const wasDefault = !!current && manager.defaultServer === current;
@@ -21654,6 +21675,17 @@ var ServerAddProcessor = class {
     if (checked.mixedContent) {
       writer.writeWarning(t.t("cli.server.link.mixed_content", "This page is served over https: the browser may block requests to an http server."));
     }
+    const same = await serverAt(manager, linked, url);
+    if (same?.byApp) {
+      writer.writeError(t.t("cli.server.link.same_as_app_server", "{url} is already configured by the app as '{name}'.", { url, name: same.name }));
+      return;
+    }
+    if (same) {
+      writer.writeWarning(t.t("cli.server.link.already_linked", "{url} is already linked as '{name}'.", { url, name: same.name }));
+      const again = await reader.readConfirm(t.t("cli.server.link.link_again", "Link it again? It replaces '{name}' (a new token)", { name: same.name }), false);
+      if (!again) return;
+    }
+    const replacing = same?.name;
     let probe;
     context2.spinner?.show(t.t("cli.server.link.checking", "Checking {url}\u2026", { url }));
     try {
@@ -21670,8 +21702,8 @@ var ServerAddProcessor = class {
       const go = await reader.readConfirm(t.t("cli.server.link.http_confirm", "Link it anyway?"), false);
       if (!go) return;
     }
-    let name = args.name;
-    if (name) {
+    let name = args.name ?? replacing;
+    if (name && name !== replacing) {
       if (!await this.nameAvailable(context2, manager, linked, name)) return;
     }
     const tokenFlag = command2.args?.["token"];
@@ -21719,6 +21751,10 @@ var ServerAddProcessor = class {
     const server = { name, url, addedAt: Date.now() };
     const previous = (await linked.get(name))?.name;
     if (previous && previous !== name) await linked.remove(previous);
+    if (replacing && replacing.toLowerCase() !== name.toLowerCase()) {
+      await linked.remove(replacing);
+      if (manager.isLinked(replacing)) manager.removeServer(replacing);
+    }
     await linked.save(server, token);
     const connection = await replaceConnection(manager, linkedServerConfig(server, token));
     if (connection.connected) {
@@ -23864,6 +23900,143 @@ function createCompletionProviders(deps) {
   return [...fromPlugins, ...builtIn];
 }
 
+// src/lib/engine/cli-touch-scroll.ts
+var SLOP_PX = 8;
+var MIN_FLING = 0.15;
+var FRICTION = 0.997;
+var VELOCITY_WINDOW_MS = 100;
+var KEYBOARD_HOLD_MS = 400;
+function enableTouchScroll(terminal, paused = () => false) {
+  const element = terminal.element;
+  if (!element) {
+    return () => {
+    };
+  }
+  let startY = 0;
+  let lastY = 0;
+  let scrolling = false;
+  let carry = 0;
+  let moves = [];
+  let frame = 0;
+  let holdTimer = 0;
+  let holding = false;
+  const textarea = terminal.textarea;
+  const keyboardOpen = () => window.innerHeight < screen.height * 0.75;
+  const holdKeyboard = () => {
+    clearTimeout(holdTimer);
+    if (holding || !textarea || textarea.hasAttribute("inputmode") || keyboardOpen()) {
+      return;
+    }
+    holding = true;
+    textarea.setAttribute("inputmode", "none");
+  };
+  const releaseKeyboard = () => {
+    clearTimeout(holdTimer);
+    if (holding) {
+      holding = false;
+      textarea?.removeAttribute("inputmode");
+    }
+  };
+  const rowHeight = () => {
+    const screen2 = element.querySelector(".xterm-screen");
+    return (screen2?.clientHeight || element.clientHeight) / terminal.rows || 16;
+  };
+  const scrollBy = (pixels) => {
+    carry += pixels;
+    const height = rowHeight();
+    const rows = Math.trunc(carry / height);
+    if (rows === 0) {
+      return true;
+    }
+    carry -= rows * height;
+    const buffer = terminal.buffer.active;
+    const before = buffer.viewportY;
+    terminal.scrollLines(-rows);
+    const moved = buffer.viewportY !== before;
+    if (!moved) {
+      carry = 0;
+    }
+    return moved;
+  };
+  const stopGlide = () => {
+    cancelAnimationFrame(frame);
+    frame = 0;
+  };
+  const glide = (velocity) => {
+    let previous = performance.now();
+    const step = (now) => {
+      const elapsed = Math.min(now - previous, 50);
+      previous = now;
+      velocity *= Math.pow(FRICTION, elapsed);
+      if (Math.abs(velocity) < 0.02 || !scrollBy(velocity * elapsed)) {
+        frame = 0;
+        return;
+      }
+      frame = requestAnimationFrame(step);
+    };
+    frame = requestAnimationFrame(step);
+  };
+  const onStart = (e) => {
+    stopGlide();
+    scrolling = false;
+    if (e.touches.length !== 1 || paused()) {
+      return;
+    }
+    holdKeyboard();
+    startY = lastY = e.touches[0].clientY;
+    carry = 0;
+    moves = [{ y: startY, time: e.timeStamp }];
+  };
+  const onMove = (e) => {
+    if (e.touches.length !== 1 || paused() || moves.length === 0) {
+      return;
+    }
+    const y = e.touches[0].clientY;
+    if (!scrolling && Math.abs(y - startY) < SLOP_PX) {
+      return;
+    }
+    scrolling = true;
+    e.preventDefault();
+    scrollBy(y - lastY);
+    lastY = y;
+    moves.push({ y, time: e.timeStamp });
+    while (moves.length > 2 && e.timeStamp - moves[0].time > VELOCITY_WINDOW_MS) {
+      moves.shift();
+    }
+  };
+  const onEnd = (e) => {
+    if (!scrolling) {
+      releaseKeyboard();
+      moves = [];
+      return;
+    }
+    e.preventDefault();
+    scrolling = false;
+    holdTimer = window.setTimeout(releaseKeyboard, KEYBOARD_HOLD_MS);
+    const first = moves[0];
+    const last = moves[moves.length - 1];
+    moves = [];
+    const elapsed = last.time - first.time;
+    const velocity = elapsed > 0 && e.timeStamp - last.time < VELOCITY_WINDOW_MS ? (last.y - first.y) / elapsed : 0;
+    if (Math.abs(velocity) >= MIN_FLING) {
+      glide(velocity);
+    }
+  };
+  const options = { passive: false, capture: true };
+  element.addEventListener("touchstart", onStart, options);
+  element.addEventListener("touchmove", onMove, options);
+  element.addEventListener("touchend", onEnd, options);
+  element.addEventListener("touchcancel", onEnd, options);
+  return () => {
+    stopGlide();
+    releaseKeyboard();
+    element.removeEventListener("touchstart", onStart, options);
+    element.removeEventListener("touchmove", onMove, options);
+    element.removeEventListener("touchend", onEnd, options);
+    element.removeEventListener("touchcancel", onEnd, options);
+  };
+}
+
 // src/lib/engine/cli-engine.ts
 var CliEngine = class {
   constructor(container, options) {
@@ -23975,6 +24148,12 @@ var CliEngine = class {
     this.serializeAddon = setup.serializeAddon;
     this.dragDropService = setup.dragDropService;
     this.wheelListener = setup.wheelListener;
+    if (this.options?.touchScroll !== false) {
+      this.disposeTouchScroll = enableTouchScroll(
+        this.terminal,
+        () => !!this.executionContext?.contextProcessor
+      );
+    }
     this.handleResize();
   }
   /** 2. Service container, boot service, executor and execution context. */
@@ -24204,6 +24383,7 @@ var CliEngine = class {
     if (this.wheelListener) {
       this.container.removeEventListener("wheel", this.wheelListener);
     }
+    this.disposeTouchScroll?.();
     this.resizeVersion = -1;
     this.resizeScheduled = false;
     this.resizeObserver?.disconnect();
@@ -25112,6 +25292,21 @@ var DARK_SCHEME_QUERY = "(prefers-color-scheme: dark)";
 function asEventTarget(node) {
   return node && typeof node.addEventListener === "function" ? node : null;
 }
+function canScrollWithin(target, root, dx, dy) {
+  for (let el = target; el && el !== root; el = el.parentElement) {
+    if (!(el instanceof HTMLElement)) continue;
+    const style = getComputedStyle(el);
+    const scrollsY = /auto|scroll/.test(style.overflowY) && el.scrollHeight > el.clientHeight;
+    const scrollsX = /auto|scroll/.test(style.overflowX) && el.scrollWidth > el.clientWidth;
+    if (dy !== 0 && scrollsY) {
+      if (dy < 0 ? el.scrollTop > 0 : el.scrollTop + el.clientHeight < el.scrollHeight) return true;
+    }
+    if (dx !== 0 && scrollsX) {
+      if (dx < 0 ? el.scrollLeft > 0 : el.scrollLeft + el.clientWidth < el.scrollWidth) return true;
+    }
+  }
+  return false;
+}
 function followsSystem(input) {
   return input === "auto" || typeof input === "object" && input !== null && input.base === "auto";
 }
@@ -25193,6 +25388,16 @@ var CliPanelController = class {
       if (event.target !== first) return;
       this.syncThemeFromEngine(event.detail);
     };
+    /**
+     * A wheel over the panel chrome (header, icon strip, empty pane) would
+     * scroll the page behind it; the terminals already keep their own wheel.
+     */
+    this.onPanelWheel = (event) => {
+      const wheel = event;
+      const root = this.rootElement;
+      if (!root || canScrollWithin(wheel.target, root, wheel.deltaX, wheel.deltaY)) return;
+      wheel.preventDefault();
+    };
     this.onVisualViewportChange = () => {
       const fields = visualViewportFields();
       const s = this.snapshot;
@@ -25301,9 +25506,13 @@ var CliPanelController = class {
   /** Element containing the terminals, used for theme sync. */
   setRootElement(element) {
     if (element === this.rootElement) return;
-    asEventTarget(this.rootElement)?.removeEventListener(CLI_TERMINAL_THEME_EVENT, this.onTerminalTheme);
+    const previous = asEventTarget(this.rootElement);
+    previous?.removeEventListener(CLI_TERMINAL_THEME_EVENT, this.onTerminalTheme);
+    previous?.removeEventListener("wheel", this.onPanelWheel);
     this.rootElement = element;
-    asEventTarget(element)?.addEventListener(CLI_TERMINAL_THEME_EVENT, this.onTerminalTheme);
+    const next = asEventTarget(element);
+    next?.addEventListener(CLI_TERMINAL_THEME_EVENT, this.onTerminalTheme);
+    next?.addEventListener("wheel", this.onPanelWheel, { passive: false });
     if (element && this.followsTerminalTheme) this.startThemeSync();
   }
   /**