file-entry-cache 10.1.4 → 11.0.0-beta.1

package/README.md

@@ -15,8 +15,8 @@
 - Ideal for processes that work on a specific set of files
 - Persists cache to Disk via `reconcile()` or `persistInterval` on `cache` options.
 - Uses `checksum` to determine if a file has changed
-- Supports `relative` and `absolute` paths
-- Ability to rename keys in the cache. Useful when renaming directories.
+- Supports `relative` and `absolute` paths - paths are stored exactly as provided
+- Portable cache files when using relative paths
 - ESM and CommonJS support with Typescript
 
 # Table of Contents
@@ -43,24 +43,30 @@ npm install file-entry-cache
 ```javascript
 import fileEntryCache from 'file-entry-cache';
 const cache = fileEntryCache.create('cache1');
-let fileDescriptor = cache.getFileDescriptor('file.txt');
+
+// Using relative paths
+let fileDescriptor = cache.getFileDescriptor('./src/file.txt');
 console.log(fileDescriptor.changed); // true as it is the first time
-fileDescriptor = cache.getFileDescriptor('file.txt');
+console.log(fileDescriptor.key); // './src/file.txt' (stored as provided)
+
+fileDescriptor = cache.getFileDescriptor('./src/file.txt');
 console.log(fileDescriptor.changed); // false as it has not changed
+
 // do something to change the file
-fs.writeFileSync('file.txt', 'new data foo bar');
+fs.writeFileSync('./src/file.txt', 'new data foo bar');
+
 // check if the file has changed
-fileDescriptor = cache.getFileDescriptor('file.txt');
+fileDescriptor = cache.getFileDescriptor('./src/file.txt');
 console.log(fileDescriptor.changed); // true
 ```
 
-Save it to Disk and Reconsile files that are no longer found
+Save it to Disk and Reconcile files that are no longer found
 ```javascript
 import fileEntryCache from 'file-entry-cache';
 const cache = fileEntryCache.create('cache1');
-let fileDescriptor = cache.getFileDescriptor('file.txt');
+let fileDescriptor = cache.getFileDescriptor('./src/file.txt');
 console.log(fileDescriptor.changed); // true as it is the first time
-fileEntryCache.reconcile(); // save the cache to disk and remove files that are no longer found
+cache.reconcile(); // save the cache to disk and remove files that are no longer found
 ```
 
 Load the cache from a file:
@@ -68,30 +74,63 @@ Load the cache from a file:
 ```javascript
 import fileEntryCache from 'file-entry-cache';
 const cache = fileEntryCache.createFromFile('/path/to/cache/file');
-let fileDescriptor = cache.getFileDescriptor('file.txt');
+let fileDescriptor = cache.getFileDescriptor('./src/file.txt');
 console.log(fileDescriptor.changed); // false as it has not changed from the saved cache.
 ```
 
+## Migration Guide from v10 to v11
+
+The main breaking change is the removal of `currentWorkingDirectory`. Here's how to update your code:
+
+**Before (v10):**
+```javascript
+const cache = new FileEntryCache({
+  currentWorkingDirectory: '/project/root'
+});
+// This would store the key as 'src/file.js'
+cache.getFileDescriptor('/project/root/src/file.js');
+```
+
+**After (v11):**
+```javascript
+const cache = new FileEntryCache();
+// Now stores the key exactly as provided
+cache.getFileDescriptor('./src/file.js');  // Key: './src/file.js'
+cache.getFileDescriptor('/project/root/src/file.js'); // Key: '/project/root/src/file.js'
+```
+
+If you were using absolute paths with `currentWorkingDirectory`, you'll need to update your code to use relative paths if you want portable cache files.
+
+# Changes from v10 to v11
+
+**BREAKING CHANGES:**
+- **Removed `currentWorkingDirectory`** - This option has been completely removed from the API. Paths are now stored exactly as provided (relative or absolute).
+- **Path handling changes** - The cache now stores paths exactly as they are provided:
+  - Relative paths remain relative in the cache
+  - Absolute paths remain absolute in the cache
+  - The same file accessed with different path formats will create separate cache entries
+- **Renamed method** - `renameAbsolutePathKeys()` is now `renameCacheKeys()` to reflect that it works with any path format
+- **Simplified API** - Removed `currentWorkingDirectory` parameter from all methods including `getFileDescriptor()`, `removeEntry()`, and factory functions
+
+These changes make cache files portable when using relative paths, and simplify the API by removing path manipulation logic.
+
 # Changes from v9 to v10
 
 There have been many features added and changes made to the `file-entry-cache` class. Here are the main changes:
 - Added `cache` object to the options to allow for more control over the cache
