@tryinget/pi-activity-strip 0.2.0 → 0.4.0

package/src/electron/niri-native-window-runtime.mjs

@@ -0,0 +1,178 @@
+// ---
+// summary: "owns Niri native strip remapping, floating conversion, and exact top-edge alignment"
+// read_when:
+//   - "changing compositor-native activity-strip placement or animation detection"
+// ---
+
+import { hasNiriFloatingPosition, isNiriWindowAligned } from "../common/alignment-controller.mjs";
+import { resolveActivityStripWindow } from "../common/niri-focus.mjs";
+
+const defaultWait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+
+function formatDelta(value) {
+  const rounded = Math.round(value);
+  return rounded >= 0 ? `+${rounded}` : String(rounded);
+}
+
+function readPosition(window) {
+  const position = window?.layout?.tile_pos_in_workspace_view;
+  if (!Array.isArray(position) || position.length < 2) return null;
+  return {
+    x: Number(position[0] ?? 0),
+    y: Number(position[1] ?? 0),
+  };
+}
+
+/**
+ * @param {{
+ *   execFileAsync: (file: string, args: string[], options: object) => Promise<unknown>;
+ *   env: NodeJS.ProcessEnv;
+ *   timeoutMs: number;
+ *   processId: number;
+ *   readWindows: () => Promise<Array<Record<string, unknown>>>;
+ *   getBrowserWindow: () => import("electron").BrowserWindow | null;
+ *   getBounds: () => {x: number; y: number; width: number; height: number};
+ *   isNiriSession: () => boolean;
+ *   wait?: (milliseconds: number) => Promise<unknown>;
+ * }} options
+ */
+export function createNiriNativeWindowRuntime(options) {
+  const wait = options.wait ?? defaultWait;
+
+  function resolveProcessWindow(windows) {
+    return resolveActivityStripWindow(
+      windows.filter((window) => window?.pid === options.processId),
+    );
+  }
+
+  async function getProcessWindow() {
+    return resolveProcessWindow(await options.readWindows());
+  }
+
+  async function moveWindowToWorkspace(stripWindow, workspace) {
+    const reference = workspace.name || workspace.idx;
+    if (reference == null) return false;
+    try {
+      await options.execFileAsync(
+        "niri",
+        [
+          "msg",
+          "action",
+          "move-window-to-workspace",
+          "--window-id",
+          String(stripWindow.id),
+          "--focus",
+          "false",
+          String(reference),
+        ],
+        { env: options.env, timeout: options.timeoutMs },
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async function moveWindowToTop(isCurrent) {
+    let animated = false;
+    const browserWindow = options.getBrowserWindow();
+    if (!isCurrent() || !browserWindow || browserWindow.isDestroyed() || !options.isNiriSession()) {
+      return { ok: false, animated };
+    }
+
+    let niriWindow = await getProcessWindow();
+    if (!isCurrent() || !niriWindow?.id) return { ok: false, animated };
+    if (niriWindow.is_floating !== true) {
+      try {
+        await options.execFileAsync(
+          "niri",
+          ["msg", "action", "move-window-to-floating", "--id", String(niriWindow.id)],
+          { env: options.env },
+        );
+        animated = true;
+      } catch {
+        return { ok: false, animated };
+      }
+    }
+
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      if (!isCurrent()) return { ok: false, animated };
+      const position = readPosition(niriWindow);
+      if (hasNiriFloatingPosition(niriWindow) && position) {
+        const target = options.getBounds();
+        if (isNiriWindowAligned(niriWindow, target)) return { ok: true, animated };
+        const deltaX = target.x - position.x;
+        const deltaY = target.y - position.y;
+        if (Math.abs(deltaX) >= 1 || Math.abs(deltaY) >= 1) {
+          try {
+            await options.execFileAsync(
+              "niri",
+              [
+                "msg",
+                "action",
+                "move-floating-window",
+                "--id",
+                String(niriWindow.id),
+                "-x",
+                formatDelta(deltaX),
+                "-y",
+                formatDelta(deltaY),
+              ],
+              { env: options.env },
+            );
+            animated = true;
+          } catch {
+            return { ok: false, animated };
+          }
+        }
+      }
+      await wait(60);
+      if (!isCurrent()) return { ok: false, animated };
+      niriWindow = await getProcessWindow();
+      if (!niriWindow?.id) return { ok: false, animated };
+    }
+    return { ok: false, animated };
+  }
+
+  async function alignWindowToTop(isCurrent) {
+    const browserWindow = options.getBrowserWindow();
+    if (!isCurrent() || !browserWindow || browserWindow.isDestroyed()) {
+      return { ok: false, animated: false };
+    }
+    if (!options.isNiriSession()) {
+      browserWindow.setBounds(options.getBounds(), false);
+      return { ok: true, animated: false };
+    }
+
+    const niriWindow = await getProcessWindow();
+    if (!isCurrent()) return { ok: false, animated: false };
+    const target = options.getBounds();
+    const currentSize = niriWindow?.layout?.window_size;
+    const widthMatches = Array.isArray(currentSize) && Number(currentSize[0]) === target.width;
+    const heightMatches = Array.isArray(currentSize) && Number(currentSize[1]) === target.height;
+    let animated = false;
+
+    if (!widthMatches || !heightMatches) {
+      browserWindow.setSize(target.width, target.height, false);
+      animated = true;
+      await wait(80);
+      if (!isCurrent()) return { ok: false, animated };
+    }
+
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const result = await moveWindowToTop(isCurrent);
+      animated ||= result.animated;
+      if (result.ok) return { ok: true, animated };
+      if (!isCurrent()) return { ok: false, animated };
+      await wait(60);
+    }
+    return { ok: false, animated };
+  }
+
+  return {
+    alignWindowToTop,
+    isWindowAligned: (window) => isNiriWindowAligned(window, options.getBounds()),
+    moveWindowToWorkspace,
+    resolveProcessWindow,
+  };
+}

package/src/electron/niri-workspace-events.mjs

@@ -0,0 +1,81 @@
+// ---
+// summary: "watches focused Niri workspace events with a bounded polling fallback"
+// read_when:
+//   - "changing activity-strip workspace switch latency or Niri event-stream handling"
+// ---
+
+/**
+ * Trigger focused-workspace reconciliation immediately from Niri's event
+ * stream while retaining the slower poll as a fail-closed fallback.
+ * @param {{
+ *   spawn: Function;
+ *   env: NodeJS.ProcessEnv;
+ *   onFocusedWorkspace: (workspaceId: number) => void;
+ *   onFallback: () => void;
+ *   fallbackMs: number;
+ *   setIntervalFn?: typeof setInterval;
+ *   clearIntervalFn?: typeof clearInterval;
+ * }} options
+ */
+export function createNiriWorkspaceEventWatcher(options) {
+  const setIntervalFn = options.setIntervalFn ?? setInterval;
+  const clearIntervalFn = options.clearIntervalFn ?? clearInterval;
+  let buffer = "";
+  let stopped = false;
+  let child = null;
+  let lastFocusedWorkspaceId = null;
+
+  const fallbackTimer = setIntervalFn(() => {
+    if (!stopped) options.onFallback();
+  }, options.fallbackMs);
+  fallbackTimer.unref?.();
+
+  function consume(chunk) {
+    if (stopped) return;
+    buffer += String(chunk ?? "");
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const line = buffer.slice(0, newlineIndex).trim();
+      buffer = buffer.slice(newlineIndex + 1);
+      if (line) {
+        try {
+          const event = JSON.parse(line);
+          const activation = event?.WorkspaceActivated;
+          if (
+            activation?.focused === true &&
+            Number.isInteger(activation.id) &&
+            activation.id !== lastFocusedWorkspaceId
+          ) {
+            lastFocusedWorkspaceId = activation.id;
+            options.onFocusedWorkspace(activation.id);
+          }
+        } catch {
+          // A malformed event is ignored; the fallback poll remains authoritative.
+        }
+      }
+      newlineIndex = buffer.indexOf("\n");
+    }
+  }
+
+  try {
+    child = options.spawn("niri", ["msg", "-j", "event-stream"], {
+      env: options.env,
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    child.stdout?.on?.("data", consume);
+    child.on?.("error", () => {});
+  } catch {
+    child = null;
+  }
+
+  function stop() {
+    if (stopped) return;
+    stopped = true;
+    clearIntervalFn(fallbackTimer);
+    child?.stdout?.removeListener?.("data", consume);
+    child?.kill?.();
+    child = null;
+  }
+
+  return { stop };
+}

package/src/electron/preload.cjs

@@ -1,6 +1,46 @@
+// ---
+// summary: "exposes a sandboxed renderer subscription API for activity-strip snapshot IPC messages"
+// read_when:
+//   - "changing the preload bridge or renderer snapshot subscription contract"
+// ---
+
 const { contextBridge, ipcRenderer } = require("electron");
 
 contextBridge.exposeInMainWorld("activityStrip", {
+  activate(sessionId) {
+    return ipcRenderer.invoke("pi-activity-strip:focus", String(sessionId ?? ""));
+  },
+  setExpanded(expanded) {
+    return ipcRenderer.invoke("pi-activity-strip:set-expanded", Boolean(expanded));
+  },
+  onCollapse(handler) {
+    if (typeof handler !== "function") return () => {};
+    const listener = () => handler();
+    ipcRenderer.on("pi-activity-strip:collapse", listener);
+    return () => ipcRenderer.removeListener("pi-activity-strip:collapse", listener);
+  },
+  onVisibility(handler) {
+    if (typeof handler !== "function") return () => {};
+    let latestRequestId = 0;
+    const listener = (_event, visible, requestId) => {
+      if (!Number.isInteger(requestId) || requestId <= 0) return;
+      latestRequestId = Math.max(latestRequestId, requestId);
+      const isCurrent = () => requestId === latestRequestId;
+      Promise.resolve()
+        .then(() => handler(Boolean(visible), isCurrent))
+        .then((applied) =>
+          ipcRenderer.send(
+            "pi-activity-strip:visibility-applied",
+            requestId,
+            Boolean(visible),
+            applied !== false,
+          ),
+        )
+        .catch(() => {});
+    };
+    ipcRenderer.on("pi-activity-strip:visibility", listener);
+    return () => ipcRenderer.removeListener("pi-activity-strip:visibility", listener);
+  },
   subscribe(handler) {
     if (typeof handler !== "function") return () => {};
     const listener = (_event, snapshot) => handler(snapshot);

package/src/electron/renderer-visibility-runtime.mjs

@@ -0,0 +1,107 @@
+// ---
+// summary: "acknowledges renderer conceal and reveal frames before native Niri lifecycle effects"
+// read_when:
+//   - "changing renderer visibility handshakes or wrong-workspace flash prevention"
+// ---
+
+export const VISIBILITY_CHANNEL = "pi-activity-strip:visibility";
+export const VISIBILITY_APPLIED_CHANNEL = "pi-activity-strip:visibility-applied";
+
+/**
+ * Coordinate one bounded main-to-renderer visibility request. The renderer
+ * acknowledges only after its CSS visibility change crosses two animation
+ * frames, so callers can keep stale cards concealed during native remaps.
+ * @param {{
+ *   getWebContents: () => {send: (channel: string, ...args: unknown[]) => void} | null;
+ *   setInputEnabled: (enabled: boolean) => void;
+ *   timeoutMs: number;
+ *   setTimer?: typeof setTimeout;
+ *   clearTimer?: typeof clearTimeout;
+ * }} options
+ */
+export function createRendererVisibilityRuntime(options) {
+  const setTimer = options.setTimer ?? setTimeout;
+  const clearTimer = options.clearTimer ?? clearTimeout;
+  let nextRequestId = 0;
+  let latestRequestId = 0;
+  const pending = new Map();
+
+  function settle(requestId, applied) {
+    const request = pending.get(requestId);
+    if (!request) return false;
+    pending.delete(requestId);
+    clearTimer(request.timer);
+    request.resolve(applied);
+    return true;
+  }
+
+  async function apply(visible, isCurrent = () => true) {
+    const webContents = options.getWebContents();
+    if (!webContents) return false;
+    if (!visible) options.setInputEnabled(false);
+
+    nextRequestId += 1;
+    const requestId = nextRequestId;
+    latestRequestId = requestId;
+    const applied = new Promise((resolve) => {
+      const timer = setTimer(() => settle(requestId, false), options.timeoutMs);
+      pending.set(requestId, { resolve, timer, webContents, visible: Boolean(visible) });
+    });
+    try {
+      webContents.send(VISIBILITY_CHANNEL, Boolean(visible), requestId);
+    } catch {
+      settle(requestId, false);
+    }
+
+    const succeeded = await applied;
+    const appliedToCurrentRenderer =
+      succeeded &&
+      requestId === latestRequestId &&
+      isCurrent() &&
+      options.getWebContents() === webContents;
+    if (appliedToCurrentRenderer && visible) options.setInputEnabled(true);
+    return appliedToCurrentRenderer;
+  }
+
+  function acknowledge(event, requestId, visible, applied = true) {
+    const request = pending.get(requestId);
+    if (!request || event?.sender !== request.webContents || Boolean(visible) !== request.visible) {
+      return false;
+    }
+    return settle(requestId, Boolean(applied));
+  }
+
+  function dispose() {
+    nextRequestId += 1;
+    latestRequestId = nextRequestId;
+    for (const requestId of [...pending.keys()]) settle(requestId, false);
+    options.setInputEnabled(false);
+  }
+
+  return {
+    acknowledge,
+    appliedChannel: VISIBILITY_APPLIED_CHANNEL,
+    apply,
+    dispose,
+  };
+}
+
+/**
+ * @param {() => import("electron").BrowserWindow | null} getWindow
+ * @param {boolean} interactive
+ */
+export function createBrowserWindowVisibilityRuntime(getWindow, interactive) {
+  return createRendererVisibilityRuntime({
+    getWebContents: () => {
+      const window = getWindow();
+      return window && !window.isDestroyed() ? window.webContents : null;
+    },
+    setInputEnabled: (enabled) => {
+      const window = getWindow();
+      if (!window || window.isDestroyed()) return;
+      window.setFocusable(enabled && interactive);
+      window.setIgnoreMouseEvents(!enabled || !interactive, { forward: true });
+    },
+    timeoutMs: 750,
+  });
+}