fix(fs,internal,path): unify isWindows implementations (#6744)

Author: lionel-rowe

_tools/node_test_runner/tsconfig_for_bun.json

@@ -7,6 +7,7 @@
       "@std/internal/diff": ["./internal/diff.ts"],
       "@std/internal/diff-str": ["./internal/diff_str.ts"],
       "@std/internal/format": ["./internal/format.ts"],
+      "@std/internal/os": ["./internal/os.ts"],
       "@std/internal/styles": ["./internal/styles.ts"],
       "@std/path": ["./path/mod.ts"],
       "@std/semver": ["./semver/mod.ts"]

fs/_to_file_info.ts

@@ -1,7 +1,7 @@
 // Copyright 2018-2025 the Deno authors. MIT license.
 
 import type { FileInfo } from "./unstable_types.ts";
-import { isWindows } from "./_utils.ts";
+import { isWindows } from "@std/internal/os";
 
 export function toFileInfo(s: import("node:fs").Stats): FileInfo {
   return {

fs/_utils.ts

@@ -6,21 +6,6 @@
  */
 export const isDeno = navigator.userAgent?.includes("Deno");
 
-/** True if the platform is windows, false otherwise */
-export const isWindows = checkWindows();
-
-/**
- * @returns true if the platform is Windows, false otherwise.
- */
-function checkWindows(): boolean {
-  if (typeof navigator !== "undefined" && (navigator as any).platform) {
-    return (navigator as any).platform.startsWith("Win");
-  } else if (typeof (globalThis as any).process !== "undefined") {
-    return (globalThis as any).platform === "win32";
-  }
-  return false;
-}
-
 /**
  * @returns The Node.js `fs` module.
  */

fs/copy.ts

@@ -7,9 +7,7 @@ import { ensureDir, ensureDirSync } from "./ensure_dir.ts";
 import { getFileInfoType } from "./_get_file_info_type.ts";
 import { toPathString } from "./_to_path_string.ts";
 import { isSubdir } from "./_is_subdir.ts";
-
-// deno-lint-ignore no-explicit-any
-const isWindows = (globalThis as any).Deno?.build.os === "windows";
+import { isWindows } from "@std/internal/os";
 
 /** Options for {@linkcode copy} and {@linkcode copySync}. */
 export interface CopyOptions {

fs/ensure_symlink.ts

@@ -4,9 +4,7 @@ import { resolve } from "@std/path/resolve";
 import { ensureDir, ensureDirSync } from "./ensure_dir.ts";
 import { getFileInfoType, type PathType } from "./_get_file_info_type.ts";
 import { toPathString } from "./_to_path_string.ts";
-
-// deno-lint-ignore no-explicit-any
-const isWindows = (globalThis as any).Deno?.build.os === "windows";
+import { isWindows } from "@std/internal/os";
 
 function resolveSymlinkTarget(target: string | URL, linkName: string | URL) {
   if (typeof target !== "string") return target; // URL is always absolute path

fs/expand_glob.ts

@@ -12,12 +12,10 @@ import {
   createWalkEntrySync,
   type WalkEntry,
 } from "./_create_walk_entry.ts";
+import { isWindows } from "@std/internal/os";
 
 export type { GlobOptions, WalkEntry };
 
-// deno-lint-ignore no-explicit-any
-const isWindows = (globalThis as any).Deno?.build.os === "windows";
-
 /** Options for {@linkcode expandGlob} and {@linkcode expandGlobSync}. */
 export interface ExpandGlobOptions extends Omit<GlobOptions, "os"> {
   /**

internal/_os.ts

@@ -0,0 +1,13 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+export function checkWindows(): boolean {
+  // deno-lint-ignore no-explicit-any
+  const global = globalThis as any;
+  const os = global.Deno?.build?.os;
+
+  // Check Deno, then the remaining runtimes (e.g. Node, Bun and the browser)
+  return typeof os === "string"
+    ? os === "windows"
+    : global.navigator?.platform?.startsWith("Win") ??
+      global.process?.platform?.startsWith("win") ?? false;
+}

internal/_os_test.ts

@@ -0,0 +1,65 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+import { assertEquals } from "@std/assert/equals";
+import { checkWindows } from "./_os.ts";
+import { disposableStack, stubProperty } from "./_testing.ts";
+
+// deno-lint-ignore no-explicit-any
+const global = globalThis as any;
+
+Deno.test("checkWindows() returns `true` on Windows on various runtimes", async (t) => {
+  await t.step("Deno", () => {
+    using stack = disposableStack();
+    stack.use(stubProperty(global, "Deno", { build: { os: "windows" } }));
+    stack.use(stubProperty(global, "navigator", undefined));
+    stack.use(stubProperty(global, "process", undefined));
+
+    assertEquals(checkWindows(), true);
+  });
+
+  await t.step("Browser etc.", () => {
+    using stack = disposableStack();
+    stack.use(stubProperty(global, "Deno", undefined));
+    stack.use(stubProperty(global, "navigator", { platform: "Win32" }));
+    stack.use(stubProperty(global, "process", undefined));
+
+    assertEquals(checkWindows(), true);
+  });
+
+  await t.step("NodeJS etc.", () => {
+    using stack = disposableStack();
+    stack.use(stubProperty(global, "Deno", undefined));
+    stack.use(stubProperty(global, "navigator", undefined));
+    stack.use(stubProperty(global, "process", { platform: "win32" }));
+
+    assertEquals(checkWindows(), true);
+  });
+});
+
+Deno.test("checkWindows() returns `false` on Linux on various runtimes", async (t) => {
+  await t.step("Deno", () => {
+    using stack = disposableStack();
+    stack.use(stubProperty(global, "Deno", { build: { os: "linux" } }));
+    stack.use(stubProperty(global, "navigator", undefined));
+    stack.use(stubProperty(global, "process", undefined));
+
+    assertEquals(checkWindows(), false);
+  });
+
+  await t.step("Browser etc.", () => {
+    using stack = disposableStack();
+    stack.use(stubProperty(global, "Deno", undefined));
+    stack.use(stubProperty(global, "navigator", { platform: "Linux x86_64" }));
+    stack.use(stubProperty(global, "process", undefined));
+
+    assertEquals(checkWindows(), false);
+  });
+
+  await t.step("NodeJS etc.", () => {
+    using stack = disposableStack();
+    stack.use(stubProperty(global, "Deno", undefined));
+    stack.use(stubProperty(global, "navigator", undefined));
+    stack.use(stubProperty(global, "process", { platform: "linux" }));
+
+    assertEquals(checkWindows(), false);
+  });
+});

internal/_testing.ts

@@ -0,0 +1,68 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+/**
+ * Stubs a property on an object, retaining the attributes of the original property descriptor as far as possible.
+ *
+ * @typeParam Self The type of the object to stub a property of.
+ * @typeParam Prop The property of the instance to stub.
+ * @param self The object to stub the property on.
+ * @param property The property to stub.
+ * @param value The value to stub the property with.
+ * @returns A disposable that restores the original property when disposed.
+ */
+export function stubProperty<Self, Prop extends keyof Self>(
+  self: Self,
+  property: Prop,
+  value: Self[Prop],
+): Disposable {
+  const descriptor = Object.getOwnPropertyDescriptor(self, property);
+
+  if (descriptor == null) {
+    Object.defineProperty(self, property, { value, configurable: true });
+    return {
+      [Symbol.dispose]() {
+        delete self[property];
+      },
+    };
+  }
+
+  if (!descriptor.configurable && !descriptor.writable) {
+    throw new TypeError(
+      `Cannot stub property "${
+        String(property)
+      }" because it is not configurable or writable.`,
+    );
+  }
+
+  Object.defineProperty(self, property, {
+    ...descriptor,
+    ...(Object.hasOwn(descriptor, "get") || Object.hasOwn(descriptor, "set")
+      ? { get: () => value }
+      : { value }),
+  });
+
+  return {
+    [Symbol.dispose]() {
+      Object.defineProperty(self, property, descriptor);
+    },
+  };
+}
+
+// partial `DisposableStack` polyfill
+// https://github.com/tc39/proposal-explicit-resource-management
+export function disposableStack() {
+  return {
+    disposables: [] as Disposable[],
+    defer(fn: () => void) {
+      this.disposables.push({ [Symbol.dispose]: fn });
+    },
+    use(val: Disposable) {
+      this.disposables.push(val);
+    },
+    [Symbol.dispose]() {
+      for (let i = this.disposables.length - 1; i >= 0; --i) {
+        this.disposables[i]![Symbol.dispose]();
+      }
+    },
+  };
+}

internal/_testing_test.ts

@@ -0,0 +1,106 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// deno-lint-ignore-file deno-style-guide/naming-convention
+import { assertEquals } from "@std/assert/equals";
+import { stubProperty } from "./_testing.ts";
+import { assertThrows } from "@std/assert/throws";
+
+const PROP = "foo";
+const ORIGINAL_VALUE = "bar";
+const STUBBED_VALUE = "baz";
+
+type Obj = { [PROP]?: string };
+
+Deno.test("stubProperty() stubs properties and returns them to their original values", () => {
+  const descriptors: (TypedPropertyDescriptor<string> | undefined)[] = [
+    undefined,
+    {
+      get: () => ORIGINAL_VALUE,
+      configurable: true,
+    },
+    {
+      set: () => {},
+      configurable: true,
+    },
+    { value: ORIGINAL_VALUE, writable: true, configurable: true },
+    { value: ORIGINAL_VALUE, writable: true, configurable: false },
+    { value: ORIGINAL_VALUE, writable: false, configurable: true },
+  ];
+
+  const Empty = () => class Empty {};
+  const Val = () =>
+    class Val {
+      [PROP] = ORIGINAL_VALUE;
+    };
+  const Get = () =>
+    class Get {
+      get [PROP]() {
+        return ORIGINAL_VALUE;
+      }
+    };
+
+  const objCreators: (() => Obj)[] = [
+    () => ({}),
+    () => ({ [PROP]: ORIGINAL_VALUE }),
+    () => {
+      const o: Obj = {};
+      o[PROP] = ORIGINAL_VALUE;
+      return o;
+    },
+    () => new (Val())(),
+    () => new (Get())(),
+    () => new (Empty())(),
+    () => Val().prototype,
+    () => Get().prototype,
+    () => Empty().prototype,
+    () => Object.create({ [PROP]: ORIGINAL_VALUE }),
+  ];
+
+  for (const getObj of objCreators) {
+    for (const descriptor of descriptors) {
+      const obj = getObj();
+      if (descriptor != null) Object.defineProperty(obj, PROP, descriptor);
+
+      const initialDescriptor = Object.getOwnPropertyDescriptor(obj, PROP);
+      const initialValue = obj[PROP];
+
+      {
+        using _ = stubProperty(obj, PROP, STUBBED_VALUE);
+        assertEquals(obj[PROP], STUBBED_VALUE);
+      }
+
+      assertEquals(obj[PROP], initialValue);
+      assertEquals(
+        Object.getOwnPropertyDescriptor(obj, PROP),
+        initialDescriptor,
+      );
+    }
+  }
+});
+
+Deno.test("stubProperty() throws if property is not configurable or writable", () => {
+  assertThrows(
+    () =>
+      stubProperty(
+        Object.defineProperty(
+          {} as Obj,
+          PROP,
+          { value: ORIGINAL_VALUE },
+        ),
+        PROP,
+        STUBBED_VALUE,
+      ),
+    TypeError,
+    'Cannot stub property "foo" because it is not configurable or writable.',
+  );
+
+  assertThrows(
+    () =>
+      stubProperty(
+        Object.freeze({ [PROP]: ORIGINAL_VALUE } as Obj),
+        PROP,
+        STUBBED_VALUE,
+      ),
+    TypeError,
+    'Cannot stub property "foo" because it is not configurable or writable.',
+  );
+});