-- Added `hashAlgorithm` to the options to allow for different checksum algorithms. Note that if you load from file it most likely will break if the value was something before. 
-- Updated more on using Relative or Absolute paths. We now support both on `getFileDescriptor()`. You can read more on this in the `Get File Descriptor` section.
+- Added `hashAlgorithm` to the options to allow for different checksum algorithms. Note that if you load from file it most likely will break if the value was something before.
 - Migrated to Typescript with ESM and CommonJS support. This allows for better type checking and support for both ESM and CommonJS.
-- Once options are passed in they get assigned as properties such as `hashAlgorithm` and `currentWorkingDirectory`. This allows for better control and access to the options. For the Cache options they are assigned to `cache` such as `cache.ttl` and `cache.lruSize`.
+- Once options are passed in they get assigned as properties such as `hashAlgorithm`. For the Cache options they are assigned to `cache` such as `cache.ttl` and `cache.lruSize`.
 - Added `cache.persistInterval` to allow for saving the cache to disk at a specific interval. This will save the cache to disk at the interval specified instead of calling `reconsile()` to save. (`off` by default)
 - Added `getFileDescriptorsByPath(filePath: string): FileEntryDescriptor[]` to get all the file descriptors that start with the path specified. This is useful when you want to get all the files in a directory or a specific path.
-- Added `renameAbsolutePathKeys(oldPath: string, newPath: string): void` will rename the keys in the cache from the old path to the new path. This is useful when you rename a directory and want to update the cache without reanalyzing the files.
 - Using `flat-cache` v6 which is a major update. This allows for better performance and more control over the cache.
 - On `FileEntryDescriptor.meta` if using typescript you need to use the `meta.data` to set additional information. This is to allow for better type checking and to avoid conflicts with the `meta` object which was `any`.
 
 # Global Default Functions
-- `create(cacheId: string, cacheDirectory?: string, useCheckSum?: boolean, currentWorkingDirectory?: string)` - Creates a new instance of the `FileEntryCache` class
-- `createFromFile(cachePath: string, useCheckSum?: boolean, currentWorkingDirectory?: string)` - Creates a new instance of the `FileEntryCache` class and loads the cache from a file.
+- `create(cacheId: string, cacheDirectory?: string, useCheckSum?: boolean)` - Creates a new instance of the `FileEntryCache` class
+- `createFromFile(cachePath: string, useCheckSum?: boolean)` - Creates a new instance of the `FileEntryCache` class and loads the cache from a file.
 
 # FileEntryCache Options (FileEntryCacheOptions)
-- `currentWorkingDirectory?` - The current working directory. Used when resolving relative paths.
 - `useModifiedTime?` - If `true` it will use the modified time to determine if the file has changed. Default is `true`
 - `useCheckSum?` - If `true` it will use a checksum to determine if the file has changed. Default is `false`
 - `hashAlgorithm?` - The algorithm to use for the checksum. Default is `md5` but can be any algorithm supported by `crypto.createHash`
@@ -110,49 +149,53 @@ There have been many features added and changes made to the `file-entry-cache` c
 - `constructor(options?: FileEntryCacheOptions)` - Creates a new instance of the `FileEntryCache` class
 - `useCheckSum: boolean` - If `true` it will use a checksum to determine if the file has changed. Default is `false`
 - `hashAlgorithm: string` - The algorithm to use for the checksum. Default is `md5` but can be any algorithm supported by `crypto.createHash`
-- `currentWorkingDirectory: string` - The current working directory. Used when resolving relative paths.
 - `getHash(buffer: Buffer): string` - Gets the hash of a buffer used for checksums
-- `createFileKey(filePath: string): string` - Creates a key for the file path. This is used to store the data in the cache based on relative or absolute paths.
-- `deleteCacheFile(filePath: string): void` - Deletes the cache file
-- `destroy(): void` - Destroys the cache. This will also delete the cache file. If using cache persistence it will stop the interval.
-- `removeEntry(filePath: string): void` - Removes an entry from the cache. This can be `relative` or `absolute` paths.
+- `createFileKey(filePath: string): string` - Returns the cache key for the file path (returns the path exactly as provided).
+- `deleteCacheFile(): boolean` - Deletes the cache file from disk
+- `destroy(): void` - Destroys the cache. This will clear the cache in memory. If using cache persistence it will stop the interval.
+- `removeEntry(filePath: string): void` - Removes an entry from the cache using the exact path provided.
 - `reconcile(): void` - Saves the cache to disk and removes any files that are no longer found.
 - `hasFileChanged(filePath: string): boolean` - Checks if the file has changed. This will return `true` if the file has changed.
