/// /// /// import { LRUCache } from 'lru-cache'; import { posix, win32 } from 'node:path'; import { Minipass } from 'minipass'; import type { Dirent, Stats } from 'node:fs'; /** * An object that will be used to override the default `fs` * methods. Any methods that are not overridden will use Node's * built-in implementations. * * - lstatSync * - readdir (callback `withFileTypes` Dirent variant, used for * readdirCB and most walks) * - readdirSync * - readlinkSync * - realpathSync * - promises: Object containing the following async methods: * - lstat * - readdir (Dirent variant only) * - readlink * - realpath */ export interface FSOption { lstatSync?: (path: string) => Stats; readdir?: (path: string, options: { withFileTypes: true; }, cb: (er: NodeJS.ErrnoException | null, entries?: Dirent[]) => any) => void; readdirSync?: (path: string, options: { withFileTypes: true; }) => Dirent[]; readlinkSync?: (path: string) => string; realpathSync?: (path: string) => string; promises?: { lstat?: (path: string) => Promise; readdir?: (path: string, options: { withFileTypes: true; }) => Promise; readlink?: (path: string) => Promise; realpath?: (path: string) => Promise; [k: string]: any; }; [k: string]: any; } interface FSValue { lstatSync: (path: string) => Stats; readdir: (path: string, options: { withFileTypes: true; }, cb: (er: NodeJS.ErrnoException | null, entries?: Dirent[]) => any) => void; readdirSync: (path: string, options: { withFileTypes: true; }) => Dirent[]; readlinkSync: (path: string) => string; realpathSync: (path: string) => string; promises: { lstat: (path: string) => Promise; readdir: (path: string, options: { withFileTypes: true; }) => Promise; readlink: (path: string) => Promise; realpath: (path: string) => Promise; [k: string]: any; }; [k: string]: any; } export type Type = 'Unknown' | 'FIFO' | 'CharacterDevice' | 'Directory' | 'BlockDevice' | 'File' | 'SymbolicLink' | 'Socket'; /** * Options that may be provided to the Path constructor */ export interface PathOpts { fullpath?: string; relative?: string; relativePosix?: string; parent?: PathBase; /** * See {@link FSOption} */ fs?: FSOption; } /** * An LRUCache for storing resolved path strings or Path objects. * @internal */ export declare class ResolveCache extends LRUCache { constructor(); } /** * an LRUCache for storing child entries. * @internal */ export declare class ChildrenCache extends LRUCache { constructor(maxSize?: number); } /** * Array of Path objects, plus a marker indicating the first provisional entry * * @internal */ export type Children = PathBase[] & { provisional: number; }; declare const setAsCwd: unique symbol; /** * Path objects are sort of like a super-powered * {@link https://nodejs.org/docs/latest/api/fs.html#class-fsdirent fs.Dirent} * * Each one represents a single filesystem entry on disk, which may or may not * exist. It includes methods for reading various types of information via * lstat, readlink, and readdir, and caches all information to the greatest * degree possible. * * Note that fs operations that would normally throw will instead return an * "empty" value. This is in order to prevent excessive overhead from error * stack traces. */ export declare abstract class PathBase implements Dirent { #private; /** * the basename of this path * * **Important**: *always* test the path name against any test string * usingthe {@link isNamed} method, and not by directly comparing this * string. Otherwise, unicode path strings that the system sees as identical * will not be properly treated as the same path, leading to incorrect * behavior and possible security issues. */ name: string; /** * the Path entry corresponding to the path root. * * @internal */ root: PathBase; /** * All roots found within the current PathScurry family * * @internal */ roots: { [k: string]: PathBase; }; /** * a reference to the parent path, or undefined in the case of root entries * * @internal */ parent?: PathBase; /** * boolean indicating whether paths are compared case-insensitively * @internal */ nocase: boolean; /** * boolean indicating that this path is the current working directory * of the PathScurry collection that contains it. */ isCWD: boolean; /** * the string or regexp used to split paths. On posix, it is `'/'`, and on * windows it is a RegExp matching either `'/'` or `'\\'` */ abstract splitSep: string | RegExp; /** * The path separator string to use when joining paths */ abstract sep: string; get dev(): number | undefined; get mode(): number | undefined; get nlink(): number | undefined; get uid(): number | undefined; get gid(): number | undefined; get rdev(): number | undefined; get blksize(): number | undefined; get ino(): number | undefined; get size(): number | undefined; get blocks(): number | undefined; get atimeMs(): number | undefined; get mtimeMs(): number | undefined; get ctimeMs(): number | undefined; get birthtimeMs(): number | undefined; get atime(): Date | undefined; get mtime(): Date | undefined; get ctime(): Date | undefined; get birthtime(): Date | undefined; /** * This property is for compatibility with the Dirent class as of * Node v20, where Dirent['parentPath'] refers to the path of the * directory that was passed to readdir. For root entries, it's the path * to the entry itself. */ get parentPath(): string; /** * Deprecated alias for Dirent['parentPath'] Somewhat counterintuitively, * this property refers to the *parent* path, not the path object itself. */ get path(): string; /** * Do not create new Path objects directly. They should always be accessed * via the PathScurry class or other methods on the Path class. * * @internal */ constructor(name: string, type: number | undefined, root: PathBase | undefined, roots: { [k: string]: PathBase; }, nocase: boolean, children: ChildrenCache, opts: PathOpts); /** * Returns the depth of the Path object from its root. * * For example, a path at `/foo/bar` would have a depth of 2. */ depth(): number; /** * @internal */ abstract getRootString(path: string): string; /** * @internal */ abstract getRoot(rootPath: string): PathBase; /** * @internal */ abstract newChild(name: string, type?: number, opts?: PathOpts): PathBase; /** * @internal */ childrenCache(): ChildrenCache; /** * Get the Path object referenced by the string path, resolved from this Path */ resolve(path?: string): PathBase; /** * Returns the cached children Path objects, if still available. If they * have fallen out of the cache, then returns an empty array, and resets the * READDIR_CALLED bit, so that future calls to readdir() will require an fs * lookup. * * @internal */ children(): Children; /** * Resolves a path portion and returns or creates the child Path. * * Returns `this` if pathPart is `''` or `'.'`, or `parent` if pathPart is * `'..'`. * * This should not be called directly. If `pathPart` contains any path * separators, it will lead to unsafe undefined behavior. * * Use `Path.resolve()` instead. * * @internal */ child(pathPart: string, opts?: PathOpts): PathBase; /** * The relative path from the cwd. If it does not share an ancestor with * the cwd, then this ends up being equivalent to the fullpath() */ relative(): string; /** * The relative path from the cwd, using / as the path separator. * If it does not share an ancestor with * the cwd, then this ends up being equivalent to the fullpathPosix() * On posix systems, this is identical to relative(). */ relativePosix(): string; /** * The fully resolved path string for this Path entry */ fullpath(): string; /** * On platforms other than windows, this is identical to fullpath. * * On windows, this is overridden to return the forward-slash form of the * full UNC path. */ fullpathPosix(): string; /** * Is the Path of an unknown type? * * Note that we might know *something* about it if there has been a previous * filesystem operation, for example that it does not exist, or is not a * link, or whether it has child entries. */ isUnknown(): boolean; isType(type: Type): boolean; getType(): Type; /** * Is the Path a regular file? */ isFile(): boolean; /** * Is the Path a directory? */ isDirectory(): boolean; /** * Is the path a character device? */ isCharacterDevice(): boolean; /** * Is the path a block device? */ isBlockDevice(): boolean; /** * Is the path a FIFO pipe? */ isFIFO(): boolean; /** * Is the path a socket? */ isSocket(): boolean; /** * Is the path a symbolic link? */ isSymbolicLink(): boolean; /** * Return the entry if it has been subject of a successful lstat, or * undefined otherwise. * * Does not read the filesystem, so an undefined result *could* simply * mean that we haven't called lstat on it. */ lstatCached(): PathBase | undefined; /** * Return the cached link target if the entry has been the subject of a * successful readlink, or undefined otherwise. * * Does not read the filesystem, so an undefined result *could* just mean we * don't have any cached data. Only use it if you are very sure that a * readlink() has been called at some point. */ readlinkCached(): PathBase | undefined; /** * Returns the cached realpath target if the entry has been the subject * of a successful realpath, or undefined otherwise. * * Does not read the filesystem, so an undefined result *could* just mean we * don't have any cached data. Only use it if you are very sure that a * realpath() has been called at some point. */ realpathCached(): PathBase | undefined; /** * Returns the cached child Path entries array if the entry has been the * subject of a successful readdir(), or [] otherwise. * * Does not read the filesystem, so an empty array *could* just mean we * don't have any cached data. Only use it if you are very sure that a * readdir() has been called recently enough to still be valid. */ readdirCached(): PathBase[]; /** * Return true if it's worth trying to readlink. Ie, we don't (yet) have * any indication that readlink will definitely fail. * * Returns false if the path is known to not be a symlink, if a previous * readlink failed, or if the entry does not exist. */ canReadlink(): boolean; /** * Return true if readdir has previously been successfully called on this * path, indicating that cachedReaddir() is likely valid. */ calledReaddir(): boolean; /** * Returns true if the path is known to not exist. That is, a previous lstat * or readdir failed to verify its existence when that would have been * expected, or a parent entry was marked either enoent or enotdir. */ isENOENT(): boolean; /** * Return true if the path is a match for the given path name. This handles * case sensitivity and unicode normalization. * * Note: even on case-sensitive systems, it is **not** safe to test the * equality of the `.name` property to determine whether a given pathname * matches, due to unicode normalization mismatches. * * Always use this method instead of testing the `path.name` property * directly. */ isNamed(n: string): boolean; /** * Return the Path object corresponding to the target of a symbolic link. * * If the Path is not a symbolic link, or if the readlink call fails for any * reason, `undefined` is returned. * * Result is cached, and thus may be outdated if the filesystem is mutated. */ readlink(): Promise; /** * Synchronous {@link PathBase.readlink} */ readlinkSync(): PathBase | undefined; /** * Call lstat() on this Path, and update all known information that can be * determined. * * Note that unlike `fs.lstat()`, the returned value does not contain some * information, such as `mode`, `dev`, `nlink`, and `ino`. If that * information is required, you will need to call `fs.lstat` yourself. * * If the Path refers to a nonexistent file, or if the lstat call fails for * any reason, `undefined` is returned. Otherwise the updated Path object is * returned. * * Results are cached, and thus may be out of date if the filesystem is * mutated. */ lstat(): Promise; /** * synchronous {@link PathBase.lstat} */ lstatSync(): PathBase | undefined; /** * Standard node-style callback interface to get list of directory entries. * * If the Path cannot or does not contain any children, then an empty array * is returned. * * Results are cached, and thus may be out of date if the filesystem is * mutated. * * @param cb The callback called with (er, entries). Note that the `er` * param is somewhat extraneous, as all readdir() errors are handled and * simply result in an empty set of entries being returned. * @param allowZalgo Boolean indicating that immediately known results should * *not* be deferred with `queueMicrotask`. Defaults to `false`. Release * zalgo at your peril, the dark pony lord is devious and unforgiving. */ readdirCB(cb: (er: NodeJS.ErrnoException | null, entries: PathBase[]) => any, allowZalgo?: boolean): void; /** * Return an array of known child entries. * * If the Path cannot or does not contain any children, then an empty array * is returned. * * Results are cached, and thus may be out of date if the filesystem is * mutated. */ readdir(): Promise; /** * synchronous {@link PathBase.readdir} */ readdirSync(): PathBase[]; canReaddir(): boolean; shouldWalk(dirs: Set, walkFilter?: (e: PathBase) => boolean): boolean; /** * Return the Path object corresponding to path as resolved * by realpath(3). * * If the realpath call fails for any reason, `undefined` is returned. * * Result is cached, and thus may be outdated if the filesystem is mutated. * On success, returns a Path object. */ realpath(): Promise; /** * Synchronous {@link realpath} */ realpathSync(): PathBase | undefined; /** * Internal method to mark this Path object as the scurry cwd, * called by {@link PathScurry#chdir} * * @internal */ [setAsCwd](oldCwd: PathBase): void; } /** * Path class used on win32 systems * * Uses `'\\'` as the path separator for returned paths, either `'\\'` or `'/'` * as the path separator for parsing paths. */ export declare class PathWin32 extends PathBase { /** * Separator for generating path strings. */ sep: '\\'; /** * Separator for parsing path strings. */ splitSep: RegExp; /** * Do not create new Path objects directly. They should always be accessed * via the PathScurry class or other methods on the Path class. * * @internal */ constructor(name: string, type: number | undefined, root: PathBase | undefined, roots: { [k: string]: PathBase; }, nocase: boolean, children: ChildrenCache, opts: PathOpts); /** * @internal */ newChild(name: string, type?: number, opts?: PathOpts): PathWin32; /** * @internal */ getRootString(path: string): string; /** * @internal */ getRoot(rootPath: string): PathBase; /** * @internal */ sameRoot(rootPath: string, compare?: string): boolean; } /** * Path class used on all posix systems. * * Uses `'/'` as the path separator. */ export declare class PathPosix extends PathBase { /** * separator for parsing path strings */ splitSep: '/'; /** * separator for generating path strings */ sep: '/'; /** * Do not create new Path objects directly. They should always be accessed * via the PathScurry class or other methods on the Path class. * * @internal */ constructor(name: string, type: number | undefined, root: PathBase | undefined, roots: { [k: string]: PathBase; }, nocase: boolean, children: ChildrenCache, opts: PathOpts); /** * @internal */ getRootString(path: string): string; /** * @internal */ getRoot(_rootPath: string): PathBase; /** * @internal */ newChild(name: string, type?: number, opts?: PathOpts): PathPosix; } /** * Options that may be provided to the PathScurry constructor */ export interface PathScurryOpts { /** * perform case-insensitive path matching. Default based on platform * subclass. */ nocase?: boolean; /** * Number of Path entries to keep in the cache of Path child references. * * Setting this higher than 65536 will dramatically increase the data * consumption and construction time overhead of each PathScurry. * * Setting this value to 256 or lower will significantly reduce the data * consumption and construction time overhead, but may also reduce resolve() * and readdir() performance on large filesystems. * * Default `16384`. */ childrenCacheSize?: number; /** * An object that overrides the built-in functions from the fs and * fs/promises modules. * * See {@link FSOption} */ fs?: FSOption; } /** * The base class for all PathScurry classes, providing the interface for path * resolution and filesystem operations. * * Typically, you should *not* instantiate this class directly, but rather one * of the platform-specific classes, or the exported {@link PathScurry} which * defaults to the current platform. */ export declare abstract class PathScurryBase { #private; /** * The root Path entry for the current working directory of this Scurry */ root: PathBase; /** * The string path for the root of this Scurry's current working directory */ rootPath: string; /** * A collection of all roots encountered, referenced by rootPath */ roots: { [k: string]: PathBase; }; /** * The Path entry corresponding to this PathScurry's current working directory. */ cwd: PathBase; /** * Perform path comparisons case-insensitively. * * Defaults true on Darwin and Windows systems, false elsewhere. */ nocase: boolean; /** * The path separator used for parsing paths * * `'/'` on Posix systems, either `'/'` or `'\\'` on Windows */ abstract sep: string | RegExp; /** * This class should not be instantiated directly. * * Use PathScurryWin32, PathScurryDarwin, PathScurryPosix, or PathScurry * * @internal */ constructor(cwd: string | URL | undefined, pathImpl: typeof win32 | typeof posix, sep: string | RegExp, { nocase, childrenCacheSize, fs, }?: PathScurryOpts); /** * Get the depth of a provided path, string, or the cwd */ depth(path?: Path | string): number; /** * Parse the root portion of a path string * * @internal */ abstract parseRootPath(dir: string): string; /** * create a new Path to use as root during construction. * * @internal */ abstract newRoot(fs: FSValue): PathBase; /** * Determine whether a given path string is absolute */ abstract isAbsolute(p: string): boolean; /** * Return the cache of child entries. Exposed so subclasses can create * child Path objects in a platform-specific way. * * @internal */ childrenCache(): ChildrenCache; /** * Resolve one or more path strings to a resolved string * * Same interface as require('path').resolve. * * Much faster than path.resolve() when called multiple times for the same * path, because the resolved Path objects are cached. Much slower * otherwise. */ resolve(...paths: string[]): string; /** * Resolve one or more path strings to a resolved string, returning * the posix path. Identical to .resolve() on posix systems, but on * windows will return a forward-slash separated UNC path. * * Same interface as require('path').resolve. * * Much faster than path.resolve() when called multiple times for the same * path, because the resolved Path objects are cached. Much slower * otherwise. */ resolvePosix(...paths: string[]): string; /** * find the relative path from the cwd to the supplied path string or entry */ relative(entry?: PathBase | string): string; /** * find the relative path from the cwd to the supplied path string or * entry, using / as the path delimiter, even on Windows. */ relativePosix(entry?: PathBase | string): string; /** * Return the basename for the provided string or Path object */ basename(entry?: PathBase | string): string; /** * Return the dirname for the provided string or Path object */ dirname(entry?: PathBase | string): string; /** * Return an array of known child entries. * * First argument may be either a string, or a Path object. * * If the Path cannot or does not contain any children, then an empty array * is returned. * * Results are cached, and thus may be out of date if the filesystem is * mutated. * * Unlike `fs.readdir()`, the `withFileTypes` option defaults to `true`. Set * `{ withFileTypes: false }` to return strings. */ readdir(): Promise; readdir(opts: { withFileTypes: true; }): Promise; readdir(opts: { withFileTypes: false; }): Promise; readdir(opts: { withFileTypes: boolean; }): Promise; readdir(entry: PathBase | string): Promise; readdir(entry: PathBase | string, opts: { withFileTypes: true; }): Promise; readdir(entry: PathBase | string, opts: { withFileTypes: false; }): Promise; readdir(entry: PathBase | string, opts: { withFileTypes: boolean; }): Promise; /** * synchronous {@link PathScurryBase.readdir} */ readdirSync(): PathBase[]; readdirSync(opts: { withFileTypes: true; }): PathBase[]; readdirSync(opts: { withFileTypes: false; }): string[]; readdirSync(opts: { withFileTypes: boolean; }): PathBase[] | string[]; readdirSync(entry: PathBase | string): PathBase[]; readdirSync(entry: PathBase | string, opts: { withFileTypes: true; }): PathBase[]; readdirSync(entry: PathBase | string, opts: { withFileTypes: false; }): string[]; readdirSync(entry: PathBase | string, opts: { withFileTypes: boolean; }): PathBase[] | string[]; /** * Call lstat() on the string or Path object, and update all known * information that can be determined. * * Note that unlike `fs.lstat()`, the returned value does not contain some * information, such as `mode`, `dev`, `nlink`, and `ino`. If that * information is required, you will need to call `fs.lstat` yourself. * * If the Path refers to a nonexistent file, or if the lstat call fails for * any reason, `undefined` is returned. Otherwise the updated Path object is * returned. * * Results are cached, and thus may be out of date if the filesystem is * mutated. */ lstat(entry?: string | PathBase): Promise; /** * synchronous {@link PathScurryBase.lstat} */ lstatSync(entry?: string | PathBase): PathBase | undefined; /** * Return the Path object or string path corresponding to the target of a * symbolic link. * * If the path is not a symbolic link, or if the readlink call fails for any * reason, `undefined` is returned. * * Result is cached, and thus may be outdated if the filesystem is mutated. * * `{withFileTypes}` option defaults to `false`. * * On success, returns a Path object if `withFileTypes` option is true, * otherwise a string. */ readlink(): Promise; readlink(opt: { withFileTypes: false; }): Promise; readlink(opt: { withFileTypes: true; }): Promise; readlink(opt: { withFileTypes: boolean; }): Promise; readlink(entry: string | PathBase, opt?: { withFileTypes: false; }): Promise; readlink(entry: string | PathBase, opt: { withFileTypes: true; }): Promise; readlink(entry: string | PathBase, opt: { withFileTypes: boolean; }): Promise; /** * synchronous {@link PathScurryBase.readlink} */ readlinkSync(): string | undefined; readlinkSync(opt: { withFileTypes: false; }): string | undefined; readlinkSync(opt: { withFileTypes: true; }): PathBase | undefined; readlinkSync(opt: { withFileTypes: boolean; }): PathBase | string | undefined; readlinkSync(entry: string | PathBase, opt?: { withFileTypes: false; }): string | undefined; readlinkSync(entry: string | PathBase, opt: { withFileTypes: true; }): PathBase | undefined; readlinkSync(entry: string | PathBase, opt: { withFileTypes: boolean; }): string | PathBase | undefined; /** * Return the Path object or string path corresponding to path as resolved * by realpath(3). * * If the realpath call fails for any reason, `undefined` is returned. * * Result is cached, and thus may be outdated if the filesystem is mutated. * * `{withFileTypes}` option defaults to `false`. * * On success, returns a Path object if `withFileTypes` option is true, * otherwise a string. */ realpath(): Promise; realpath(opt: { withFileTypes: false; }): Promise; realpath(opt: { withFileTypes: true; }): Promise; realpath(opt: { withFileTypes: boolean; }): Promise; realpath(entry: string | PathBase, opt?: { withFileTypes: false; }): Promise; realpath(entry: string | PathBase, opt: { withFileTypes: true; }): Promise; realpath(entry: string | PathBase, opt: { withFileTypes: boolean; }): Promise; realpathSync(): string | undefined; realpathSync(opt: { withFileTypes: false; }): string | undefined; realpathSync(opt: { withFileTypes: true; }): PathBase | undefined; realpathSync(opt: { withFileTypes: boolean; }): PathBase | string | undefined; realpathSync(entry: string | PathBase, opt?: { withFileTypes: false; }): string | undefined; realpathSync(entry: string | PathBase, opt: { withFileTypes: true; }): PathBase | undefined; realpathSync(entry: string | PathBase, opt: { withFileTypes: boolean; }): string | PathBase | undefined; /** * Asynchronously walk the directory tree, returning an array of * all path strings or Path objects found. * * Note that this will be extremely memory-hungry on large filesystems. * In such cases, it may be better to use the stream or async iterator * walk implementation. */ walk(): Promise; walk(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Promise; walk(opts: WalkOptionsWithFileTypesFalse): Promise; walk(opts: WalkOptions): Promise; walk(entry: string | PathBase): Promise; walk(entry: string | PathBase, opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Promise; walk(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): Promise; walk(entry: string | PathBase, opts: WalkOptions): Promise; /** * Synchronously walk the directory tree, returning an array of * all path strings or Path objects found. * * Note that this will be extremely memory-hungry on large filesystems. * In such cases, it may be better to use the stream or async iterator * walk implementation. */ walkSync(): PathBase[]; walkSync(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): PathBase[]; walkSync(opts: WalkOptionsWithFileTypesFalse): string[]; walkSync(opts: WalkOptions): string[] | PathBase[]; walkSync(entry: string | PathBase): PathBase[]; walkSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesUnset | WalkOptionsWithFileTypesTrue): PathBase[]; walkSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): string[]; walkSync(entry: string | PathBase, opts: WalkOptions): PathBase[] | string[]; /** * Support for `for await` * * Alias for {@link PathScurryBase.iterate} * * Note: As of Node 19, this is very slow, compared to other methods of * walking. Consider using {@link PathScurryBase.stream} if memory overhead * and backpressure are concerns, or {@link PathScurryBase.walk} if not. */ [Symbol.asyncIterator](): AsyncGenerator; /** * Async generator form of {@link PathScurryBase.walk} * * Note: As of Node 19, this is very slow, compared to other methods of * walking, especially if most/all of the directory tree has been previously * walked. Consider using {@link PathScurryBase.stream} if memory overhead * and backpressure are concerns, or {@link PathScurryBase.walk} if not. */ iterate(): AsyncGenerator; iterate(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): AsyncGenerator; iterate(opts: WalkOptionsWithFileTypesFalse): AsyncGenerator; iterate(opts: WalkOptions): AsyncGenerator; iterate(entry: string | PathBase): AsyncGenerator; iterate(entry: string | PathBase, opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): AsyncGenerator; iterate(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): AsyncGenerator; iterate(entry: string | PathBase, opts: WalkOptions): AsyncGenerator; /** * Iterating over a PathScurry performs a synchronous walk. * * Alias for {@link PathScurryBase.iterateSync} */ [Symbol.iterator](): Generator; iterateSync(): Generator; iterateSync(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Generator; iterateSync(opts: WalkOptionsWithFileTypesFalse): Generator; iterateSync(opts: WalkOptions): Generator; iterateSync(entry: string | PathBase): Generator; iterateSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Generator; iterateSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): Generator; iterateSync(entry: string | PathBase, opts: WalkOptions): Generator; /** * Stream form of {@link PathScurryBase.walk} * * Returns a Minipass stream that emits {@link PathBase} objects by default, * or strings if `{ withFileTypes: false }` is set in the options. */ stream(): Minipass; stream(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Minipass; stream(opts: WalkOptionsWithFileTypesFalse): Minipass; stream(opts: WalkOptions): Minipass; stream(entry: string | PathBase): Minipass; stream(entry: string | PathBase, opts: WalkOptionsWithFileTypesUnset | WalkOptionsWithFileTypesTrue): Minipass; stream(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): Minipass; stream(entry: string | PathBase, opts: WalkOptions): Minipass | Minipass; /** * Synchronous form of {@link PathScurryBase.stream} * * Returns a Minipass stream that emits {@link PathBase} objects by default, * or strings if `{ withFileTypes: false }` is set in the options. * * Will complete the walk in a single tick if the stream is consumed fully. * Otherwise, will pause as needed for stream backpressure. */ streamSync(): Minipass; streamSync(opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset): Minipass; streamSync(opts: WalkOptionsWithFileTypesFalse): Minipass; streamSync(opts: WalkOptions): Minipass; streamSync(entry: string | PathBase): Minipass; streamSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesUnset | WalkOptionsWithFileTypesTrue): Minipass; streamSync(entry: string | PathBase, opts: WalkOptionsWithFileTypesFalse): Minipass; streamSync(entry: string | PathBase, opts: WalkOptions): Minipass | Minipass; chdir(path?: string | Path): void; } /** * Options provided to all walk methods. */ export interface WalkOptions { /** * Return results as {@link PathBase} objects rather than strings. * When set to false, results are fully resolved paths, as returned by * {@link PathBase.fullpath}. * @default true */ withFileTypes?: boolean; /** * Attempt to read directory entries from symbolic links. Otherwise, only * actual directories are traversed. Regardless of this setting, a given * target path will only ever be walked once, meaning that a symbolic link * to a previously traversed directory will never be followed. * * Setting this imposes a slight performance penalty, because `readlink` * must be called on all symbolic links encountered, in order to avoid * infinite cycles. * @default false */ follow?: boolean; /** * Only return entries where the provided function returns true. * * This will not prevent directories from being traversed, even if they do * not pass the filter, though it will prevent directories themselves from * being included in the result set. See {@link walkFilter} * * Asynchronous functions are not supported here. * * By default, if no filter is provided, all entries and traversed * directories are included. */ filter?: (entry: PathBase) => boolean; /** * Only traverse directories (and in the case of {@link follow} being set to * true, symbolic links to directories) if the provided function returns * true. * * This will not prevent directories from being included in the result set, * even if they do not pass the supplied filter function. See {@link filter} * to do that. * * Asynchronous functions are not supported here. */ walkFilter?: (entry: PathBase) => boolean; } export type WalkOptionsWithFileTypesUnset = WalkOptions & { withFileTypes?: undefined; }; export type WalkOptionsWithFileTypesTrue = WalkOptions & { withFileTypes: true; }; export type WalkOptionsWithFileTypesFalse = WalkOptions & { withFileTypes: false; }; /** * Windows implementation of {@link PathScurryBase} * * Defaults to case insensitve, uses `'\\'` to generate path strings. Uses * {@link PathWin32} for Path objects. */ export declare class PathScurryWin32 extends PathScurryBase { /** * separator for generating path strings */ sep: '\\'; constructor(cwd?: URL | string, opts?: PathScurryOpts); /** * @internal */ parseRootPath(dir: string): string; /** * @internal */ newRoot(fs: FSValue): PathWin32; /** * Return true if the provided path string is an absolute path */ isAbsolute(p: string): boolean; } /** * {@link PathScurryBase} implementation for all posix systems other than Darwin. * * Defaults to case-sensitive matching, uses `'/'` to generate path strings. * * Uses {@link PathPosix} for Path objects. */ export declare class PathScurryPosix extends PathScurryBase { /** * separator for generating path strings */ sep: '/'; constructor(cwd?: URL | string, opts?: PathScurryOpts); /** * @internal */ parseRootPath(_dir: string): string; /** * @internal */ newRoot(fs: FSValue): PathPosix; /** * Return true if the provided path string is an absolute path */ isAbsolute(p: string): boolean; } /** * {@link PathScurryBase} implementation for Darwin (macOS) systems. * * Defaults to case-insensitive matching, uses `'/'` for generating path * strings. * * Uses {@link PathPosix} for Path objects. */ export declare class PathScurryDarwin extends PathScurryPosix { constructor(cwd?: URL | string, opts?: PathScurryOpts); } /** * Default {@link PathBase} implementation for the current platform. * * {@link PathWin32} on Windows systems, {@link PathPosix} on all others. */ export declare const Path: typeof PathWin32 | typeof PathPosix; export type Path = PathBase | InstanceType; /** * Default {@link PathScurryBase} implementation for the current platform. * * {@link PathScurryWin32} on Windows systems, {@link PathScurryDarwin} on * Darwin (macOS) systems, {@link PathScurryPosix} on all others. */ export declare const PathScurry: typeof PathScurryWin32 | typeof PathScurryDarwin | typeof PathScurryPosix; export type PathScurry = PathScurryBase | InstanceType; export {}; //# sourceMappingURL=index.d.ts.map