feat: migrate glob implementation to use Node's built-in glob functionality

GoodbyeNJN · GoodbyeNJN · commit f05a1b023662 · 2026-06-15T18:21:35.000+08:00
diff --git a/src/fs/safe/glob.ts b/src/fs/safe/glob.ts
@@ -0,0 +1,23 @@
+import { Result } from "@/result";
+
+import { glob as unsafeGlob, globSync as unsafeGlobSync } from "../unsafe/glob";
+
+import type { Glob as UnsafeGlob, GlobSync as UnsafeGlobSync } from "../unsafe/glob";
+import type { SetReturnType } from "@/types";
+
+export type {
+    GlobOptions,
+    GlobOptionsWithFileTypes,
+    GlobOptionsWithoutFileTypes,
+} from "../unsafe/glob";
+
+export type Glob = SetReturnType<UnsafeGlob, Promise<Result<Awaited<ReturnType<UnsafeGlob>>>>>;
+export type GlobSync = SetReturnType<UnsafeGlobSync, Result<ReturnType<UnsafeGlobSync>>>;
+
+const safeGlob = /* #__PURE__ */ Result.wrap(unsafeGlob, Error);
+export const glob: Glob = async (...args: [any]) =>
+    (await safeGlob(...args)).context("Failed to perform glob operation");
+
+const safeGlobSync = /* #__PURE__ */ Result.wrap(unsafeGlobSync, Error);
+export const globSync: GlobSync = (...args: [any]) =>
+    safeGlobSync(...args).context("Failed to perform glob operation");
diff --git a/src/fs/unsafe/glob.ts b/src/fs/unsafe/glob.ts
@@ -0,0 +1,156 @@
+import fs, { promises as fsp } from "node:fs";
+import path from "node:path";
+import url from "node:url";
+
+import { isArray, isString, omit } from "@/fp";
+
+import type {
+    Dirent,
+    GlobOptions as NodeGlobOptions,
+    GlobOptionsWithFileTypes as NodeGlobOptionsWithFileTypes,
+    GlobOptionsWithoutFileTypes as NodeGlobOptionsWithoutFileTypes,
+} from "node:fs";
+
+interface BaseGlobOptions {
+    patterns: string | string[];
+
+    /**
+     * Return absolute paths in the results.
+     *
+     * @default false
+     */
+    absolute?: boolean;
+    /**
+     * Include files in the results.
+     *
+     * @default true
+     */
+    includeFiles?: boolean;
+    /**
+     * Include directories in the results.
+     *
+     * @default false
+     */
+    includeDirectories?: boolean;
+}
+
+export interface GlobOptions extends BaseGlobOptions, NodeGlobOptions {}
+
+export interface GlobOptionsWithFileTypes extends BaseGlobOptions, NodeGlobOptionsWithFileTypes {}
+
+export interface GlobOptionsWithoutFileTypes
+    extends BaseGlobOptions, NodeGlobOptionsWithoutFileTypes {}
+
+export type Glob = {
+    (
+        patterns: GlobOptionsWithFileTypes["patterns"],
+        options?: Omit<GlobOptionsWithFileTypes, "patterns">,
+    ): Promise<Dirent[]>;
+    (
+        patterns: GlobOptionsWithoutFileTypes["patterns"],
+        options?: Omit<GlobOptionsWithoutFileTypes, "patterns">,
+    ): Promise<string[]>;
+    (
+        patterns: GlobOptions["patterns"],
+        options?: Omit<GlobOptions, "patterns">,
+    ): Promise<(Dirent | string)[]>;
+    (options: GlobOptionsWithFileTypes): Promise<Dirent[]>;
+    (options: GlobOptionsWithoutFileTypes): Promise<string[]>;
+    (options: GlobOptions): Promise<(Dirent | string)[]>;
+};
+
+export type GlobSync = {
+    (
+        patterns: GlobOptionsWithFileTypes["patterns"],
+        options?: Omit<GlobOptionsWithFileTypes, "patterns">,
+    ): Dirent[];
+    (
+        patterns: GlobOptionsWithoutFileTypes["patterns"],
+        options?: Omit<GlobOptionsWithoutFileTypes, "patterns">,
+    ): string[];
+    (
+        patterns: GlobOptions["patterns"],
+        options?: Omit<GlobOptions, "patterns">,
+    ): (Dirent | string)[];
+    (options: GlobOptionsWithFileTypes): Dirent[];
+    (options: GlobOptionsWithoutFileTypes): string[];
+    (options: GlobOptions): (Dirent | string)[];
+};
+
+const normalizeArgs = (
+    patternsOrOptions: string | string[] | GlobOptions,
+    maybeOptions?: Omit<GlobOptions, "patterns">,
+) => {
+    const patternsAsArgument = isString(patternsOrOptions) || isArray(patternsOrOptions);
+
+    const patterns = patternsAsArgument ? patternsOrOptions : patternsOrOptions.patterns;
+    const options = patternsAsArgument ? maybeOptions || {} : omit(patternsOrOptions, ["patterns"]);
+
+    if (options.includeFiles === undefined && options.includeDirectories === undefined) {
+        options.includeFiles = true;
+        options.includeDirectories = false;
+    } else if (options.includeFiles === undefined) {
+        options.includeFiles = !options.includeDirectories;
+    } else if (options.includeDirectories === undefined) {
+        options.includeDirectories = !options.includeFiles;
+    }
+
+    return { patterns, options };
+};
+
+const processEntries = (entries: Dirent[], options: Omit<GlobOptions, "patterns">) => {
+    const result = entries.filter(
+        entry =>
+            (options.includeFiles && entry.isFile()) ||
+            (options.includeDirectories && entry.isDirectory()) ||
+            (!options.includeFiles && !options.includeDirectories),
+    );
+
+    if (options.absolute) {
+        const cwd =
+            (options.cwd instanceof URL ? url.fileURLToPath(options.cwd) : options.cwd) ??
+            process.cwd();
+
+        if (!options.withFileTypes) {
+            return result.map(entry => path.resolve(cwd, entry.parentPath, entry.name));
+        } else {
+            for (const entry of entries) {
+                entry.parentPath = path.resolve(cwd, entry.parentPath);
+            }
+
+            return result;
+        }
+    }
+
+    if (!options.withFileTypes) {
+        return result.map(entry => path.join(entry.parentPath, entry.name));
+    }
+
+    return result;
+};
+
+/* #__NO_SIDE_EFFECTS__ */
+export const glob: Glob = async (...args: [any, any?]): Promise<any[]> => {
+    const { patterns, options } = normalizeArgs(...args);
+
+    const entries = await Array.fromAsync(
+        fsp.glob(patterns, {
+            ...options,
+            withFileTypes: true,
+        }),
+    );
+
+    return processEntries(entries, options);
+};
+
+/* #__NO_SIDE_EFFECTS__ */
+export const globSync: GlobSync = (...args: [any, any?]): any[] => {
+    const { patterns, options } = normalizeArgs(...args);
+
+    const entries = fs.globSync(patterns, {
+        ...options,
+        withFileTypes: true,
+    });
+
+    return processEntries(entries, options);
+};
diff --git a/src/glob/index.ts b/src/glob/index.ts
