bun-app-window 0.7.0 → 0.9.0

package/src/shell/resolve.ts

@@ -14,15 +14,7 @@
  */
 
 import { createHash } from "node:crypto";
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  renameSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 
@@ -48,176 +40,165 @@ const INSTALLED = /[\\/]node_modules[\\/]/i.test(PKG_ROOT);
 
 /** 是否运行在 `bun build --compile` 产物内 */
 export function isPackedRuntime(): boolean {
-  return (
-    /^[A-Za-z]:[\\/]~BUN[\\/]/i.test(import.meta.dir) ||
-    import.meta.dir.startsWith("/$bunfs/")
-  );
+    return /^[A-Za-z]:[\\/]~BUN[\\/]/i.test(import.meta.dir) || import.meta.dir.startsWith("/$bunfs/");
 }
 
 function sha256Hex(buf: Uint8Array): string {
-  return createHash("sha256").update(buf).digest("hex");
+    return createHash("sha256").update(buf).digest("hex");
 }
 
 function runtimeDir(appName: string): string {
-  const base =
-    process.env.LOCALAPPDATA && process.env.LOCALAPPDATA.length > 0
-      ? process.env.LOCALAPPDATA
-      : join(homedir(), "AppData", "Local");
-  return join(base, appName, "runtime");
+    const base =
+        process.env.LOCALAPPDATA && process.env.LOCALAPPDATA.length > 0
+            ? process.env.LOCALAPPDATA
+            : join(homedir(), "AppData", "Local");
+    return join(base, appName, "runtime");
 }
 
 function fromPath(path: string, source: NativeLibInfo["source"]): NativeLibInfo {
-  return {
-    path,
-    source,
-    version: PKG_VERSION,
-    sha256: "",
-    bytes: statSync(path).size,
-    reused: false,
-    pruned: [],
-  };
+    return {
+        path,
+        source,
+        version: PKG_VERSION,
+        sha256: "",
+        bytes: statSync(path).size,
+        reused: false,
+        pruned: [],
+    };
 }
 
 /** 写入目标目录；同名同大小视为可复用，写入走临时文件 + rename 保证原子性 */
