@gesslar/toolkit 3.8.0 → 3.12.3

package/src/types/lib/DirectoryObject.d.ts

@@ -8,7 +8,6 @@
  * - Pattern-based content filtering with glob support
  * - Path traversal via walkUp generator
  * - Intelligent path merging for subdirectories and files
- * - Support for temporary directory management
  *
  * @property {string} supplied - The original directory path as supplied to constructor
  * @property {string} path - The absolute resolved directory path
@@ -18,7 +17,6 @@
  * @property {string} extension - The directory extension (typically empty string)
  * @property {string} sep - Platform-specific path separator ('/' or '\\')
  * @property {Array<string>} trail - Path segments split by separator
- * @property {boolean} temporary - Whether this is marked as a temporary directory
  * @property {boolean} isFile - Always false (this is a directory)
  * @property {boolean} isDirectory - Always true
  * @property {DirectoryObject|null} parent - The parent directory (null if root)
@@ -48,20 +46,34 @@
  * const file = dir.getFile("package.json")
  */
 export default class DirectoryObject extends FS {
-    [x: number]: () => object;
+    /**
+     * Creates a DirectoryObject from the current working directory.
+     * Useful when working with pnpx or other tools where the project root
+     * needs to be determined at runtime.
+     *
+     * @returns {DirectoryObject} A DirectoryObject representing the current working directory
+     * @example
+     * const projectRoot = DirectoryObject.fromCwd()
+     * console.log(projectRoot.path) // process.cwd()
+     */
+    static fromCwd(): DirectoryObject;
     /**
      * Constructs a DirectoryObject instance.
      *
-     * @param {string? | DirectoryObject?} directory - The directory path or DirectoryObject
-     * @param {boolean} [temporary] - Whether this is a temporary directory.
+     * @param {string?} [directory="."] - The directory path or DirectoryObject (defaults to current directory)
      */
-    constructor(directory?: any, temporary?: boolean);
+    constructor(directory?: string | null);
     /**
      * Returns a JSON representation of the DirectoryObject.
      *
      * @returns {object} JSON representation of the DirectoryObject
      */
     toJSON(): object;
+    /**
+     * Custom inspect method for Node.js console.
+     *
+     * @returns {object} JSON representation of this object.
+     */
     /**
      * Checks if the directory exists (async).
      *
@@ -119,12 +131,6 @@ export default class DirectoryObject extends FS {
      * console.log(dir.trail) // ['', 'path', 'to', 'directory']
      */
     get trail(): Array<string>;
-    /**
-     * Returns whether this directory is marked as temporary.
-     *
-     * @returns {boolean} True if this is a temporary directory, false otherwise
-     */
-    get temporary(): boolean;
     /**
      * Returns the parent directory of this directory.
      * Returns null if this directory is the root directory.
@@ -139,42 +145,6 @@ export default class DirectoryObject extends FS {
      * console.log(root.parent) // null
      */
     get parent(): DirectoryObject | null;
-    /**
-     * Returns the root directory of the filesystem.
-     *
-     * For DirectoryObject, this walks up to the filesystem root.
-     * For CappedDirectoryObject, this returns the cap root.
-     *
-     * @returns {DirectoryObject} The root directory
-     * @example
-     * const dir = new DirectoryObject("/usr/local/bin")
-     * console.log(dir.root.path)  // "/"
-     *
-     * @example
-     * const capped = new CappedDirectoryObject("/projects/myapp")
-     * const sub = capped.getDirectory("src/lib")
-     * console.log(sub.root.path)  // "/" (virtual, cap root)
-     * console.log(sub.root.real.path)  // "/projects/myapp"
-     */
-    get root(): DirectoryObject;
-    /**
-     * Recursively removes a temporary directory and all its contents.
-     *
-     * This method will delete all files and subdirectories within this directory,
-     * then delete the directory itself. It only works on directories explicitly
-     * marked as temporary for safety.
-     *
-     * @async
-     * @returns {Promise<void>}
-     * @throws {Sass} If the directory is not marked as temporary
-     * @throws {Sass} If the directory deletion fails
-     * @example
-     * const tempDir = new TempDirectoryObject("my-temp")
-     * await tempDir.assureExists()
-     * // ... use the directory ...
-     * await tempDir.remove() // Recursively deletes everything
-     */
-    remove(): Promise<void>;
     /**
      * Returns false. Because this is a directory.
      *
@@ -225,7 +195,7 @@ export default class DirectoryObject extends FS {
      * Generator that walks up the directory tree, yielding each parent directory.
      * Starts from the current directory and yields each parent until reaching the root.
      *
-     * @returns {object} Generator yielding parent DirectoryObject instances
+     * @returns {DirectoryObject} Generator yielding parent DirectoryObject instances
      * @example
      * const dir = new DirectoryObject('/path/to/deep/directory')
      * for(const parent of dir.walkUp) {
@@ -237,7 +207,7 @@ export default class DirectoryObject extends FS {
      *   // /
      * }
      */
-    get walkUp(): object;
+    get walkUp(): DirectoryObject;
     /**
      * Deletes an empty directory from the filesystem.
      *
@@ -275,7 +245,7 @@ export default class DirectoryObject extends FS {
      * duplication (e.g., "/projects/toolkit" + "toolkit/src" = "/projects/toolkit/src").
      * The temporary flag is preserved from the parent directory.
      *
-     * @param {string} newPath - The subdirectory path to append (can be nested like "src/lib")
+     * @param {string} dir - The subdirectory path to append (can be nested like "src/lib")
      * @returns {DirectoryObject} A new DirectoryObject instance with the combined path
      * @throws {Sass} If newPath is not a string
      * @example
@@ -289,7 +259,7 @@ export default class DirectoryObject extends FS {
      * const subDir = dir.getDirectory("toolkit/src")
      * console.log(subDir.path) // "/projects/toolkit/src" (not /projects/toolkit/toolkit/src)
      */
-    getDirectory(newPath: string): DirectoryObject;
+    getDirectory(dir: string): DirectoryObject;
     /**
      * Creates a new FileObject by extending this directory's path.
      *
@@ -297,7 +267,7 @@ export default class DirectoryObject extends FS {
      * duplication. The resulting FileObject can be used for reading, writing,
      * and other file operations.
      *
-     * @param {string} filename - The filename to append (can include subdirectories like "src/index.js")
+     * @param {string} file - The filename to append (can include subdirectories like "src/index.js")
      * @returns {FileObject} A new FileObject instance with the combined path
      * @throws {Sass} If filename is not a string
      * @example
@@ -310,7 +280,7 @@ export default class DirectoryObject extends FS {
      * const file = dir.getFile("src/index.js")
      * const data = await file.read()
      */
-    getFile(filename: string): FileObject;
+    getFile(file: string): FileObject;
     #private;
 }
 import FS from "./FS.js";

