@ecopages/file-system 0.2.0-alpha.0 → 0.2.0-alpha.2

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+All notable changes to `@ecopages/file-system` are documented here.
+
+> **Note:** Changelog tracking begins at version `0.2.0`. Changes prior to this release are not recorded here but are available in the git history.
+
+## [UNRELEASED] — TBD
+
+### Refactoring
+
+- `package.json` updated to add `fs` as an explicit peer dependency, reflecting the package's role in the runtime-agnostic file abstraction layer used by the Node adapter.

package/package.json

@@ -1,60 +1,59 @@
 {
-	"name": "@ecopages/file-system",
-	"version": "0.2.0-alpha.0",
-	"description": "Runtime-agnostic file system utilities for Ecopages with Bun and Node adapters",
-	"keywords": [
-		"ecopages",
-		"fs",
-		"file-system",
-		"bun",
-		"node"
-	],
-	"license": "MIT",
-	"main": "./src/index.ts",
-	"type": "module",
-	"files": [
-		"src"
-	],
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/ecopages/ecopages.git",
-		"directory": "packages/file-system"
-	},
-	"scripts": {
-		"typecheck": "tsc --noEmit",
-		"test": "bun test",
-		"benchmark": "bun run test/benchmark.ts",
-		"release:jsr": "bunx jsr publish"
-	},
-	"exports": {
-		".": {
-			"import": "./src/index.ts",
-			"require": "./src/index.ts",
-			"types": "./src/types.ts"
-		},
-		"./bun": {
-			"import": "./src/adapters/bun.ts",
-			"types": "./src/adapters/bun.ts"
-		},
-		"./node": {
-			"import": "./src/adapters/node.ts",
-			"types": "./src/adapters/node.ts"
-		}
-	},
-	"dependencies": {
-		"fast-glob": "^3.3.2"
-	},
-	"devDependencies": {
-		"@types/bun": "^1.3.9",
-		"@types/node": "^24",
-		"mitata": "^1.0.34"
-	},
-	"peerDependencies": {
-		"bun": ">=1.0.0"
-	},
-	"peerDependenciesMeta": {
-		"bun": {
-			"optional": true
-		}
-	}
+  "name": "@ecopages/file-system",
+  "version": "0.2.0-alpha.2",
+  "description": "Runtime-agnostic file system utilities for Ecopages with Bun and Node adapters",
+  "keywords": [
+    "ecopages",
+    "fs",
+    "file-system",
+    "bun",
+    "node"
+  ],
+  "license": "MIT",
+  "main": "./src/index.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ecopages/ecopages.git",
+    "directory": "packages/file-system"
+  },
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "types": "./src/types.d.ts",
+      "default": "./src/index.js"
+    },
+    "./bun": {
+      "import": "./src/adapters/bun.js",
+      "types": "./src/adapters/bun.d.ts",
+      "default": "./src/adapters/bun.js"
+    },
+    "./node": {
+      "import": "./src/adapters/node.js",
+      "types": "./src/adapters/node.d.ts",
+      "default": "./src/adapters/node.js"
+    },
+    "./bun.ts": {
+      "import": "./src/adapters/bun.js",
+      "types": "./src/adapters/bun.d.ts",
+      "default": "./src/adapters/bun.js"
+    },
+    "./node.ts": {
+      "import": "./src/adapters/node.js",
+      "types": "./src/adapters/node.d.ts",
+      "default": "./src/adapters/node.js"
+    }
+  },
+  "dependencies": {
+    "fast-glob": "^3.3.2"
+  },
+  "peerDependencies": {
+    "bun": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "bun": {
+      "optional": true
+    }
+  },
+  "types": "./src/types.d.ts"
 }