-- `getFileDescriptor(filePath: string, options?: { useModifiedTime?: boolean, useCheckSum?: boolean, currentWorkingDirectory?: string }): FileEntryDescriptor` - Gets the file descriptor for the file. Please refer to the entire section on `Get File Descriptor` for more information.
+- `getFileDescriptor(filePath: string, options?: { useModifiedTime?: boolean, useCheckSum?: boolean }): FileEntryDescriptor` - Gets the file descriptor for the file. Please refer to the entire section on `Get File Descriptor` for more information.
 - `normalizeEntries(entries: FileEntryDescriptor[]): FileEntryDescriptor[]` - Normalizes the entries to have the correct paths. This is used when loading the cache from disk.
 - `analyzeFiles(files: string[])` will return `AnalyzedFiles` object with `changedFiles`, `notFoundFiles`, and `notChangedFiles` as FileDescriptor arrays.
 - `getUpdatedFiles(files: string[])` will return an array of `FileEntryDescriptor` objects that have changed.
-- `getFileDescriptorsByPath(filePath: string): FileEntryDescriptor[]` will return an array of `FileEntryDescriptor` objects that starts with the path specified.
-- `renameAbsolutePathKeys(oldPath: string, newPath: string): void` - Renames the keys in the cache from the old path to the new path. This is useful when you rename a directory and want to update the cache without reanalyzing the files.
+- `getFileDescriptorsByPath(filePath: string): FileEntryDescriptor[]` will return an array of `FileEntryDescriptor` objects that starts with the path prefix specified.
 
 # Get File Descriptor
 
-The `getFileDescriptor(filePath: string, options?: { useCheckSum?: boolean, currentWorkingDirectory?: string }): FileEntryDescriptor` function is used to get the file descriptor for the file. This function will return a `FileEntryDescriptor` object that has the following properties:
+The `getFileDescriptor(filePath: string, options?: { useCheckSum?: boolean, useModifiedTime?: boolean }): FileEntryDescriptor` function is used to get the file descriptor for the file. This function will return a `FileEntryDescriptor` object that has the following properties:
 
-- `key: string` - The key for the file. This is the relative or absolute path of the file.
+- `key: string` - The cache key for the file. This is exactly the path that was provided (relative or absolute).
 - `changed: boolean` - If the file has changed since the last time it was analyzed.
 - `notFound: boolean` - If the file was not found.
-- `meta: FileEntryMeta` - The meta data for the file. This has the following prperties: `size`, `mtime`, `ctime`, `hash`, `data`. Note that `data` is an object that can be used to store additional information.
+- `meta: FileEntryMeta` - The meta data for the file. This has the following properties: `size`, `mtime`, `hash`, `data`. Note that `data` is an object that can be used to store additional information.
 - `err` - If there was an error analyzing the file.
 
-We have added the ability to use `relative` or `absolute` paths. If you pass in a `relative` path it will use the `currentWorkingDirectory` to resolve the path. If you pass in an `absolute` path it will use the path as is. This is useful when you want to use `relative` paths but also want to use `absolute` paths. 
+## Path Handling
 
-If you do not pass in `currentWorkingDirectory` in the class options or in the `getFileDescriptor` function it will use the `process.cwd()` as the default `currentWorkingDirectory`.
+The cache stores paths exactly as they are provided:
+
+- **Relative paths** remain relative in the cache
+- **Absolute paths** remain absolute in the cache
+- The same file accessed with different path formats creates **separate cache entries**
 
 ```javascript
 const fileEntryCache = new FileEntryCache();
-const fileDescriptor = fileEntryCache.getFileDescriptor('file.txt', { currentWorkingDirectory: '/path/to/directory' });
-```
 
-Since this is a relative path it will use the `currentWorkingDirectory` to resolve the path. If you want to use an absolute path you can do the following:
+// Using a relative path
+const relativeDescriptor = fileEntryCache.getFileDescriptor('./file.txt');
+console.log(relativeDescriptor.key); // './file.txt'
 
-```javascript
-const fileEntryCache = new FileEntryCache();
-const filePath = path.resolve('/path/to/directory', 'file.txt');
-const fileDescriptor = fileEntryCache.getFileDescriptor(filePath);
+// Using an absolute path
+const absolutePath = path.resolve('./file.txt');
+const absoluteDescriptor = fileEntryCache.getFileDescriptor(absolutePath);
+console.log(absoluteDescriptor.key); // '/full/path/to/file.txt'
+
+// These create two separate cache entries even though they refer to the same file
 ```
 