package/src/types/lib/DirectoryObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/DirectoryObject.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;uBAsGe,MAAM;IAnEnB;;;;;OAKG;IACH,yCAFW,OAAO,EA6BjB;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAelB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,aALa,KAAK,CAAC,MAAM,CAAC,CAOzB;IAED;;;;OAIG;IACH,iBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;OAYG;IACH,cARa,eAAe,GAAC,IAAI,CAwBhC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,YAXa,eAAe,CAoB3B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,UATa,OAAO,CAAC,IAAI,CAAC,CA0BzB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAiBD;;;;;;;;;;;;;;;OAeG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAoCpF;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAqBzB;IA8BD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,MAAM,CAclB;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,sBAdW,MAAM,GACJ,eAAe,CAoB3B;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAbW,MAAM,GACJ,UAAU,CAkBtB;;CACF;eAnmBc,SAAS;uBACD,iBAAiB"}
+{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/DirectoryObject.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH;IAmEE;;;;;;;;;OASG;IACH,kBALa,eAAe,CAO3B;IA/CD;;;;OAIG;IACH,wBAFW,MAAM,OAAC,EA8BjB;IA+BD;;;;OAIG;IACH,UAFa,MAAM,CAclB;IAED;;;;OAIG;IAKH;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,aALa,KAAK,CAAC,MAAM,CAAC,CAOzB;IAED;;;;;;;;;;;;OAYG;IACH,cARa,eAAe,GAAC,IAAI,CAsBhC;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAqBD;;;;;;;;;;;;;;;OAeG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAiDpF;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAqBzB;IAyBD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,eAAe,CAc3B;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAUD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBAdW,MAAM,GACJ,eAAe,CAqB3B;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cAbW,MAAM,GACJ,UAAU,CAoBtB;;CACF;eA9jBc,SAAS;uBACD,iBAAiB"}

package/src/types/lib/FS.d.ts

@@ -20,7 +20,7 @@ export default class FS {
      * @param {string} pathName - The path to convert
      * @returns {string} The URI
      */
-    static pathToUri(pathName: string): string;
+    static pathToUrl(pathName: string): string;
     /**
      * Convert a URI to a path
      *
@@ -28,22 +28,12 @@ export default class FS {
      * @param {string} pathName - The URI to convert
      * @returns {string} The path
      */
-    static uriToPath(pathName: string): string;
-    /**
-     * Retrieve all files matching a specific glob pattern.
-     *
-     * @static
-     * @param {string|Array<string>} glob - The glob pattern(s) to search.
-     * @returns {Promise<Array<FileObject>>} A promise that resolves to an array of file objects
-     * @throws {Sass} If the input is not a string or array of strings.
-     * @throws {Sass} If the glob pattern array is empty or for other search failures.
-     */
-    static getFiles(glob: string | Array<string>): Promise<Array<FileObject>>;
+    static urlToPath(pathName: string): string;
     /**
      * Computes the relative path from one file or directory to another.
      *
-     * If the target is outside the source (i.e., the relative path starts with ".."),
-     * returns the absolute path to the target instead.
+     * If the target is outside the source (i.e., the relative path starts with
+     * ".."), returns the absolute path to the target instead.
      *
      * @static
      * @param {FileObject|DirectoryObject} from - The source file or directory object
@@ -52,7 +42,8 @@ export default class FS {
      */
     static relativeOrAbsolutePath(from: FileObject | DirectoryObject, to: FileObject | DirectoryObject): string;
     /**
-     * Merge two paths by finding overlapping segments and combining them efficiently
+     * Merge two paths by finding overlapping segments and combining them
+     * efficiently
      *
      * @static
      * @param {string} path1 - The first path
@@ -71,6 +62,115 @@ export default class FS {
      * @returns {string} The resolved path
      */
     static resolvePath(fromPath: string, toPath: string): string;
+    /**
+     * Check if a candidate path is contained within a container path.
+     *
+     * @static
+     * @param {string} container - The container path to check against
+     * @param {string} candidate - The candidate path that might be contained
+     * @returns {boolean} True if candidate is within container, false otherwise
+     * @throws {Sass} If container is not a non-empty string
+     * @throws {Sass} If candidate is not a non-empty string
+     * @example
+     * FS.pathContains("/home/user", "/home/user/docs") // true
+     * FS.pathContains("/home/user", "/home/other") // false
+     */
+    static pathContains(container: string, candidate: string): boolean;
+    /**
+     * Convert an absolute path to a relative path by finding overlapping segments.
+     * Returns the relative portion of the 'to' path after the last occurrence
+     * of the final segment from the 'from' path.
+     *
+     * @static
+     * @param {string} from - The base path to calculate relative from
+     * @param {string} to - The target path to make relative
+     * @param {string} [sep=path.sep] - The path separator to use (defaults to system separator)
+     * @returns {string|null} The relative path, empty string if paths are identical, or null if no overlap found
+     * @example
+     * FS.toRelativePath("/projects/toolkit", "/projects/toolkit/src") // "src"
+     * FS.toRelativePath("/home/user", "/home/user") // ""
+     * FS.toRelativePath("/projects/app", "/other/path") // null
+     */
+    static toRelativePath(from: string, to: string, sep?: string): string | null;
+    /**
+     * Find the common root path between two paths by identifying overlapping segments.
+     * Returns the portion of 'from' that matches up to the overlap point in 'to'.
+     *
+     * @static
+     * @param {string} from - The first path to compare
+     * @param {string} to - The second path to find common root with
+     * @param {string} [sep=path.sep] - The path separator to use (defaults to system separator)
+     * @returns {string|null} The common root path, the original path if identical, or null if no overlap found
+     * @throws {Sass} If from is not a non-empty string
+     * @throws {Sass} If to is not a non-empty string
+     * @example
+     * FS.getCommonRootPath("/projects/toolkit/src", "/projects/toolkit/tests") // "/projects/toolkit"
+     * FS.getCommonRootPath("/home/user", "/home/user") // "/home/user"
+     * FS.getCommonRootPath("/projects/app", "/other/path") // null
+     */
+    static getCommonRootPath(from: string, to: string, sep?: string): string | null;
+    /**
+     * @typedef {object} PathParts
+     * @property {string} base - The file name with extension
+     * @property {string} dir - The directory path
+     * @property {string} ext - The file extension (including dot)
+     */
+    /**
+     * Deconstruct a file or directory name into parts.
+     *
+     * @static
+     * @param {string} pathName - The file/directory name to deconstruct
+     * @returns {PathParts} The filename parts
+     * @throws {Sass} If not a string of more than 1 character
+     */
+    static pathParts(pathName: string): {
+        /**
+         * - The file name with extension
+         */
+        base: string;
+        /**
+         * - The directory path
+         */
+        dir: string;
+        /**
+         * - The file extension (including dot)
+         */
+        ext: string;
+    };
+    /**
+     * Convert a virtual capped path to its real filesystem path.
+     * For capped objects, resolves the virtual path relative to the cap's real path.
+     * For uncapped objects, returns the path unchanged.
+     *
+     * @static
+     * @param {FileObject|DirectoryObject} fileOrDirectoryObject - The file or directory object to convert
+     * @returns {string} The real filesystem path
+     * @throws {Sass} If parameter is not a FileObject or DirectoryObject
+     * @example
+     * const temp = new TempDirectoryObject("myapp")
+     * const file = temp.getFile("/config.json")
+     * FS.virtualToRealPath(file) // "/tmp/myapp-ABC123/config.json"
+     *
+     * @example
+     * const regular = new FileObject("/home/user/file.txt")
+     * FS.virtualToRealPath(regular) // "/home/user/file.txt"
+     */
+    static virtualToRealPath(fileOrDirectoryObject: FileObject | DirectoryObject): string;
+    /**
+     * Convert an absolute path to a relative format by removing the root component.
+     * By default, keeps a leading separator (making it "absolute-like relative").
+     * Use forceActuallyRelative to get a truly relative path without leading separator.
+     *
+     * @static
+     * @param {string} pathToCheck - The path to convert (returned unchanged if already relative)
+     * @param {boolean} [forceActuallyRelative=false] - If true, removes leading separator for truly relative path
+     * @returns {string} The relative path (with or without leading separator based on forceActuallyRelative)
+     * @example
+     * FS.absoluteToRelative("/home/user/docs") // "/home/user/docs" (with leading /)
+     * FS.absoluteToRelative("/home/user/docs", true) // "home/user/docs" (truly relative)
+     * FS.absoluteToRelative("relative/path") // "relative/path" (unchanged)
+     */
+    static absoluteToRelative(pathToCheck: string, forceActuallyRelative?: boolean): string;
     /**
      * Compute the relative path from another file or directory to this instance.
      *

package/src/types/lib/FS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FS.d.ts","sourceRoot":"","sources":["../../lib/FS.js"],"names":[],"mappings":"AAwBA;;GAEG;AACH;IACE,kCAAwB;IACxB,uCAAkC;IAClC,mBAAsB;IAsBtB;;;;;;OAMG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;OAQG;IACH,sBALW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,GAClB,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAmCtC;IAED;;;;;;;;;;OAUG;IACH,oCAJW,UAAU,GAAC,eAAe,MAC1B,UAAU,GAAC,eAAe,GACxB,MAAM,CAYlB;IAED;;;;;;;;OAQG;IACH,oCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA0BlB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAgClB;IA1MD;;;;;;;;;OASG;IACH,kCAJW,UAAU,GAAC,eAAe,GACxB,MAAM,CAWlB;CAyLF;yBA5Na,OAAO,iBAAiB,EAAE,OAAO;8BACjC,OAAO,sBAAsB,EAAE,OAAO"}
+{"version":3,"file":"FS.d.ts","sourceRoot":"","sources":["../../lib/FS.js"],"names":[],"mappings":"AA0BA;;GAEG;AACH;IACE,kCAAwB;IACxB,uCAAkC;IAClC,mBAAsB;IAsBtB;;;;;;OAMG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;;;OAUG;IACH,oCAJW,UAAU,GAAC,eAAe,MAC1B,UAAU,GAAC,eAAe,GACxB,MAAM,CAYlB;IAED;;;;;;;;;OASG;IACH,oCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA0BlB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAmClB;IAED;;;;;;;;;;;;OAYG;IACH,+BATW,MAAM,aACN,MAAM,GACJ,OAAO,CAcnB;IAED;;;;;;;;;;;;;;OAcG;IACH,4BATW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CAwBvB;IAED;;;;;;;;;;;;;;;OAeG;IACH,+BAXW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CA+BvB;IAED;;;;;OAKG;IAEH;;;;;;;OAOG;IACH,2BAJW,MAAM;;;;cATH,MAAM;;;;aACN,MAAM;;;;aACN,MAAM;MAenB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gDAZW,UAAU,GAAC,eAAe,GACxB,MAAM,CAiClB;IAED;;;;;;;;;;;;;OAaG;IACH,uCARW,MAAM,0BACN,OAAO,GACL,MAAM,CAkBlB;IA/VD;;;;;;;;;OASG;IACH,kCAJW,UAAU,GAAC,eAAe,GACxB,MAAM,CAWlB;CA8UF;yBAjXa,OAAO,iBAAiB,EAAE,OAAO;8BACjC,OAAO,sBAAsB,EAAE,OAAO"}

package/src/types/lib/FileObject.d.ts

@@ -27,10 +27,10 @@ export default class FileObject extends FS {
     /**
      * Constructs a FileObject instance.
      *
-     * @param {string | FileObject} fileName - The file path or FileObject
+     * @param {string} fileName - The file path
      * @param {DirectoryObject|string|null} [parent] - The parent directory (object or string)
      */
-    constructor(fileName: string | FileObject, parent?: DirectoryObject | string | null);
+    constructor(fileName: string, parent?: DirectoryObject | string | null);
     /**
      * Returns a JSON representation of the FileObject.
      *
@@ -51,7 +51,9 @@ export default class FileObject extends FS {
     get supplied(): string;
     /**
      * Returns the file path. If the parent is a capped directory, returns the
-     * virtual path relative to the cap. Otherwise returns the real filesystem path.
+     * virtual path relative to the cap. Otherwise returns the real filesystem
+     * path.
+     *
      * Use `.real.path` to always get the actual filesystem path.
      *
      * @returns {string} The file path (virtual if parent is capped, real otherwise)
@@ -110,6 +112,7 @@ export default class FileObject extends FS {
      * @returns {DirectoryObject} The parent directory object
      */
     get parent(): DirectoryObject;
+    get parentPath(): any;
     /**
      * Returns a plain FileObject representing the actual filesystem location.
      * This provides an "escape hatch" when working with capped directories,

package/src/types/lib/FileObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../lib/FileObject.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;GAcG;AAEH;uBAmIe,MAAM;IAlInB;;;;;OAKG;IACH,yBAFU;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC,CAAA;KAAC,CAO1D;IA2BF;;;;;OAKG;IACH,sBAHW,MAAM,GAAG,UAAU,WACnB,eAAe,GAAC,MAAM,GAAC,IAAI,EAuDrC;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAclB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,YAFa,MAAM,CAkBlB;IAED;;;;;OAKG;IACH,WAFa,GAAG,CAWf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IACD;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,cAFa,eAAe,CAI3B;IAED;;;;;;;;;;;;;;;OAeG;IACH,YAXa,UAAU,CAatB;IAED;;;;OAIG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,YAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC,MAAM,OAAC,CAAC,CAU5B;IAED;;;;;OAKG;IACH,YAFa,OAAO,CAAC,IAAI,OAAC,CAAC,CAU1B;IAsBD;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAkB3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAXW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAkC5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,IAAI,CAAC,CAiBzB;;CACF;eA9jBc,SAAS;4BADI,sBAAsB"}
+{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../lib/FileObject.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;GAcG;AAEH;uBAgIe,MAAM;IA/HnB;;;;;OAKG;IACH,yBAFU;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC,CAAA;KAAC,CAO1D;IA4BF;;;;;OAKG;IACH,sBAHW,MAAM,WACN,eAAe,GAAC,MAAM,GAAC,IAAI,EAkDrC;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAelB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,YAFa,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,WAFa,GAAG,CAQf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IACD;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,cAFa,eAAe,CAI3B;IAED,sBAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,YAXa,UAAU,CAatB;IAED;;;;OAIG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,YAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC,MAAM,OAAC,CAAC,CAU5B;IAED;;;;;OAKG;IACH,YAFa,OAAO,CAAC,IAAI,OAAC,CAAC,CAU1B;IAED;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAkB3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CA+BzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAXW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAkC5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,IAAI,CAAC,CAiBzB;;CACF;eA3jBc,SAAS;4BADI,sBAAsB"}

package/src/types/lib/TempDirectoryObject.d.ts

@@ -10,72 +10,32 @@
  */
 export default class TempDirectoryObject extends CappedDirectoryObject {
     /**
-     * Constructs a TempDirectoryObject instance and creates the directory.
+     * TempDirectoryObject does not support fromCwd() since it is specifically
+     * designed to work within the OS temporary directory tree.
      *
-     * The directory is created synchronously during construction, so it will
-     * exist immediately after the constructor returns.
-     *
-     * If no name is provided, uses the OS temp directory directly. If a name
-     * is provided without a parent, creates a new directory with a unique suffix.
-     * If a parent is provided, creates a subdirectory within that parent.
-     *
-     * @param {string?} [name] - Base name for the temp directory (if empty/null, uses OS temp dir)
-     * @param {TempDirectoryObject?} [parent] - Optional parent temporary directory
-     * @throws {Sass} If name is absolute
-     * @throws {Sass} If name is empty (when parent is provided)
-     * @throws {Sass} If name contains path separators
-     * @throws {Sass} If parent is provided but not a temporary directory
-     * @throws {Sass} If parent's lineage does not trace back to the OS temp directory
-     * @throws {Sass} If directory creation fails
-     * @example
-     * // Use OS temp directory directly
-     * const temp = new TempDirectoryObject()
-     * console.log(temp.path) // "/tmp"
-     *
-     * @example
-     * // Create with unique name
-     * const temp = new TempDirectoryObject("myapp")
-     * console.log(temp.path) // "/tmp/myapp-ABC123"
-     *
-     * @example
-     * // Nested temp directories
-     * const parent = new TempDirectoryObject("parent")
-     * const child = new TempDirectoryObject("child", parent)
-     * await parent.remove() // Removes both parent and child
-     */
-    constructor(name?: string | null, parent?: TempDirectoryObject | null);
-    /**
-     * Creates a new TempDirectoryObject by extending this directory's path.
-     *
-     * Validates that the resulting path remains within the temp directory tree.
-     *
-     * @param {string} newPath - The path segment to append
-     * @returns {TempDirectoryObject} A new TempDirectoryObject with the extended path
-     * @throws {Sass} If the path would escape the temp directory
-     * @throws {Sass} If the path is absolute
-     * @throws {Sass} If the path contains traversal (..)
-     * @example
-     * const temp = new TempDirectoryObject("myapp")
-     * const subDir = temp.getDirectory("data")
-     * console.log(subDir.path) // "/tmp/myapp-ABC123/data"
+     * @throws {Sass} Always throws an error
      */
-    getDirectory(newPath: string): TempDirectoryObject;
+    static fromCwd(): void;
+    get isTemporary(): boolean;
+    get cap(): any;
     /**
-     * Creates a new FileObject by extending this directory's path.
+     * Recursively removes a temporary directory and all its contents.
      *
-     * Validates that the resulting path remains within the temp directory tree.
+     * This method will delete all files and subdirectories within this directory,
+     * then delete the directory itself. It only works on directories explicitly
+     * marked as temporary for safety.
      *
-     * @param {string} filename - The filename to append
-     * @returns {FileObject} A new FileObject with the extended path
-     * @throws {Sass} If the path would escape the temp directory
-     * @throws {Sass} If the path is absolute
-     * @throws {Sass} If the path contains traversal (..)
+     * @async
+     * @returns {Promise<void>}
+     * @throws {Sass} If the directory is not marked as temporary
+     * @throws {Sass} If the directory deletion fails
      * @example
-     * const temp = new TempDirectoryObject("myapp")
-     * const file = temp.getFile("config.json")
-     * console.log(file.path) // "/tmp/myapp-ABC123/config.json"
+     * const tempDir = new TempDirectoryObject("my-temp")
+     * await tempDir.assureExists()
+     * // ... use the directory ...
+     * await tempDir.remove() // Recursively deletes everything
      */
-    getFile(filename: string): FileObject;
+    remove(): Promise<void>;
     #private;
 }
 import CappedDirectoryObject from "./CappedDirectoryObject.js";

package/src/types/lib/TempDirectoryObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TempDirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/TempDirectoryObject.js"],"names":[],"mappings":"AAcA;;;;;;;;;GASG;AACH;IAEE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,mBAxBW,MAAM,OAAC,WACP,mBAAmB,OAAC,EA6F9B;IAsBD;;;;;;;;;;;;;;OAcG;IACH,sBAVW,MAAM,GACJ,mBAAmB,CAY/B;IAED;;;;;;;;;;;;;;OAcG;IACH,kBAVW,MAAM,GACJ,UAAU,CAYtB;;CAUF;kCA9LiC,4BAA4B"}
+{"version":3,"file":"TempDirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/TempDirectoryObject.js"],"names":[],"mappings":"AAiBA;;;;;;;;;GASG;AACH;IAgIE;;;;;OAKG;IACH,uBAEC;IA1ED,2BAEC;IAwBD,eAEC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,UATa,OAAO,CAAC,IAAI,CAAC,CAWzB;;CA0BF;kCAzJiC,4BAA4B"}