package/src/adapters/bun.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module @ecopages/file-system/adapters/bun
+ * @description Bun-optimized file system adapter using Bun.Glob, Bun.hash, and Bun.file.
+ */
+import type { FileSystem, GlobOptions } from '../types.js';
+import { BaseFileSystem } from '../utils/common.js';
+/**
+ * Bun-optimized implementation of the FileSystem interface.
+ */
+export declare class BunFileSystem extends BaseFileSystem implements FileSystem {
+    existsAsync(path: string): Promise<boolean>;
+    readFile(path: string): Promise<string>;
+    writeAsync(filepath: string, contents: string | Buffer): Promise<void>;
+    copyFileAsync(source: string, destination: string): Promise<void>;
+    glob(patterns: string[], options?: GlobOptions): Promise<string[]>;
+    hash(path: string): string;
+}
+/**
+ * Singleton instance for Bun runtime.
+ */
+export declare const bunFs: BunFileSystem;

package/src/adapters/bun.js

@@ -0,0 +1,63 @@
+import { dirname } from "node:path";
+import { BaseFileSystem } from "../utils/common.js";
+class BunFileSystem extends BaseFileSystem {
+  async existsAsync(path) {
+    return Bun.file(path).exists();
+  }
+  async readFile(path) {
+    try {
+      this.verifyFileExists(path);
+      return await Bun.file(path).text();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error reading file: ${path}, ${message}`);
+    }
+  }
+  async writeAsync(filepath, contents) {
+    try {
+      await this.ensureDirAsync(dirname(filepath));
+      await Bun.write(filepath, contents);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error writing file: ${filepath}. Cause: ${message}`);
+    }
+  }
+  async copyFileAsync(source, destination) {
+    try {
+      await Bun.write(destination, Bun.file(source));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error copying file: ${source} to ${destination}. Cause: ${message}`);
+    }
+  }
+  async glob(patterns, options = {}) {
+    const scanOptions = {
+      cwd: options.cwd ?? process.cwd()
+    };
+    const promises = patterns.map((pattern) => {
+      const glob = new Bun.Glob(pattern);
+      return Array.fromAsync(glob.scan(scanOptions));
+    });
+    const results = await Promise.all(promises);
+    let files = results.flat();
+    if (options.ignore?.length) {
+      const ignoreGlobs = options.ignore.map((pattern) => new Bun.Glob(pattern));
+      files = files.filter((file) => !ignoreGlobs.some((glob) => glob.match(file)));
+    }
+    return files;
+  }
+  hash(path) {
+    try {
+      const buffer = this.readFileAsBuffer(path);
+      return Bun.hash(buffer).toString();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error hashing file: ${path}. Cause: ${message}`);
+    }
+  }
+}
+const bunFs = new BunFileSystem();
+export {
+  BunFileSystem,
+  bunFs
+};

package/src/adapters/node.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module @ecopages/file-system/adapters/node
+ * @description Node.js file system adapter using fast-glob, crypto, and node:fs.
+ */
+import type { FileSystem, GlobOptions } from '../types.js';
+import { BaseFileSystem } from '../utils/common.js';
+/**
+ * Node.js implementation of the FileSystem interface.
+ */
+export declare class NodeFileSystem extends BaseFileSystem implements FileSystem {
+    existsAsync(filePath: string): Promise<boolean>;
+    readFile(path: string): Promise<string>;
+    writeAsync(filepath: string, contents: string | Buffer): Promise<void>;
+    copyFileAsync(source: string, destination: string): Promise<void>;
+    glob(patterns: string[], options?: GlobOptions): Promise<string[]>;
+    hash(path: string): string;
+}
+/**
+ * Singleton instance for Node.js runtime.
+ */
+export declare const nodeFs: NodeFileSystem;

package/src/adapters/node.js