-This will save the key as the absolute path.
+This behavior makes cache files portable when using relative paths, as they will work correctly when the project is moved to a different location.
 
 If there is an error when trying to get the file descriptor it will return an ``notFound` and `err` property with the error.
 

package/dist/index.cjs

@@ -40,14 +40,13 @@ var import_node_crypto = __toESM(require("crypto"), 1);
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var import_flat_cache = require("flat-cache");
-function createFromFile(filePath, useCheckSum, currentWorkingDirectory) {
+function createFromFile(filePath, useCheckSum) {
   const fname = import_node_path.default.basename(filePath);
   const directory = import_node_path.default.dirname(filePath);
-  return create(fname, directory, useCheckSum, currentWorkingDirectory);
+  return create(fname, directory, useCheckSum);
 }
-function create(cacheId, cacheDirectory, useCheckSum, currentWorkingDirectory) {
+function create(cacheId, cacheDirectory, useCheckSum) {
   const options = {
-    currentWorkingDirectory,
     useCheckSum,
     cache: {
       cacheId,
@@ -71,7 +70,6 @@ var FileEntryCache = class {
   _cache = new import_flat_cache.FlatCache({ useClone: false });
   _useCheckSum = false;
   _useModifiedTime = true;
-  _currentWorkingDirectory;
   _hashAlgorithm = "md5";
   /**
    * Create a new FileEntryCache instance
@@ -87,9 +85,6 @@ var FileEntryCache = class {
     if (options?.useCheckSum) {
       this._useCheckSum = options.useCheckSum;
     }
-    if (options?.currentWorkingDirectory) {
-      this._currentWorkingDirectory = options.currentWorkingDirectory;
-    }
     if (options?.hashAlgorithm) {
       this._hashAlgorithm = options.hashAlgorithm;
     }
@@ -150,20 +145,6 @@ var FileEntryCache = class {
   set hashAlgorithm(value) {
     this._hashAlgorithm = value;
   }
-  /**
-   * Get the current working directory
-   * @returns {string | undefined} The current working directory
-   */
-  get currentWorkingDirectory() {
-    return this._currentWorkingDirectory;
-  }
-  /**
-   * Set the current working directory
-   * @param {string | undefined} value - The value to set
-   */
-  set currentWorkingDirectory(value) {
-    this._currentWorkingDirectory = value;
-  }
   /**
    * Given a buffer, calculate md5 hash of its content.
    * @method getHash
@@ -179,19 +160,8 @@ var FileEntryCache = class {
    * @param {String} filePath
    * @return {String}
    */
-  createFileKey(filePath, options) {
-    let result = filePath;
-    const currentWorkingDirectory = options?.currentWorkingDirectory ?? this._currentWorkingDirectory;
-    if (currentWorkingDirectory && filePath.startsWith(currentWorkingDirectory)) {
-      const splitPath = filePath.split(currentWorkingDirectory).pop();
-      if (splitPath) {
-        result = splitPath;
-        if (result.startsWith("/")) {
-          result = result.slice(1);
-        }
-      }
-    }
-    return result;
+  createFileKey(filePath) {
+    return filePath;
   }
   /**
    * Check if the file path is a relative path
@@ -222,16 +192,8 @@ var FileEntryCache = class {
    * @method removeEntry
    * @param filePath - The file path to remove from the cache
    */
-  removeEntry(filePath, options) {
-    if (this.isRelativePath(filePath)) {
-      filePath = this.getAbsolutePath(filePath, {
-        currentWorkingDirectory: options?.currentWorkingDirectory
-      });
-      this._cache.removeKey(this.createFileKey(filePath));
-    }
-    const key = this.createFileKey(filePath, {
-      currentWorkingDirectory: options?.currentWorkingDirectory
-    });
+  removeEntry(filePath) {
+    const key = this.createFileKey(filePath);
     this._cache.removeKey(key);
   }
   /**
@@ -277,19 +239,17 @@ var FileEntryCache = class {
       meta: {}
     };
     result.meta = this._cache.getKey(result.key) ?? {};
-    filePath = this.getAbsolutePath(filePath, {
-      currentWorkingDirectory: options?.currentWorkingDirectory
-    });
+    const absolutePath = this.getAbsolutePath(filePath);
     const useCheckSumValue = options?.useCheckSum ?? this._useCheckSum;
     const useModifiedTimeValue = options?.useModifiedTime ?? this._useModifiedTime;
     try {
-      fstat = import_node_fs.default.statSync(filePath);
+      fstat = import_node_fs.default.statSync(absolutePath);
       result.meta = {
         size: fstat.size
       };
       result.meta.mtime = fstat.mtime.getTime();
       if (useCheckSumValue) {
-        const buffer = import_node_fs.default.readFileSync(filePath);
+        const buffer = import_node_fs.default.readFileSync(absolutePath);
         result.meta.hash = this.getHash(buffer);
       }
     } catch (error) {
@@ -391,17 +351,16 @@ var FileEntryCache = class {
     return result;
   }
   /**
-   * Get the not found files
+   * Get the file descriptors by path prefix
    * @method getFileDescriptorsByPath
-   * @param filePath - the files that you want to get from a path
-   * @returns {FileDescriptor[]} The not found files
+   * @param filePath - the path prefix to match
+   * @returns {FileDescriptor[]} The file descriptors
    */
   getFileDescriptorsByPath(filePath) {
     const result = [];
     const keys = this._cache.keys();
     for (const key of keys) {
-      const absolutePath = this.getAbsolutePath(filePath);
-      if (absolutePath.startsWith(filePath)) {
+      if (key.startsWith(filePath)) {
         const fileDescriptor = this.getFileDescriptor(key);
         result.push(fileDescriptor);
       }
@@ -412,23 +371,21 @@ var FileEntryCache = class {
    * Get the Absolute Path. If it is already absolute it will return the path as is.
    * @method getAbsolutePath
    * @param filePath - The file path to get the absolute path for
-   * @param options - The options for getting the absolute path. The current working directory is used if not provided.
    * @returns {string}
    */
-  getAbsolutePath(filePath, options) {
+  getAbsolutePath(filePath) {
     if (this.isRelativePath(filePath)) {
-      const currentWorkingDirectory = options?.currentWorkingDirectory ?? this._currentWorkingDirectory ?? process.cwd();
-      filePath = import_node_path.default.resolve(currentWorkingDirectory, filePath);
+      return import_node_path.default.resolve(process.cwd(), filePath);
     }
     return filePath;
   }
   /**
-   * Rename the absolute path keys. This is used when a directory is changed or renamed.
-   * @method renameAbsolutePathKeys
-   * @param oldPath - The old path to rename
-   * @param newPath - The new path to rename to
+   * Rename cache keys that start with a given path prefix.
+   * @method renameCacheKeys
+   * @param oldPath - The old path prefix to rename
+   * @param newPath - The new path prefix to rename to
    */
-  renameAbsolutePathKeys(oldPath, newPath) {
+  renameCacheKeys(oldPath, newPath) {
     const keys = this._cache.keys();
     for (const key of keys) {
       if (key.startsWith(oldPath)) {

package/dist/index.d.cts

@@ -2,7 +2,6 @@ import { Buffer } from 'node:buffer';
 import { FlatCacheOptions, FlatCache } from 'flat-cache';
 
 type FileEntryCacheOptions = {
-    currentWorkingDirectory?: string;
     useModifiedTime?: boolean;
     useCheckSum?: boolean;
     hashAlgorithm?: string;
@@ -11,7 +10,6 @@ type FileEntryCacheOptions = {
 type GetFileDescriptorOptions = {
     useCheckSum?: boolean;
     useModifiedTime?: boolean;
-    currentWorkingDirectory?: string;
 };
 type FileDescriptor = {
     key: string;
@@ -31,8 +29,8 @@ type AnalyzedFiles = {
     notFoundFiles: string[];
     notChangedFiles: string[];
 };
-declare function createFromFile(filePath: string, useCheckSum?: boolean, currentWorkingDirectory?: string): FileEntryCache;
-declare function create(cacheId: string, cacheDirectory?: string, useCheckSum?: boolean, currentWorkingDirectory?: string): FileEntryCache;
+declare function createFromFile(filePath: string, useCheckSum?: boolean): FileEntryCache;
+declare function create(cacheId: string, cacheDirectory?: string, useCheckSum?: boolean): FileEntryCache;
 declare class FileEntryDefault {
     static create: typeof create;
     static createFromFile: typeof createFromFile;
@@ -41,7 +39,6 @@ declare class FileEntryCache {
     private _cache;
     private _useCheckSum;
     private _useModifiedTime;
-    private _currentWorkingDirectory;
     private _hashAlgorithm;
     /**
      * Create a new FileEntryCache instance
@@ -88,16 +85,6 @@ declare class FileEntryCache {
      * @param {string} value - The value to set
      */
     set hashAlgorithm(value: string);
-    /**
-     * Get the current working directory
-     * @returns {string | undefined} The current working directory
-     */
-    get currentWorkingDirectory(): string | undefined;
-    /**
-     * Set the current working directory
-     * @param {string | undefined} value - The value to set
-     */
-    set currentWorkingDirectory(value: string | undefined);
     /**
      * Given a buffer, calculate md5 hash of its content.
      * @method getHash
@@ -111,9 +98,7 @@ declare class FileEntryCache {
      * @param {String} filePath
      * @return {String}
      */
-    createFileKey(filePath: string, options?: {
-        currentWorkingDirectory?: string;
-    }): string;
+    createFileKey(filePath: string): string;
     /**
      * Check if the file path is a relative path
      * @method isRelativePath
@@ -137,9 +122,7 @@ declare class FileEntryCache {
      * @method removeEntry
      * @param filePath - The file path to remove from the cache
      */
-    removeEntry(filePath: string, options?: {
-        currentWorkingDirectory?: string;
-    }): void;
+    removeEntry(filePath: string): void;
     /**
      * Reconcile the cache
      * @method reconcile
@@ -182,29 +165,26 @@ declare class FileEntryCache {
      */
     getUpdatedFiles(files: string[]): string[];
     /**
-     * Get the not found files
+     * Get the file descriptors by path prefix
      * @method getFileDescriptorsByPath
-     * @param filePath - the files that you want to get from a path
-     * @returns {FileDescriptor[]} The not found files
+     * @param filePath - the path prefix to match
+     * @returns {FileDescriptor[]} The file descriptors
      */
     getFileDescriptorsByPath(filePath: string): FileDescriptor[];
     /**
      * Get the Absolute Path. If it is already absolute it will return the path as is.
      * @method getAbsolutePath
      * @param filePath - The file path to get the absolute path for
-     * @param options - The options for getting the absolute path. The current working directory is used if not provided.
      * @returns {string}
      */
-    getAbsolutePath(filePath: string, options?: {
-        currentWorkingDirectory?: string;
-    }): string;
+    getAbsolutePath(filePath: string): string;
     /**
-     * Rename the absolute path keys. This is used when a directory is changed or renamed.
-     * @method renameAbsolutePathKeys
-     * @param oldPath - The old path to rename
-     * @param newPath - The new path to rename to
+     * Rename cache keys that start with a given path prefix.
+     * @method renameCacheKeys
+     * @param oldPath - The old path prefix to rename
+     * @param newPath - The new path prefix to rename to
      */
-    renameAbsolutePathKeys(oldPath: string, newPath: string): void;
+    renameCacheKeys(oldPath: string, newPath: string): void;
 }
 
 export { type AnalyzedFiles, type FileDescriptor, type FileDescriptorMeta, FileEntryCache, type FileEntryCacheOptions, type GetFileDescriptorOptions, create, createFromFile, FileEntryDefault as default };

package/dist/index.d.ts

@@ -2,7 +2,6 @@ import { Buffer } from 'node:buffer';
 import { FlatCacheOptions, FlatCache } from 'flat-cache';
 
 type FileEntryCacheOptions = {
-    currentWorkingDirectory?: string;
     useModifiedTime?: boolean;
     useCheckSum?: boolean;
     hashAlgorithm?: string;
@@ -11,7 +10,6 @@ type FileEntryCacheOptions = {
 type GetFileDescriptorOptions = {
     useCheckSum?: boolean;
     useModifiedTime?: boolean;
-    currentWorkingDirectory?: string;
 };
 type FileDescriptor = {
     key: string;
@@ -31,8 +29,8 @@ type AnalyzedFiles = {
     notFoundFiles: string[];
     notChangedFiles: string[];
 };
-declare function createFromFile(filePath: string, useCheckSum?: boolean, currentWorkingDirectory?: string): FileEntryCache;
-declare function create(cacheId: string, cacheDirectory?: string, useCheckSum?: boolean, currentWorkingDirectory?: string): FileEntryCache;
+declare function createFromFile(filePath: string, useCheckSum?: boolean): FileEntryCache;
+declare function create(cacheId: string, cacheDirectory?: string, useCheckSum?: boolean): FileEntryCache;
 declare class FileEntryDefault {
     static create: typeof create;
     static createFromFile: typeof createFromFile;
@@ -41,7 +39,6 @@ declare class FileEntryCache {
     private _cache;
     private _useCheckSum;
     private _useModifiedTime;
-    private _currentWorkingDirectory;
     private _hashAlgorithm;
     /**
      * Create a new FileEntryCache instance
@@ -88,16 +85,6 @@ declare class FileEntryCache {
      * @param {string} value - The value to set
      */
     set hashAlgorithm(value: string);
-    /**
-     * Get the current working directory
-     * @returns {string | undefined} The current working directory
-     */
-    get currentWorkingDirectory(): string | undefined;
-    /**
-     * Set the current working directory
-     * @param {string | undefined} value - The value to set
-     */
-    set currentWorkingDirectory(value: string | undefined);
     /**
      * Given a buffer, calculate md5 hash of its content.
      * @method getHash
@@ -111,9 +98,7 @@ declare class FileEntryCache {
      * @param {String} filePath
      * @return {String}
      */
-    createFileKey(filePath: string, options?: {
-        currentWorkingDirectory?: string;
-    }): string;
+    createFileKey(filePath: string): string;
     /**
      * Check if the file path is a relative path
      * @method isRelativePath
@@ -137,9 +122,7 @@ declare class FileEntryCache {
      * @method removeEntry
      * @param filePath - The file path to remove from the cache
      */
-    removeEntry(filePath: string, options?: {
-        currentWorkingDirectory?: string;
-    }): void;
+    removeEntry(filePath: string): void;
     /**
      * Reconcile the cache
      * @method reconcile
@@ -182,29 +165,26 @@ declare class FileEntryCache {
      */
     getUpdatedFiles(files: string[]): string[];
     /**
-     * Get the not found files
+     * Get the file descriptors by path prefix
      * @method getFileDescriptorsByPath
-     * @param filePath - the files that you want to get from a path
-     * @returns {FileDescriptor[]} The not found files
+     * @param filePath - the path prefix to match
+     * @returns {FileDescriptor[]} The file descriptors
      */
     getFileDescriptorsByPath(filePath: string): FileDescriptor[];
     /**
      * Get the Absolute Path. If it is already absolute it will return the path as is.
      * @method getAbsolutePath
      * @param filePath - The file path to get the absolute path for
-     * @param options - The options for getting the absolute path. The current working directory is used if not provided.
      * @returns {string}
      */
-    getAbsolutePath(filePath: string, options?: {
-        currentWorkingDirectory?: string;
-    }): string;
+    getAbsolutePath(filePath: string): string;
     /**
-     * Rename the absolute path keys. This is used when a directory is changed or renamed.
-     * @method renameAbsolutePathKeys
-     * @param oldPath - The old path to rename
-     * @param newPath - The new path to rename to
+     * Rename cache keys that start with a given path prefix.
+     * @method renameCacheKeys
+     * @param oldPath - The old path prefix to rename
+     * @param newPath - The new path prefix to rename to
      */
-    renameAbsolutePathKeys(oldPath: string, newPath: string): void;
+    renameCacheKeys(oldPath: string, newPath: string): void;
 }
 
 export { type AnalyzedFiles, type FileDescriptor, type FileDescriptorMeta, FileEntryCache, type FileEntryCacheOptions, type GetFileDescriptorOptions, create, createFromFile, FileEntryDefault as default };

package/dist/index.js

@@ -6,14 +6,13 @@ import {
   createFromFile as createFlatCacheFile,
   FlatCache
 } from "flat-cache";
-function createFromFile(filePath, useCheckSum, currentWorkingDirectory) {
+function createFromFile(filePath, useCheckSum) {
   const fname = path.basename(filePath);
   const directory = path.dirname(filePath);
-  return create(fname, directory, useCheckSum, currentWorkingDirectory);
+  return create(fname, directory, useCheckSum);
 }
-function create(cacheId, cacheDirectory, useCheckSum, currentWorkingDirectory) {
+function create(cacheId, cacheDirectory, useCheckSum) {
   const options = {
-    currentWorkingDirectory,
     useCheckSum,
     cache: {
       cacheId,
@@ -37,7 +36,6 @@ var FileEntryCache = class {
   _cache = new FlatCache({ useClone: false });
   _useCheckSum = false;
   _useModifiedTime = true;
-  _currentWorkingDirectory;
   _hashAlgorithm = "md5";
   /**
    * Create a new FileEntryCache instance
@@ -53,9 +51,6 @@ var FileEntryCache = class {
     if (options?.useCheckSum) {
       this._useCheckSum = options.useCheckSum;
     }
-    if (options?.currentWorkingDirectory) {
-      this._currentWorkingDirectory = options.currentWorkingDirectory;
-    }
     if (options?.hashAlgorithm) {
       this._hashAlgorithm = options.hashAlgorithm;
     }
@@ -116,20 +111,6 @@ var FileEntryCache = class {
   set hashAlgorithm(value) {
     this._hashAlgorithm = value;
   }
-  /**
-   * Get the current working directory
-   * @returns {string | undefined} The current working directory
-   */
-  get currentWorkingDirectory() {
-    return this._currentWorkingDirectory;
-  }
-  /**
-   * Set the current working directory
-   * @param {string | undefined} value - The value to set
-   */
-  set currentWorkingDirectory(value) {
-    this._currentWorkingDirectory = value;
-  }
   /**
    * Given a buffer, calculate md5 hash of its content.
    * @method getHash
@@ -145,19 +126,8 @@ var FileEntryCache = class {
    * @param {String} filePath
    * @return {String}
    */
-  createFileKey(filePath, options) {
-    let result = filePath;
-    const currentWorkingDirectory = options?.currentWorkingDirectory ?? this._currentWorkingDirectory;
-    if (currentWorkingDirectory && filePath.startsWith(currentWorkingDirectory)) {
-      const splitPath = filePath.split(currentWorkingDirectory).pop();
-      if (splitPath) {
-        result = splitPath;
-        if (result.startsWith("/")) {
-          result = result.slice(1);
-        }
-      }
-    }
-    return result;
+  createFileKey(filePath) {
+    return filePath;
   }
   /**
    * Check if the file path is a relative path
@@ -188,16 +158,8 @@ var FileEntryCache = class {
    * @method removeEntry
    * @param filePath - The file path to remove from the cache
    */
-  removeEntry(filePath, options) {
-    if (this.isRelativePath(filePath)) {
-      filePath = this.getAbsolutePath(filePath, {
-        currentWorkingDirectory: options?.currentWorkingDirectory
-      });
-      this._cache.removeKey(this.createFileKey(filePath));
-    }
-    const key = this.createFileKey(filePath, {
-      currentWorkingDirectory: options?.currentWorkingDirectory
-    });
+  removeEntry(filePath) {
+    const key = this.createFileKey(filePath);
     this._cache.removeKey(key);
   }
   /**
@@ -243,19 +205,17 @@ var FileEntryCache = class {
       meta: {}
     };
     result.meta = this._cache.getKey(result.key) ?? {};
-    filePath = this.getAbsolutePath(filePath, {
-      currentWorkingDirectory: options?.currentWorkingDirectory
-    });
+    const absolutePath = this.getAbsolutePath(filePath);
     const useCheckSumValue = options?.useCheckSum ?? this._useCheckSum;
     const useModifiedTimeValue = options?.useModifiedTime ?? this._useModifiedTime;
     try {
-      fstat = fs.statSync(filePath);
+      fstat = fs.statSync(absolutePath);
       result.meta = {
         size: fstat.size
       };
       result.meta.mtime = fstat.mtime.getTime();
       if (useCheckSumValue) {
-        const buffer = fs.readFileSync(filePath);
+        const buffer = fs.readFileSync(absolutePath);
         result.meta.hash = this.getHash(buffer);
       }
     } catch (error) {
@@ -357,17 +317,16 @@ var FileEntryCache = class {
     return result;
   }
   /**
-   * Get the not found files
+   * Get the file descriptors by path prefix
    * @method getFileDescriptorsByPath
-   * @param filePath - the files that you want to get from a path
-   * @returns {FileDescriptor[]} The not found files
+   * @param filePath - the path prefix to match
+   * @returns {FileDescriptor[]} The file descriptors
    */
   getFileDescriptorsByPath(filePath) {
     const result = [];
     const keys = this._cache.keys();
     for (const key of keys) {
-      const absolutePath = this.getAbsolutePath(filePath);
-      if (absolutePath.startsWith(filePath)) {
+      if (key.startsWith(filePath)) {
         const fileDescriptor = this.getFileDescriptor(key);
         result.push(fileDescriptor);
       }
@@ -378,23 +337,21 @@ var FileEntryCache = class {
    * Get the Absolute Path. If it is already absolute it will return the path as is.
    * @method getAbsolutePath
    * @param filePath - The file path to get the absolute path for
-   * @param options - The options for getting the absolute path. The current working directory is used if not provided.
    * @returns {string}
    */
-  getAbsolutePath(filePath, options) {
+  getAbsolutePath(filePath) {
     if (this.isRelativePath(filePath)) {
-      const currentWorkingDirectory = options?.currentWorkingDirectory ?? this._currentWorkingDirectory ?? process.cwd();
-      filePath = path.resolve(currentWorkingDirectory, filePath);
+      return path.resolve(process.cwd(), filePath);
     }
     return filePath;
   }
   /**
-   * Rename the absolute path keys. This is used when a directory is changed or renamed.
-   * @method renameAbsolutePathKeys
-   * @param oldPath - The old path to rename
-   * @param newPath - The new path to rename to
+   * Rename cache keys that start with a given path prefix.
+   * @method renameCacheKeys
+   * @param oldPath - The old path prefix to rename
+   * @param newPath - The new path prefix to rename to
    */
-  renameAbsolutePathKeys(oldPath, newPath) {
+  renameCacheKeys(oldPath, newPath) {
     const keys = this._cache.keys();
     for (const key of keys) {
       if (key.startsWith(oldPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "file-entry-cache",
-  "version": "10.1.4",
+  "version": "11.0.0-beta.1",
   "description": "A lightweight cache for file metadata, ideal for processes that work on a specific set of files and only need to reprocess files that have changed since the last run",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -29,8 +29,8 @@
     "cache"
   ],
   "devDependencies": {
-    "@biomejs/biome": "^2.2.0",
-    "@types/node": "^24.3.0",
+    "@biomejs/biome": "^2.2.4",
+    "@types/node": "^24.5.0",
     "@vitest/coverage-v8": "^3.2.4",
     "rimraf": "^6.0.1",
     "tsup": "^8.5.0",
@@ -38,7 +38,7 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "flat-cache": "^6.1.13"
+    "flat-cache": "^6.1.14"
   },
   "files": [
     "dist",
@@ -47,8 +47,9 @@
   "scripts": {
     "build": "rimraf ./dist && tsup src/index.ts --format cjs,esm --dts --clean",
     "prepublish": "pnpm build",
-    "test": "biome check --write && vitest run --coverage",
-    "test:ci": "biome check && vitest run --coverage",
+    "lint": "biome check --write --error-on-warnings",
+    "test": "pnpm lint && vitest run --coverage",
+    "test:ci": "biome check --error-on-warnings && vitest run --coverage",
     "clean": "rimraf ./dist ./coverage ./node_modules"
   }
 }