@bobfrankston/winpos 2.0.20

package/windows.ts

@@ -0,0 +1,200 @@
+/**
+ * Window enumeration and filtering
+ */
+
+import { user32, RECT, isBun, SW_RESTORE, SW_MINIMIZE, SW_MAXIMIZE, SW_SHOWNORMAL } from './ffi-wrapper.js';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+export { SW_RESTORE, SW_MINIMIZE, SW_MAXIMIZE, SW_SHOWNORMAL, SW_HIDE, SW_SHOW } from './ffi-wrapper.js';
+
+export interface WindowInfo {
+    hwnd: bigint;
+    title: string;
+    rect: RECT;
+}
+
+let ignores: string[] = [];
+let ignoreStarts: string[] = [];
+
+export function loadIgnorePatterns(filePath: string) {
+    try {
+        const lines = readFileSync(filePath, 'utf-8').split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            if (trimmed.endsWith('*')) {
+                ignoreStarts.push(trimmed.slice(0, -1));
+            } else {
+                ignores.push(trimmed);
+            }
+        }
+    } catch (error: any) {
+        // Ignore file doesn't exist - that's OK
+    }
+}
+
+function shouldIgnoreWindow(title: string): boolean {
+    const lowerTitle = title.toLowerCase();
+    return ignores.some(ign => lowerTitle === ign.toLowerCase()) ||
+        ignoreStarts.some(start => lowerTitle.startsWith(start.toLowerCase()));
+}
+
+export function enumerateWindows(includeIgnored: boolean = false): WindowInfo[] {
+    const windows: WindowInfo[] = [];
+
+    if (isBun) {
+        // Bun implementation
+        const { ptr } = (globalThis as any).Bun;
+
+        const callback = (hwnd: bigint, lParam: bigint) => {
+            const textBuf = new Uint16Array(256);
+            const textPtr = ptr(textBuf);
+            const length = user32.GetWindowTextW(hwnd, textPtr, 256);
+
+            if (length > 0) {
+                const title = String.fromCharCode(...textBuf.slice(0, length));
+
+                if (includeIgnored || !shouldIgnoreWindow(title)) {
+                    const rect: RECT = { Left: 0, Top: 0, Right: 0, Bottom: 0 };
+                    const rectBuf = new Int32Array(4);
+                    const rectPtr = ptr(rectBuf);
+
+                    if (user32.GetWindowRect(hwnd, rectPtr)) {
+                        rect.Left = rectBuf[0];
+                        rect.Top = rectBuf[1];
+                        rect.Right = rectBuf[2];
+                        rect.Bottom = rectBuf[3];
+
+                        if (rect.Top !== rect.Bottom && rect.Left !== rect.Right) {
+                            windows.push({ hwnd, title, rect });
+                        }
+                    }
+                }
+            }
+            return true;
+        };
+
+        user32.EnumWindows(callback, 0n);
+    } else {
+        // Node.js with koffi
+        const callback = (hwnd: bigint, lParam: bigint) => {
+            const textBuf = Buffer.alloc(512);
+            const length = user32.GetWindowTextW(hwnd, textBuf as any, 256);
+
+            if (length > 0) {
+                const title = textBuf.toString('utf16le', 0, length * 2);
+
+                if (includeIgnored || !shouldIgnoreWindow(title)) {
+                    const rect: RECT = { Left: 0, Top: 0, Right: 0, Bottom: 0 };
+
+                    if (user32.GetWindowRect(hwnd, rect)) {
+                        if (rect.Top !== rect.Bottom && rect.Left !== rect.Right) {
+                            windows.push({ hwnd, title, rect });
+                        }
+                    }
+                }
+            }
+            return true;
+        };
+
+        user32.EnumWindows(callback, 0n);
+    }
+
+    return windows;
+}
+
+export function findWindowsByPattern(pattern: string): WindowInfo[] {
+    const allWindows = enumerateWindows();
+
+    if (pattern.startsWith('/') && pattern.endsWith('/')) {
+        // Regex match
+        const regex = new RegExp(pattern.slice(1, -1), 'i');
+        return allWindows.filter(w => regex.test(w.title));
+    } else if (pattern.endsWith('*')) {
+        // Prefix match
+        const prefix = pattern.slice(0, -1).toLowerCase();
+        return allWindows.filter(w => w.title.toLowerCase().startsWith(prefix));
+    } else {
+        // Exact match
+        return allWindows.filter(w => w.title.toLowerCase() === pattern.toLowerCase());
+    }
+}
+
+// Window state management API
+
+export enum WindowState {
+    Normal = 'normal',
+    Minimized = 'minimized',
+    Maximized = 'maximized'
+}
+
+/**
+ * Get the current state of a window
+ */
+export function getWindowState(hwnd: bigint): WindowState {
+    if (user32.IsIconic(hwnd))
+        return WindowState.Minimized;
+    if (user32.IsZoomed(hwnd))
+        return WindowState.Maximized;
+    return WindowState.Normal;
+}
+
+/**
+ * Set the state of a window
+ */
+export function setWindowState(hwnd: bigint, state: WindowState): boolean {
+    switch (state) {
+        case WindowState.Minimized:
+            return user32.ShowWindow(hwnd, SW_MINIMIZE);
+        case WindowState.Maximized:
+            return user32.ShowWindow(hwnd, SW_MAXIMIZE);
+        case WindowState.Normal:
+            return user32.ShowWindow(hwnd, SW_RESTORE);
+        default:
+            return false;
+    }
+}
+
+/**
+ * Check if a window is minimized
+ */
+export function isMinimized(hwnd: bigint): boolean {
+    return user32.IsIconic(hwnd);
+}
+
+/**
+ * Check if a window is maximized
+ */
+export function isMaximized(hwnd: bigint): boolean {
+    return user32.IsZoomed(hwnd);
+}
+
+/**
+ * Check if a window is in normal state
+ */
+export function isNormal(hwnd: bigint): boolean {
+    return !user32.IsIconic(hwnd) && !user32.IsZoomed(hwnd);
+}
+
+/**
+ * Minimize a window
+ */
+export function minimizeWindow(hwnd: bigint): boolean {
+    return user32.ShowWindow(hwnd, SW_MINIMIZE);
+}
+
+/**
+ * Maximize a window
+ */
+export function maximizeWindow(hwnd: bigint): boolean {
+    return user32.ShowWindow(hwnd, SW_MAXIMIZE);
+}
+
+/**
+ * Restore a window to normal state
+ */
+export function restoreWindow(hwnd: bigint): boolean {
+    return user32.ShowWindow(hwnd, SW_RESTORE);
+}