-function materialize(
-  dir: string,
-  bytes: Uint8Array,
-  sha256: string,
-): { path: string; reused: boolean } {
-  mkdirSync(dir, { recursive: true });
+function materialize(dir: string, bytes: Uint8Array, sha256: string): { path: string; reused: boolean } {
+    mkdirSync(dir, { recursive: true });
+
+    const finalName = `libshell-${sha256.slice(0, 16)}.dll`;
+    const finalPath = join(dir, finalName);
+
+    if (existsSync(finalPath)) {
+        try {
+            if (statSync(finalPath).size === bytes.length) {
+                return { path: finalPath, reused: true };
+            }
+        } catch {
+            // 读不到就重写
+        }
+    }
 
-  const finalName = `libshell-${sha256.slice(0, 16)}.dll`;
-  const finalPath = join(dir, finalName);
+    const tmpPath = join(dir, `.tmp-${process.pid}-${Date.now().toString(36)}.dll`);
+    writeFileSync(tmpPath, bytes);
 
-  if (existsSync(finalPath)) {
     try {
-      if (statSync(finalPath).size === bytes.length) {
-        return { path: finalPath, reused: true };
-      }
-    } catch {
-      // 读不到就重写
+        renameSync(tmpPath, finalPath);
+    } catch (err) {
+        // Windows 上目标已存在时 rename 会失败：另一个实例可能刚好抢先写入
+        rmSync(tmpPath, { force: true });
+        if (!existsSync(finalPath)) throw err;
     }
-  }
-
-  const tmpPath = join(dir, `.tmp-${process.pid}-${Date.now().toString(36)}.dll`);
-  writeFileSync(tmpPath, bytes);
-
-  try {
-    renameSync(tmpPath, finalPath);
-  } catch (err) {
-    // Windows 上目标已存在时 rename 会失败：另一个实例可能刚好抢先写入
-    rmSync(tmpPath, { force: true });
-    if (!existsSync(finalPath)) throw err;
-  }
 
-  return { path: finalPath, reused: false };
+    return { path: finalPath, reused: false };
 }
 
 /** 删掉与当前哈希不符的旧副本；正被其它实例占用的删除失败则忽略 */
 function pruneOldVersions(dir: string, keepName: string): string[] {
-  const pruned: string[] = [];
-  let entries: string[];
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return pruned;
-  }
-
-  for (const name of entries) {
-    if (!DLL_PATTERN.test(name)) continue;
-    if (name === keepName) continue;
+    const pruned: string[] = [];
+    let entries: string[];
     try {
-      rmSync(join(dir, name), { force: true });
-      pruned.push(name);
+        entries = readdirSync(dir);
     } catch {
-      // 正被其它实例加载，跳过
+        return pruned;
+    }
+
+    for (const name of entries) {
+        if (!DLL_PATTERN.test(name)) continue;
+        if (name === keepName) continue;
+        try {
+            rmSync(join(dir, name), { force: true });
+            pruned.push(name);
+        } catch {
+            // 正被其它实例加载，跳过
+        }
     }
-  }
-  return pruned;
+    return pruned;
 }
 
 /** 从 Bun.embeddedFiles 找内嵌 DLL；没有则返回 null */
 async function readBunEmbedded(): Promise<Uint8Array | null> {
-  const files = (Bun as unknown as { embeddedFiles?: ReadonlyArray<Blob & { name: string }> })
-    .embeddedFiles;
-  if (!files || files.length === 0) return null;
-
-  const hit = files.find((f) => DLL_PATTERN.test(f.name));
-  if (!hit) return null;
-
-  const buf = new Uint8Array(await hit.arrayBuffer());
-  if (buf.length < 2 || buf[0] !== 0x4d || buf[1] !== 0x5a) {
-    throw new Error(`embedded native library is not a PE file (${hit.name})`);
-  }
-  return buf;
+    const files = (Bun as unknown as { embeddedFiles?: ReadonlyArray<Blob & { name: string }> }).embeddedFiles;
+    if (!files || files.length === 0) return null;
+
+    const hit = files.find((f) => DLL_PATTERN.test(f.name));
+    if (!hit) return null;
+
+    const buf = new Uint8Array(await hit.arrayBuffer());
+    if (buf.length < 2 || buf[0] !== 0x4d || buf[1] !== 0x5a) {
+        throw new Error(`embedded native library is not a PE file (${hit.name})`);
+    }
+    return buf;
 }
 
 export type ResolveOptions = {
-  nativeLibPath?: string;
-  appName?: string;
-  embedded?: () => Promise<Uint8Array | null>;
+    nativeLibPath?: string;
+    appName?: string;
+    embedded?: () => Promise<Uint8Array | null>;
 };
 
 export async function resolveNativeLib(opts: ResolveOptions = {}): Promise<NativeLibInfo> {
-  const appName = opts.appName ?? "BunAppWindow";
-
-  // 1. 显式指定
-  if (opts.nativeLibPath) {
-    if (!existsSync(opts.nativeLibPath)) {
-      throw new Error(`nativeLibPath does not exist: ${opts.nativeLibPath}`);
+    const appName = opts.appName ?? "BunAppWindow";
+
+    // 1. 显式指定
+    if (opts.nativeLibPath) {
+        if (!existsSync(opts.nativeLibPath)) {
+            throw new Error(`nativeLibPath does not exist: ${opts.nativeLibPath}`);
+        }
+        return fromPath(opts.nativeLibPath, "explicit");
     }
-    return fromPath(opts.nativeLibPath, "explicit");
-  }
-
-  if (isPackedRuntime()) {
-    // 2. 内嵌字节 → 释放到用户目录
-    const bytes = opts.embedded ? await opts.embedded() : await readBunEmbedded();
-    if (bytes) {
-      const sha256 = sha256Hex(bytes);
-      try {
-        const { path, reused } = materialize(runtimeDir(appName), bytes, sha256);
-        return {
-          path,
-          source: "embedded",
-          version: PKG_VERSION,
-          sha256,
-          bytes: bytes.length,
-          reused,
-          pruned: pruneOldVersions(dirname(path), basename(path)),
-        };
-      } catch {
-        // %LOCALAPPDATA% 不可写（受限环境）：继续尝试同级文件
-      }
+
+    if (isPackedRuntime()) {
+        // 2. 内嵌字节 → 释放到用户目录
+        const bytes = opts.embedded ? await opts.embedded() : await readBunEmbedded();
+        if (bytes) {
+            const sha256 = sha256Hex(bytes);
+            try {
+                const { path, reused } = materialize(runtimeDir(appName), bytes, sha256);
+                return {
+                    path,
+                    source: "embedded",
+                    version: PKG_VERSION,
+                    sha256,
+                    bytes: bytes.length,
+                    reused,
+                    pruned: pruneOldVersions(dirname(path), basename(path)),
+                };
+            } catch {
+                // %LOCALAPPDATA% 不可写（受限环境）：继续尝试同级文件
+            }
+        }
+
+        // 3. 可执行文件同级
+        for (const candidate of [
+            join(dirname(process.execPath), "libshell.dll"),
+            join(dirname(process.execPath), "dist", "libshell.dll"),
+        ]) {
+            if (existsSync(candidate)) return fromPath(candidate, "package");
+        }
+
+        throw new Error(
+            "cannot locate libshell.dll in a compiled executable. " +
+                "Either place libshell.dll next to the executable, or import " +
+                "`bun-app-window/embedded` so it gets bundled. " +
+                `Searched: ${dirname(process.execPath)}`,
+        );
     }
 
-    // 3. 可执行文件同级
-    for (const candidate of [
-      join(dirname(process.execPath), "libshell.dll"),
-      join(dirname(process.execPath), "dist", "libshell.dll"),
-    ]) {
-      if (existsSync(candidate)) return fromPath(candidate, "package");
+    // 4. 开发态 / 包安装态：包根下的 .build/ 再 dist/
+    const source: NativeLibInfo["source"] = INSTALLED ? "package" : "dev";
+    for (const candidate of [join(PKG_ROOT, ".build", "libshell.dll"), join(PKG_ROOT, "dist", "libshell.dll")]) {
+        if (existsSync(candidate)) return fromPath(candidate, source);
     }
 
     throw new Error(
-      "cannot locate libshell.dll in a compiled executable. " +
-        "Either place libshell.dll next to the executable, or import " +
-        "`bun-app-window/embedded` so it gets bundled. " +
-        `Searched: ${dirname(process.execPath)}`,
+        "libshell.dll not found. Build the native layer first: " +
+            "`bun run native/build.ts`. " +
+            `Searched under ${PKG_ROOT}`,
     );
-  }
-
-  // 4. 开发态 / 包安装态：包根下的 .build/ 再 dist/
-  const source: NativeLibInfo["source"] = INSTALLED ? "package" : "dev";
-  for (const candidate of [
-    join(PKG_ROOT, ".build", "libshell.dll"),
-    join(PKG_ROOT, "dist", "libshell.dll"),
-  ]) {
-    if (existsSync(candidate)) return fromPath(candidate, source);
-  }
-
-  throw new Error(
-    "libshell.dll not found. Build the native layer first: " +
-      "`bun run native/build.ts`. " +
-      `Searched under ${PKG_ROOT}`,
-  );
 }

package/src/shell/state.ts

@@ -3,6 +3,7 @@ import { dirname, resolve } from "node:path";
 
 import { EVENT_STATE, attachEventPump, type EventPump, unrefTimer } from "./events";
 import type { Shell } from "./index";
+import { isMinimizedSentinel, parseBounds, type WindowRect } from "./types";
 
 /**
  * 窗口位置与尺寸的持久化。
@@ -32,16 +33,26 @@ import type { Shell } from "./index";
  * 位置变化就永久丢了——用户「拖完立刻点 X」是最常见的关闭方式。
  */
 
-export type WindowPlacement = {
-    /** 物理像素，屏幕坐标 */
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    maximized: boolean;
-    /** 保存时的窗口 DPI；恢复时用于换算尺寸 */
-    dpi: number;
-};
+/**
+ * 窗口矩形的持久化形态——与 `Shell.getRect()` 返回的 `WindowRect` 是同一个类型。
+ *
+ * 不再各自定义一份形状相同的结构：两份类型会让 `savePlacement(file, shell.getRect())`
+ * 这种直接传递，在字段漂移时**静默丢字段**（结构宽的那个能赋给窄的，反过来不行，
+ * 而 TS 只报错不提「这是同一份数据」）。`tests/rect.test.ts` 钉住两者可互换。
+ *
+ * 语义差别只在用途上：`WindowRect` 说的是「此刻读到什么」，本别名说的是
+ * 「这份读数要落盘」。字段集合必须一致，因为它们本来就是同一次原生读取。
+ */
+export type WindowPlacement = WindowRect;
+
+/**
+ * 从 `./types` 转出解析器，保持 `bun-app-window/state` 的既有导入面不破。
+ *
+ * 真正实现在 `types.ts`：主入口 `getRect()` 也要用它，而本模块依赖 `node:fs`，
+ * 主入口不能反过来依赖这个可选件。两个子路径拿到的是**同一个函数对象**
+ * （`tests/rect.test.ts` 用 `toBe` 钉住），不会出现两份判据各说各话。
+ */
+export { parseBounds };
 
 const DEFAULTS = {
     /** 收到变化事件后攒多久再写盘。拖动期间事件每帧一条，攒到停手写一次 */
@@ -50,59 +61,6 @@ const DEFAULTS = {
     pumpMs: 16,
 } as const;
 
-/**
- * Win32 的「窗口已最小化」哨兵坐标。
- *
- * 窗口最小化时 `GetWindowRect` 返回的不是真实位置，而是一对哨兵值——实测
- * `-32000,-32000` 加一个图标尺寸（典型 `314x50`）。它们**看起来完全合法**：
- * 坐标是整数，尺寸也大于 0，所以只判「非有限 / 尺寸 ≤ 0」的形状校验拦不住。
- *
- * 成因在原生 `format_bounds`：它只在 `IsZoomed` 为真时走
- * `WINDOWPLACEMENT.rcNormalPosition`，最小化时 `IsZoomed` 返回 false，于是落进
- * `GetWindowRect` 分支——**`IsIconic` 从未被判断**。于是这对哨兵值会一路写成
- * `{"x":-32000,"y":-32000,"width":314,"height":50}`，下次启动恢复成一个畸形小窗
- * （实测：666×471，页面被挤到换行并出现滚动条）。
- *
- * 阈值取 -30000 而不是精确 -32000：不同 DPI / 主题下这对值会带几个像素偏移。
- * 真实坐标到不了这个量级——8K 屏横向也只有 7680，多屏横排也远不到 30000，
- * 所以用阈值不会误伤合法的负坐标（主屏在右、副屏在左时 x 确实是负数）。
- */
-const MINIMIZED_SENTINEL = -30000;
-
-/** 是不是 Win32 的最小化哨兵坐标。任一维命中即判否——两维是同时写的 */
-function isMinimizedSentinel(x: number, y: number): boolean {
-    return x <= MINIMIZED_SENTINEL || y <= MINIMIZED_SENTINEL;
-}
-
-/** 把原生返回的一行文本解析成 WindowPlacement；格式不对返回 null。 */
-export function parseBounds(text: string): WindowPlacement | null {
-    const parts = text.trim().split(",");
-    if (parts.length !== 6) {
-        return null;
-    }
-    const nums = parts.map((p) => Number(p));
-    if (nums.some((n) => !Number.isFinite(n))) {
-        return null;
-    }
-    const [x, y, width, height, maximized, dpi] = nums as [
-        number,
-        number,
-        number,
-        number,
-        number,
-        number,
-    ];
-    // 尺寸为 0 或负数说明窗口还没建好（原生在无窗口时返回 0 长度文本，这里再兜一层）
-    if (width <= 0 || height <= 0 || dpi <= 0) {
-        return null;
-    }
-    // 最小化时原生给的是哨兵坐标，不是真实位置——宁可返回 null 让调用方保留上一次的值
-    if (isMinimizedSentinel(x, y)) {
-        return null;
-    }
-    return { x, y, width, height, maximized: maximized !== 0, dpi };
-}
-
 /**
  * 校验外部来源（磁盘 JSON）里的 placement。
  *
@@ -217,15 +175,9 @@ export type PlacementStoreOptions = {
  * 首次 `attach` 会立刻抓一次快照并写盘——程序若在用户操作前崩溃，也还有
  * 初始位置可恢复。
  */
-export function attachPlacementStore(
-    shell: Shell,
-    file: string,
-    opts: PlacementStoreOptions = {},
-): PlacementStore {
+export function attachPlacementStore(shell: Shell, file: string, opts: PlacementStoreOptions = {}): PlacementStore {
     const debounceMs = Math.max(0, opts.debounceMs ?? DEFAULTS.debounceMs);
-    const pump =
-        opts.events ??
-        attachEventPump(shell, { intervalMs: Math.max(1, opts.pumpMs ?? DEFAULTS.pumpMs) });
+    const pump = opts.events ?? attachEventPump(shell, { intervalMs: Math.max(1, opts.pumpMs ?? DEFAULTS.pumpMs) });
     const ownsPump = opts.events === undefined;
 
     let last: WindowPlacement | null = null;
@@ -277,9 +229,11 @@ export function attachPlacementStore(
             return;
         }
         // 串行化写入：并发 rename 同一目标会互相踩
-        pending = pending.then(() => savePlacement(file, now)).catch(() => {
-            // 写盘失败不该打断应用；下一次变化会重试
-        });
+        pending = pending
+            .then(() => savePlacement(file, now))
+            .catch(() => {
+                // 写盘失败不该打断应用；下一次变化会重试
+            });
     };
 
     const scheduleWrite = (): void => {