@@ -0,0 +1,62 @@
+import crypto from "node:crypto";
+import {
+  access as accessAsync,
+  cp as cpAsync,
+  readFile as readFileAsync,
+  writeFile as writeFileAsync
+} from "node:fs/promises";
+import { dirname } from "node:path";
+import fg from "fast-glob";
+import { BaseFileSystem } from "../utils/common.js";
+class NodeFileSystem extends BaseFileSystem {
+  async existsAsync(filePath) {
+    try {
+      await accessAsync(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async readFile(path) {
+    try {
+      this.verifyFileExists(path);
+      return await readFileAsync(path, "utf-8");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error reading file: ${path}, ${message}`);
+    }
+  }
+  async writeAsync(filepath, contents) {
+    try {
+      await this.ensureDirAsync(dirname(filepath));
+      await writeFileAsync(filepath, contents);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error writing file: ${filepath}. Cause: ${message}`);
+    }
+  }
+  async copyFileAsync(source, destination) {
+    await cpAsync(source, destination);
+  }
+  async glob(patterns, options = {}) {
+    return fg(patterns, {
+      cwd: options.cwd ?? process.cwd(),
+      ignore: options.ignore,
+      ...options
+    });
+  }
+  hash(path) {
+    try {
+      const buffer = this.readFileAsBuffer(path);
+      return crypto.createHash("sha256").update(buffer).digest("hex");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error hashing file: ${path}. Cause: ${message}`);
+    }
+  }
+}
+const nodeFs = new NodeFileSystem();
+export {
+  NodeFileSystem,
+  nodeFs
+};

package/src/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @module @ecopages/file-system
+ * @description Runtime-agnostic file system utilities for Ecopages.
+ *
+ * Automatically selects the optimal adapter based on runtime:
+ * - **Bun**: Uses `Bun.Glob`, `Bun.hash`, `Bun.file` for maximum performance
+ * - **Node.js**: Uses `fast-glob` and `crypto` for compatibility
+ *
+ * @example
+ * ```typescript
+ * import { fileSystem } from '@ecopages/file-system';
+ *
+ * const files = await fileSystem.glob(['**\/*.ts']);
+ * const content = await fileSystem.readFile('file.txt');
+ */
+export * from './types.js';
+export { BaseFileSystem } from './utils/common.js';
+export { BunFileSystem, bunFs } from './adapters/bun.js';
+export { NodeFileSystem, nodeFs } from './adapters/node.js';
+import type { FileSystem } from './types.js';
+/**
+ * Runtime-agnostic file system instance.
+ * Automatically uses Bun or Node adapter based on environment.
+ */
+export declare const fileSystem: FileSystem;

package/src/index.js

@@ -0,0 +1,21 @@
+export * from "./types.js";
+import { BaseFileSystem } from "./utils/common.js";
+import { BunFileSystem, bunFs } from "./adapters/bun.js";
+import { NodeFileSystem, nodeFs } from "./adapters/node.js";
+async function createFileSystem() {
+  if (typeof Bun !== "undefined") {
+    const { bunFs: bunFs2 } = await import("./adapters/bun.js");
+    return bunFs2;
+  }
+  const { nodeFs: nodeFs2 } = await import("./adapters/node.js");
+  return nodeFs2;
+}
+const fileSystem = await createFileSystem();
+export {
+  BaseFileSystem,
+  BunFileSystem,
+  NodeFileSystem,
+  bunFs,
+  fileSystem,
+  nodeFs
+};

package/src/types.d.ts

@@ -0,0 +1,158 @@
+/**
+ * @module @ecopages/file-system/types
+ * @description Type definitions for runtime-agnostic file system operations.
+ */
+/**
+ * Options for glob pattern matching.
+ */
+export interface GlobOptions {
+    /** Working directory for glob patterns */
+    cwd?: string;
+    /** Patterns to ignore */
+    ignore?: string[];
+}
+/**
+ * Runtime-agnostic file system interface.
+ * Implementations exist for Bun (optimized) and Node.js (fallback).
+ */
+export interface FileSystem {
+    /**
+     * Scan the file system for files matching glob patterns.
+     * @param patterns - Glob patterns to match
+     * @param options - Glob options
+     */
+    glob(patterns: string[], options?: GlobOptions): Promise<string[]>;
+    /**
+     * Read a file as a string asynchronously.
+     * @param path - Path to the file
+     */
+    readFile(path: string): Promise<string>;
+    /**
+     * Read a file as a string synchronously.
+     * @param path - Path to the file
+     */
+    readFileSync(path: string): string;
+    /**
+     * Read a file as a Buffer.
+     * @param path - Path to the file
+     */
+    readFileAsBuffer(path: string): Buffer;
+    /**
+     * Write contents to a file synchronously.
+     * Creates parent directories if they don't exist.
+     * @param filepath - Path to write to
+     * @param contents - Content to write
+     */
+    write(filepath: string, contents: string | Buffer): void;
+    /**
+     * Write contents to a file asynchronously.
+     * @param filepath - Path to write to
+     * @param contents - Content to write
+     */
+    writeAsync(filepath: string, contents: string | Buffer): Promise<void>;
+    /**
+     * Ensure a directory exists, optionally cleaning it first.
+     * @param dirPath - Directory path
+     * @param forceCleanup - If true, remove existing directory first
+     */
+    ensureDir(dirPath: string, forceCleanup?: boolean): void;
+    /**
+     * Ensure a directory exists asynchronously, optionally cleaning it first.
+     * @param dirPath - Directory path
+     * @param forceCleanup - If true, remove existing directory first
+     */
+    ensureDirAsync(dirPath: string, forceCleanup?: boolean): Promise<void>;
+    /**
+     * Copy a directory recursively.
+     * @param source - Source directory
+     * @param destination - Destination directory
+     */
+    copyDir(source: string, destination: string): void;
+    /**
+     * Copy a directory recursively asynchronously.
+     * @param source - Source directory
+     * @param destination - Destination directory
+     */
+    copyDirAsync(source: string, destination: string): Promise<void>;
+    /**
+     * Remove all contents of a directory.
+     * @param path - Directory path
+     */
+    emptyDir(path: string): void;
+    /**
+     * Remove all contents of a directory asynchronously.
+     * @param path - Directory path
+     */
+    emptyDirAsync(path: string): Promise<void>;
+    /**
+     * Check if a path is a directory.
+     * @param path - Path to check
+     */
+    isDirectory(path: string): boolean;
+    /**
+     * Check if a path is a directory asynchronously.
+     * @param path - Path to check
+     */
+    isDirectoryAsync(path: string): Promise<boolean>;
+    /**
+     * Check if a file or directory exists.
+     * @param path - Path to check
+     */
+    exists(path: string): boolean;
+    /**
+     * Check if a file or directory exists asynchronously.
+     * @param path - Path to check
+     */
+    existsAsync(path: string): Promise<boolean>;
+    /**
+     * Copy a file.
+     * @param source - Source file path
+     * @param destination - Destination file path
+     */
+    copyFile(source: string, destination: string): void;
+    /**
+     * Copy a file asynchronously.
+     * @param source - Source file path
+     * @param destination - Destination file path
+     */
+    copyFileAsync(source: string, destination: string): Promise<void>;
+    /**
+     * Remove a file or directory synchronously.
+     * @param path - Path to remove
+     */
+    remove(path: string): void;
+    /**
+     * Remove a file or directory asynchronously.
+     * @param path - Path to remove
+     */
+    removeAsync(path: string): Promise<void>;
+    /**
+     * Get a hash of a file's contents.
+     * @param path - Path to the file
+     */
+    hash(path: string): string;
+    /**
+     * Gzip a single file.
+     * @param path - Path to the file
+     */
+    gzipFile(path: string): void;
+    /**
+     * Gzip all files with specified extensions in a directory.
+     * @param path - Directory path
+     * @param extensions - File extensions to gzip (without dot)
+     */
+    gzipDir(path: string, extensions: string[]): void;
+    /**
+     * Verify that a file exists, throw FileNotFoundError if not.
+     * @param path - Path to verify
+     * @throws FileNotFoundError
+     */
+    verifyFileExists(path: string): void;
+}
+/**
+ * Error thrown when a file is not found.
+ */
+export declare class FileNotFoundError extends Error {
+    code: string;
+    constructor(path: string);
+}

package/src/types.js

@@ -0,0 +1,10 @@
+class FileNotFoundError extends Error {
+  code = "ENOENT";
+  constructor(path) {
+    super(`File: ${path} not found`);
+    this.name = "FileNotFoundError";
+  }
+}
+export {
+  FileNotFoundError
+};

package/src/utils/common.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @module @ecopages/file-system/utils/common
+ * @description Shared utilities used by both Bun and Node adapters.
+ */
+import { type GlobOptions } from '../types.js';
+/**
+ * Base implementation for file system operations.
+ * Subclasses override specific methods with runtime-optimized versions.
+ */
+export declare abstract class BaseFileSystem {
+    /**
+     * Check if a file or directory exists.
+     */
+    exists(filePath: string): boolean;
+    /**
+     * Verify that a file exists, throw FileNotFoundError if not.
+     */
+    verifyFileExists(filePath: string): void;
+    /**
+     * Read a file as a string synchronously.
+     */
+    readFileSync(filePath: string): string;
+    /**
+     * Read a file as a Buffer.
+     */
+    readFileAsBuffer(filePath: string): Buffer;
+    /**
+     * Write contents to a file synchronously.
+     */
+    write(filepath: string, contents: string | Buffer): void;
+    /**
+     * Ensure a directory exists.
+     */
+    ensureDir(dirPath: string, forceCleanup?: boolean): void;
+    /**
+     * Ensure a directory exists asynchronously.
+     */
+    ensureDirAsync(dirPath: string, forceCleanup?: boolean): Promise<void>;
+    /**
+     * Copy a directory recursively.
+     */
+    copyDir(source: string, destination: string): void;
+    /**
+     * Copy a directory recursively asynchronously.
+     */
+    copyDirAsync(source: string, destination: string): Promise<void>;
+    /**
+     * Copy a file.
+     */
+    copyFile(source: string, destination: string): void;
+    /**
+     * Remove all contents of a directory.
+     */
+    emptyDir(dirPath: string): void;
+    /**
+     * Remove a directory's contents asynchronously.
+     */
+    emptyDirAsync(dirPath: string): Promise<void>;
+    /**
+     * Remove a file or directory synchronously.
+     */
+    remove(filePath: string): void;
+    /**
+     * Remove a file or directory asynchronously.
+     */
+    removeAsync(filePath: string): Promise<void>;
+    /**
+     * Check if a path is a directory.
+     */
+    isDirectory(filePath: string): boolean;
+    /**
+     * Check if a path is a directory asynchronously.
+     */
+    isDirectoryAsync(filePath: string): Promise<boolean>;
+    /**
+     * Gzip a single file.
+     */
+    gzipFile(filePath: string): void;
+    /**
+     * Gzip all files with specified extensions in a directory.
+     */
+    gzipDir(dirPath: string, extensionsToGzip: string[]): void;
+    /**
+     * Glob patterns - must be implemented by runtime-specific adapters.
+     */
+    abstract glob(patterns: string[], options?: GlobOptions): Promise<string[]>;
+    /**
+     * Read file async - must be implemented by runtime-specific adapters.
+     */
+    abstract readFile(path: string): Promise<string>;
+    /**
+     * Write file async - must be implemented by runtime-specific adapters.
+     */
+    abstract writeAsync(filepath: string, contents: string | Buffer): Promise<void>;
+    /**
+     * Check if a file exists asynchronously - must be implemented by runtime-specific adapters.
+     */
+    abstract existsAsync(filePath: string): Promise<boolean>;
+    /**
+     * Copy a file asynchronously - must be implemented by runtime-specific adapters.
+     */
+    abstract copyFileAsync(source: string, destination: string): Promise<void>;
+    /**
+     * Hash file - must be implemented by runtime-specific adapters.
+     */
+    abstract hash(path: string): string;
+}

package/src/utils/common.js

@@ -0,0 +1,169 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { cp as cpAsync, mkdir as mkdirAsync, readdir, rm as rmAsync, stat as statAsync } from "node:fs/promises";
+import { dirname, extname, join as pathJoin } from "node:path";
+import zlib from "node:zlib";
+import { FileNotFoundError } from "../types.js";
+class BaseFileSystem {
+  /**
+   * Check if a file or directory exists.
+   */
+  exists(filePath) {
+    return existsSync(filePath);
+  }
+  /**
+   * Verify that a file exists, throw FileNotFoundError if not.
+   */
+  verifyFileExists(filePath) {
+    if (!this.exists(filePath)) {
+      throw new FileNotFoundError(filePath);
+    }
+  }
+  /**
+   * Read a file as a string synchronously.
+   */
+  readFileSync(filePath) {
+    try {
+      return readFileSync(filePath, "utf-8");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error reading file: ${filePath}, ${message}`, { cause: error });
+    }
+  }
+  /**
+   * Read a file as a Buffer.
+   */
+  readFileAsBuffer(filePath) {
+    try {
+      return readFileSync(filePath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error reading file: ${filePath}, ${message}`, { cause: error });
+    }
+  }
+  /**
+   * Write contents to a file synchronously.
+   */
+  write(filepath, contents) {
+    try {
+      this.ensureDir(dirname(filepath));
+      writeFileSync(filepath, contents);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error writing file: ${filepath}. Cause: ${message}`);
+    }
+  }
+  /**
+   * Ensure a directory exists.
+   */
+  ensureDir(dirPath, forceCleanup) {
+    if (forceCleanup && existsSync(dirPath)) {
+      rmSync(dirPath, { recursive: true, force: true });
+    }
+    mkdirSync(dirPath, { recursive: true });
+  }
+  /**
+   * Ensure a directory exists asynchronously.
+   */
+  async ensureDirAsync(dirPath, forceCleanup) {
+    if (forceCleanup && await this.existsAsync(dirPath)) {
+      await rmAsync(dirPath, { recursive: true, force: true });
+    }
+    await mkdirAsync(dirPath, { recursive: true });
+  }
+  /**
+   * Copy a directory recursively.
+   */
+  copyDir(source, destination) {
+    cpSync(source, destination, { recursive: true });
+  }
+  /**
+   * Copy a directory recursively asynchronously.
+   */
+  async copyDirAsync(source, destination) {
+    await cpAsync(source, destination, { recursive: true });
+  }
+  /**
+   * Copy a file.
+   */
+  copyFile(source, destination) {
+    cpSync(source, destination);
+  }
+  /**
+   * Remove all contents of a directory.
+   */
+  emptyDir(dirPath) {
+    if (!this.isDirectory(dirPath)) {
+      return;
+    }
+    const entries = readdirSync(dirPath);
+    for (const entry of entries) {
+      const fullPath = pathJoin(dirPath, entry);
+      rmSync(fullPath, { recursive: true, force: true });
+    }
+  }
+  /**
+   * Remove a directory's contents asynchronously.
+   */
+  async emptyDirAsync(dirPath) {
+    if (!await this.isDirectoryAsync(dirPath)) {
+      return;
+    }
+    const entries = await readdir(dirPath);
+    await Promise.all(entries.map((entry) => rmAsync(pathJoin(dirPath, entry), { recursive: true, force: true })));
+  }
+  /**
+   * Remove a file or directory synchronously.
+   */
+  remove(filePath) {
+    rmSync(filePath, { recursive: true, force: true });
+  }
+  /**
+   * Remove a file or directory asynchronously.
+   */
+  async removeAsync(filePath) {
+    await rmAsync(filePath, { recursive: true, force: true });
+  }
+  /**
+   * Check if a path is a directory.
+   */
+  isDirectory(filePath) {
+    return existsSync(filePath) && statSync(filePath).isDirectory();
+  }
+  /**
+   * Check if a path is a directory asynchronously.
+   */
+  async isDirectoryAsync(filePath) {
+    try {
+      const stats = await statAsync(filePath);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Gzip a single file.
+   */
+  gzipFile(filePath) {
+    const data = this.readFileAsBuffer(filePath);
+    const compressedData = zlib.gzipSync(Buffer.from(data));
+    const gzipFile = `${filePath}.gz`;
+    writeFileSync(gzipFile, compressedData);
+  }
+  /**
+   * Gzip all files with specified extensions in a directory.
+   */
+  gzipDir(dirPath, extensionsToGzip) {
+    const entries = readdirSync(dirPath, { recursive: true, withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const ext = extname(entry.name).slice(1);
+        if (extensionsToGzip.includes(ext)) {
+          this.gzipFile(pathJoin(entry.parentPath, entry.name));
+        }
+      }
+    }
+  }
+}
+export {
+  BaseFileSystem
+};