MountableFS

Hierarchy

FakeFS<PortablePath>
- MountableFS

Index

Properties

pathUtils

Methods

Properties

publicreadonlypathUtils

pathUtils: PathUtils<PortablePath>

Methods

abstractaccessPromise

accessPromise(p: PortablePath, mode?: number): Promise<void>

Inherited from FakeFS.accessPromise
Parameters
- p: PortablePath
- optionalmode: number
Returns Promise<void>

abstractaccessSync

accessSync(p: PortablePath, mode?: number): void

Inherited from FakeFS.accessSync
Parameters
- p: PortablePath
- optionalmode: number
Returns void

abstractappendFilePromise

appendFilePromise(p: FSPath<PortablePath>, content: string | Uint8Array, opts?: WriteFileOptions): Promise<void>

Inherited from FakeFS.appendFilePromise
Parameters
- p: FSPath<PortablePath>
- content: string | Uint8Array
- optionalopts: WriteFileOptions
Returns Promise<void>

abstractappendFileSync

appendFileSync(p: FSPath<PortablePath>, content: string | Uint8Array, opts?: WriteFileOptions): void

Inherited from FakeFS.appendFileSync
Parameters
- p: FSPath<PortablePath>
- content: string | Uint8Array
- optionalopts: WriteFileOptions
Returns void

changeFilePromise

changeFilePromise(p: PortablePath, content: Buffer): Promise<void>
changeFilePromise(p: PortablePath, content: string, opts?: Partial<{ automaticNewlines: boolean; mode: number }>): Promise<void>

Inherited from FakeFS.changeFilePromise
Parameters
- p: PortablePath
- content: Buffer
Returns Promise<void>

changeFileSync

changeFileSync(p: PortablePath, content: Buffer): void
changeFileSync(p: PortablePath, content: string, opts?: Partial<{ automaticNewlines: boolean; mode: number }>): void

Inherited from FakeFS.changeFileSync
Parameters
- p: PortablePath
- content: Buffer
Returns void

checksumFilePromise

checksumFilePromise(path: PortablePath, __namedParameters?: { algorithm?: string }): Promise<string>

Inherited from FakeFS.checksumFilePromise
Parameters
- path: PortablePath
- __namedParameters: { algorithm?: string } = {}
Returns Promise<string>

abstractchmodPromise

chmodPromise(p: PortablePath, mask: number): Promise<void>

Inherited from FakeFS.chmodPromise
Parameters
- p: PortablePath
- mask: number
Returns Promise<void>

abstractchmodSync

chmodSync(p: PortablePath, mask: number): void

Inherited from FakeFS.chmodSync
Parameters
- p: PortablePath
- mask: number
Returns void

abstractchownPromise

chownPromise(p: PortablePath, uid: number, gid: number): Promise<void>

Inherited from FakeFS.chownPromise
Parameters
- p: PortablePath
- uid: number
- gid: number
Returns Promise<void>

abstractchownSync

chownSync(p: PortablePath, uid: number, gid: number): void

Inherited from FakeFS.chownSync
Parameters
- p: PortablePath
- uid: number
- gid: number
Returns void

abstractclosePromise

closePromise(fd: number): Promise<void>

Inherited from FakeFS.closePromise
Parameters
- fd: number
Returns Promise<void>

abstractcloseSync

closeSync(fd: number): void

Inherited from FakeFS.closeSync
Parameters
- fd: number
Returns void

abstractcopyFilePromise

copyFilePromise(sourceP: PortablePath, destP: PortablePath, flags?: number): Promise<void>

Inherited from FakeFS.copyFilePromise
Parameters
- sourceP: PortablePath
- destP: PortablePath
- optionalflags: number
Returns Promise<void>

abstractcopyFileSync

copyFileSync(sourceP: PortablePath, destP: PortablePath, flags?: number): void

Inherited from FakeFS.copyFileSync
Parameters
- sourceP: PortablePath
- destP: PortablePath
- optionalflags: number
Returns void

copyPromise

copyPromise(destination: PortablePath, source: PortablePath, options?: { baseFs?: undefined; linkStrategy?: null | LinkStrategy<PortablePath>; overwrite?: boolean; stableSort?: boolean; stableTime?: boolean }): Promise<void>
copyPromise<P2>(destination: PortablePath, source: P2, options: { baseFs: FakeFS<P2>; linkStrategy?: null | LinkStrategy<PortablePath>; overwrite?: boolean; stableSort?: boolean; stableTime?: boolean }): Promise<void>

Inherited from FakeFS.copyPromise
Parameters
- destination: PortablePath
- source: PortablePath
- optionaloptions: { baseFs?: undefined; linkStrategy?: null | LinkStrategy<PortablePath>; overwrite?: boolean; stableSort?: boolean; stableTime?: boolean }
Returns Promise<void>

copySync

copySync(destination: PortablePath, source: PortablePath, options?: { baseFs?: undefined; overwrite?: boolean }): void
copySync<P2>(destination: PortablePath, source: P2, options: { baseFs: FakeFS<P2>; overwrite?: boolean }): void

Inherited from FakeFS.copySync
@deprecated
Prefer using copyPromise instead
Parameters
- destination: PortablePath
- source: PortablePath
- optionaloptions: { baseFs?: undefined; overwrite?: boolean }
Returns void

abstractcreateReadStream

createReadStream(p: null | PortablePath, opts?: Partial<{ encoding: BufferEncoding; fd: number }>): ReadStream

Inherited from FakeFS.createReadStream
Parameters
- p: null | PortablePath
- optionalopts: Partial<{ encoding: BufferEncoding; fd: number }>
Returns ReadStream

abstractcreateWriteStream

createWriteStream(p: null | PortablePath, opts?: Partial<{ encoding: BufferEncoding; fd: number; flags: a }>): WriteStream

Inherited from FakeFS.createWriteStream
Parameters
- p: null | PortablePath
- optionalopts: Partial<{ encoding: BufferEncoding; fd: number; flags: a }>
Returns WriteStream

optionaldiscardAndClose

discardAndClose(): void

Returns void

abstractexistsPromise

existsPromise(p: PortablePath): Promise<boolean>

Inherited from FakeFS.existsPromise
Parameters
- p: PortablePath
Returns Promise<boolean>

abstractexistsSync

existsSync(p: PortablePath): boolean

Inherited from FakeFS.existsSync
Parameters
- p: PortablePath
Returns boolean

abstractfchmodPromise

fchmodPromise(fd: number, mask: number): Promise<void>

Inherited from FakeFS.fchmodPromise
Parameters
- fd: number
- mask: number
Returns Promise<void>

abstractfchmodSync

fchmodSync(fd: number, mask: number): void

Inherited from FakeFS.fchmodSync
Parameters
- fd: number
- mask: number
Returns void

abstractfchownPromise

fchownPromise(fd: number, uid: number, gid: number): Promise<void>

Inherited from FakeFS.fchownPromise
Parameters
- fd: number
- uid: number
- gid: number
Returns Promise<void>

abstractfchownSync

fchownSync(fd: number, uid: number, gid: number): void

Inherited from FakeFS.fchownSync
Parameters
- fd: number
- uid: number
- gid: number
Returns void

abstractfstatPromise

fstatPromise(fd: number): Promise<Stats>
fstatPromise(fd: number, opts: { bigint: true }): Promise<BigIntStats>
fstatPromise(fd: number, opts?: { bigint?: boolean }): Promise<Stats | BigIntStats>

Inherited from FakeFS.fstatPromise
Parameters
- fd: number
Returns Promise<Stats>

abstractfstatSync

fstatSync(fd: number): Stats
fstatSync(fd: number, opts: { bigint: true }): BigIntStats
fstatSync(fd: number, opts?: { bigint?: boolean }): Stats | BigIntStats

Inherited from FakeFS.fstatSync
Parameters
- fd: number
Returns Stats

abstractftruncatePromise

ftruncatePromise(fd: number, len?: number): Promise<void>

Inherited from FakeFS.ftruncatePromise
Parameters
- fd: number
- optionallen: number
Returns Promise<void>

abstractftruncateSync

ftruncateSync(fd: number, len?: number): void

Inherited from FakeFS.ftruncateSync
Parameters
- fd: number
- optionallen: number
Returns void

genTraversePromise

genTraversePromise(init: PortablePath, __namedParameters?: { stableSort?: boolean }): AsyncGenerator<PortablePath, void, unknown>

Inherited from FakeFS.genTraversePromise
Parameters
- init: PortablePath
- __namedParameters: { stableSort?: boolean } = {}
Returns AsyncGenerator<PortablePath, void, unknown>

abstractgetExtractHint

getExtractHint(hints: ExtractHintOptions): boolean

Inherited from FakeFS.getExtractHint
@deprecated: Moved to jsInstallUtils
Parameters
- hints: ExtractHintOptions
Returns boolean

abstractgetRealPath

getRealPath(): PortablePath

Inherited from FakeFS.getRealPath
Returns PortablePath

optionalhasOpenFileHandles

hasOpenFileHandles(): boolean

Returns boolean

abstractlinkPromise

linkPromise(existingP: PortablePath, newP: PortablePath): Promise<void>

Inherited from FakeFS.linkPromise
Parameters
- existingP: PortablePath
- newP: PortablePath
Returns Promise<void>

abstractlinkSync

linkSync(existingP: PortablePath, newP: PortablePath): void

Inherited from FakeFS.linkSync
Parameters
- existingP: PortablePath
- newP: PortablePath
Returns void

lockPromise

lockPromise<T>(affectedPath: PortablePath, callback: () => Promise<T>): Promise<T>

Inherited from FakeFS.lockPromise
Type parameters
- T
Parameters
- affectedPath: PortablePath
- callback: () => Promise<T>
Returns Promise<T>

abstractlstatPromise

lstatPromise(p: PortablePath): Promise<Stats>
lstatPromise(p: PortablePath, opts: undefined | (StatOptions & { bigint?: false })): Promise<Stats>
lstatPromise(p: PortablePath, opts: StatOptions & { bigint: true }): Promise<BigIntStats>
lstatPromise(p: PortablePath, opts?: StatOptions): Promise<Stats | BigIntStats>

Inherited from FakeFS.lstatPromise
Parameters
- p: PortablePath
Returns Promise<Stats>

abstractlstatSync

lstatSync(p: PortablePath): Stats
lstatSync(p: PortablePath, opts?: StatSyncOptions & { bigint?: false; throwIfNoEntry: false }): undefined | Stats
lstatSync(p: PortablePath, opts: StatSyncOptions & { bigint: true; throwIfNoEntry: false }): undefined | BigIntStats
lstatSync(p: PortablePath, opts?: StatSyncOptions & { bigint?: false }): Stats
lstatSync(p: PortablePath, opts: StatSyncOptions & { bigint: true }): BigIntStats
lstatSync(p: PortablePath, opts: StatSyncOptions & { bigint: boolean; throwIfNoEntry?: false }): Stats | BigIntStats
lstatSync(p: PortablePath, opts?: StatSyncOptions): undefined | Stats | BigIntStats

Inherited from FakeFS.lstatSync
Parameters
- p: PortablePath
Returns Stats

abstractlutimesPromise

lutimesPromise(p: PortablePath, atime: string | number | Date, mtime: string | number | Date): Promise<void>

Inherited from FakeFS.lutimesPromise
Parameters
- p: PortablePath
- atime: string | number | Date
- mtime: string | number | Date
Returns Promise<void>

abstractlutimesSync

lutimesSync(p: PortablePath, atime: string | number | Date, mtime: string | number | Date): void

Inherited from FakeFS.lutimesSync
Parameters
- p: PortablePath
- atime: string | number | Date
- mtime: string | number | Date
Returns void

abstractmkdirPromise

mkdirPromise(p: PortablePath, opts?: Partial<{ mode: number; recursive: boolean }>): Promise<undefined | string>

Inherited from FakeFS.mkdirPromise
Parameters
- p: PortablePath
- optionalopts: Partial<{ mode: number; recursive: boolean }>
Returns Promise<undefined | string>

abstractmkdirSync

mkdirSync(p: PortablePath, opts?: Partial<{ mode: number; recursive: boolean }>): undefined | string

Inherited from FakeFS.mkdirSync
Parameters
- p: PortablePath
- optionalopts: Partial<{ mode: number; recursive: boolean }>
Returns undefined | string

mkdirpPromise

mkdirpPromise(p: PortablePath, __namedParameters?: { chmod?: number; utimes?: [string | number | Date, string | number | Date] }): Promise<undefined | string>

Inherited from FakeFS.mkdirpPromise
Parameters
- p: PortablePath
- __namedParameters: { chmod?: number; utimes?: [string | number | Date, string | number | Date] } = {}
Returns Promise<undefined | string>

mkdirpSync

mkdirpSync(p: PortablePath, __namedParameters?: { chmod?: number; utimes?: [string | number | Date, string | number | Date] }): undefined | string

Inherited from FakeFS.mkdirpSync
Parameters
- p: PortablePath
- __namedParameters: { chmod?: number; utimes?: [string | number | Date, string | number | Date] } = {}
Returns undefined | string

movePromise

movePromise(fromP: PortablePath, toP: PortablePath): Promise<void>

Inherited from FakeFS.movePromise
Parameters
- fromP: PortablePath
- toP: PortablePath
Returns Promise<void>

moveSync

moveSync(fromP: PortablePath, toP: PortablePath): void

Inherited from FakeFS.moveSync
Parameters
- fromP: PortablePath
- toP: PortablePath
Returns void

abstractopenPromise

openPromise(p: PortablePath, flags: string, mode?: number): Promise<number>

Inherited from FakeFS.openPromise
Parameters
- p: PortablePath
- flags: string
- optionalmode: number
Returns Promise<number>

abstractopenSync

openSync(p: PortablePath, flags: string, mode?: number): number

Inherited from FakeFS.openSync
Parameters
- p: PortablePath
- flags: string
- optionalmode: number
Returns number

abstractopendirPromise

opendirPromise(p: PortablePath, opts?: Partial<{ bufferSize: number; recursive: boolean }>): Promise<Dir<PortablePath>>

Inherited from FakeFS.opendirPromise
Parameters
- p: PortablePath
- optionalopts: Partial<{ bufferSize: number; recursive: boolean }>
Returns Promise<Dir<PortablePath>>

abstractopendirSync

opendirSync(p: PortablePath, opts?: Partial<{ bufferSize: number; recursive: boolean }>): Dir<PortablePath>

Inherited from FakeFS.opendirSync
Parameters
- p: PortablePath
- optionalopts: Partial<{ bufferSize: number; recursive: boolean }>
Returns Dir<PortablePath>

preserveTimePromise

preserveTimePromise(p: PortablePath, cb: () => Promise<void | PortablePath>): Promise<void>

Inherited from FakeFS.preserveTimePromise
Parameters
- p: PortablePath
- cb: () => Promise<void | PortablePath>
Returns Promise<void>

preserveTimeSync

preserveTimeSync(p: PortablePath, cb: () => void | PortablePath): Promise<void>

Inherited from FakeFS.preserveTimeSync
Parameters
- p: PortablePath
- cb: () => void | PortablePath
Returns Promise<void>

abstractreadFilePromise

readFilePromise(p: FSPath<PortablePath>, encoding?: null): Promise<Buffer>
readFilePromise(p: FSPath<PortablePath>, encoding: BufferEncoding): Promise<string>
readFilePromise(p: FSPath<PortablePath>, encoding?: null | BufferEncoding): Promise<string | Buffer>

Inherited from FakeFS.readFilePromise
Parameters
- p: FSPath<PortablePath>
- optionalencoding: null
Returns Promise<Buffer>

abstractreadFileSync

readFileSync(p: FSPath<PortablePath>, encoding?: null): Buffer
readFileSync(p: FSPath<PortablePath>, encoding: BufferEncoding): string
readFileSync(p: FSPath<PortablePath>, encoding?: null | BufferEncoding): string | Buffer

Inherited from FakeFS.readFileSync
Parameters
- p: FSPath<PortablePath>
- optionalencoding: null
Returns Buffer

readJsonPromise

readJsonPromise(p: PortablePath): Promise<any>

Inherited from FakeFS.readJsonPromise
Parameters
- p: PortablePath
Returns Promise<any>

readJsonSync

readJsonSync(p: PortablePath): any

Inherited from FakeFS.readJsonSync
Parameters
- p: PortablePath
Returns any

abstractreadPromise

readPromise(fd: number, buffer: Buffer, offset?: number, length?: number, position?: null | number): Promise<number>

Inherited from FakeFS.readPromise
Parameters
- fd: number
- buffer: Buffer
- optionaloffset: number
- optionallength: number
- optionalposition: null | number
Returns Promise<number>

abstractreadSync

readSync(fd: number, buffer: Buffer, offset?: number, length?: number, position?: null | number): number

Inherited from FakeFS.readSync
Parameters
- fd: number
- buffer: Buffer
- optionaloffset: number
- optionallength: number
- optionalposition: null | number
Returns number

abstractreaddirPromise

readdirPromise(p: PortablePath, opts?: null): Promise<Filename[]>
readdirPromise(p: PortablePath, opts: { recursive?: false; withFileTypes: true }): Promise<DirentNoPath[]>
readdirPromise(p: PortablePath, opts: { recursive?: false; withFileTypes?: false }): Promise<Filename[]>
readdirPromise(p: PortablePath, opts: { recursive?: false; withFileTypes: boolean }): Promise<(Filename | DirentNoPath)[]>
readdirPromise(p: PortablePath, opts: { recursive: true; withFileTypes: true }): Promise<Dirent<PortablePath>[]>
readdirPromise(p: PortablePath, opts: { recursive: true; withFileTypes?: false }): Promise<PortablePath[]>
readdirPromise(p: PortablePath, opts: { recursive: true; withFileTypes: boolean }): Promise<(PortablePath | Dirent<PortablePath>)[]>
readdirPromise(p: PortablePath, opts: { recursive: boolean; withFileTypes: true }): Promise<(DirentNoPath | Dirent<PortablePath>)[]>
readdirPromise(p: PortablePath, opts: { recursive: boolean; withFileTypes?: false }): Promise<PortablePath[]>
readdirPromise(p: PortablePath, opts: { recursive: boolean; withFileTypes: boolean }): Promise<(PortablePath | DirentNoPath | Dirent<PortablePath>)[]>
readdirPromise(p: PortablePath, opts?: null | Partial<{ recursive: boolean; withFileTypes: boolean }>): Promise<(PortablePath | DirentNoPath | Dirent<PortablePath>)[]>

Inherited from FakeFS.readdirPromise
Parameters
- p: PortablePath
- optionalopts: null
Returns Promise<Filename[]>

abstractreaddirSync

readdirSync(p: PortablePath, opts?: null): Filename[]
readdirSync(p: PortablePath, opts: { recursive?: false; withFileTypes: true }): DirentNoPath[]
readdirSync(p: PortablePath, opts: { recursive?: false; withFileTypes?: false }): Filename[]
readdirSync(p: PortablePath, opts: { recursive?: false; withFileTypes: boolean }): (Filename | DirentNoPath)[]
readdirSync(p: PortablePath, opts: { recursive: true; withFileTypes: true }): Dirent<PortablePath>[]
readdirSync(p: PortablePath, opts: { recursive: true; withFileTypes?: false }): PortablePath[]
readdirSync(p: PortablePath, opts: { recursive: true; withFileTypes: boolean }): (PortablePath | Dirent<PortablePath>)[]
readdirSync(p: PortablePath, opts: { recursive: boolean; withFileTypes: true }): (DirentNoPath | Dirent<PortablePath>)[]
readdirSync(p: PortablePath, opts: { recursive: boolean; withFileTypes?: false }): PortablePath[]
readdirSync(p: PortablePath, opts: { recursive: boolean; withFileTypes: boolean }): (PortablePath | DirentNoPath | Dirent<PortablePath>)[]
readdirSync(p: PortablePath, opts?: null | Partial<{ recursive: boolean; withFileTypes: boolean }>): (PortablePath | DirentNoPath | Dirent<PortablePath>)[]

Inherited from FakeFS.readdirSync
Parameters
- p: PortablePath
- optionalopts: null
Returns Filename[]

abstractreadlinkPromise

readlinkPromise(p: PortablePath): Promise<PortablePath>

Inherited from FakeFS.readlinkPromise
Parameters
- p: PortablePath
Returns Promise<PortablePath>

abstractreadlinkSync

readlinkSync(p: PortablePath): PortablePath

Inherited from FakeFS.readlinkSync
Parameters
- p: PortablePath
Returns PortablePath

abstractrealpathPromise

realpathPromise(p: PortablePath): Promise<PortablePath>

Inherited from FakeFS.realpathPromise
Parameters
- p: PortablePath
Returns Promise<PortablePath>

abstractrealpathSync

realpathSync(p: PortablePath): PortablePath

Inherited from FakeFS.realpathSync
Parameters
- p: PortablePath
Returns PortablePath

removePromise

removePromise(p: PortablePath, __namedParameters?: { maxRetries?: number; recursive?: boolean }): Promise<void>

Inherited from FakeFS.removePromise
Parameters
- p: PortablePath
- __namedParameters: { maxRetries?: number; recursive?: boolean } = {}
Returns Promise<void>

removeSync

removeSync(p: PortablePath, __namedParameters?: { recursive?: boolean }): void

Inherited from FakeFS.removeSync
Parameters
- p: PortablePath
- __namedParameters: { recursive?: boolean } = {}
Returns void

abstractrenamePromise

renamePromise(oldP: PortablePath, newP: PortablePath): Promise<void>

Inherited from FakeFS.renamePromise
Parameters
- oldP: PortablePath
- newP: PortablePath
Returns Promise<void>

abstractrenameSync

renameSync(oldP: PortablePath, newP: PortablePath): void

Inherited from FakeFS.renameSync
Parameters
- oldP: PortablePath
- newP: PortablePath
Returns void

abstractresolve

resolve(p: PortablePath): PortablePath

Inherited from FakeFS.resolve
Parameters
- p: PortablePath
Returns PortablePath

abstractrmPromise

rmPromise(p: PortablePath, opts?: Partial<{ force: boolean; maxRetries: number; recursive: boolean; retryDelay: number }>): Promise<void>

Inherited from FakeFS.rmPromise
Parameters
- p: PortablePath
- optionalopts: Partial<{ force: boolean; maxRetries: number; recursive: boolean; retryDelay: number }>
Returns Promise<void>

abstractrmSync

rmSync(p: PortablePath, opts?: Partial<{ force: boolean; maxRetries: number; recursive: boolean; retryDelay: number }>): void

Inherited from FakeFS.rmSync
Parameters
- p: PortablePath
- optionalopts: Partial<{ force: boolean; maxRetries: number; recursive: boolean; retryDelay: number }>
Returns void

abstractrmdirPromise

rmdirPromise(p: PortablePath, opts?: Partial<{ maxRetries: number; recursive: boolean; retryDelay: number }>): Promise<void>

Inherited from FakeFS.rmdirPromise
Parameters
- p: PortablePath
- optionalopts: Partial<{ maxRetries: number; recursive: boolean; retryDelay: number }>
Returns Promise<void>

abstractrmdirSync

rmdirSync(p: PortablePath, opts?: Partial<{ maxRetries: number; recursive: boolean; retryDelay: number }>): void

Inherited from FakeFS.rmdirSync
Parameters
- p: PortablePath
- optionalopts: Partial<{ maxRetries: number; recursive: boolean; retryDelay: number }>
Returns void

optionalsaveAndClose

saveAndClose(): void

Returns void

abstractstatPromise

statPromise(p: PortablePath): Promise<Stats>
statPromise(p: PortablePath, opts: undefined | (StatOptions & { bigint?: false })): Promise<Stats>
statPromise(p: PortablePath, opts: StatOptions & { bigint: true }): Promise<BigIntStats>
statPromise(p: PortablePath, opts?: StatOptions): Promise<Stats | BigIntStats>

Inherited from FakeFS.statPromise
Parameters
- p: PortablePath
Returns Promise<Stats>

abstractstatSync

statSync(p: PortablePath): Stats
statSync(p: PortablePath, opts?: StatSyncOptions & { bigint?: false; throwIfNoEntry: false }): undefined | Stats
statSync(p: PortablePath, opts: StatSyncOptions & { bigint: true; throwIfNoEntry: false }): undefined | BigIntStats
statSync(p: PortablePath, opts?: StatSyncOptions & { bigint?: false }): Stats
statSync(p: PortablePath, opts: StatSyncOptions & { bigint: true }): BigIntStats
statSync(p: PortablePath, opts: StatSyncOptions & { bigint: boolean; throwIfNoEntry?: false }): Stats | BigIntStats
statSync(p: PortablePath, opts?: StatSyncOptions): undefined | Stats | BigIntStats

Inherited from FakeFS.statSync
Parameters
- p: PortablePath
Returns Stats

abstractsymlinkPromise

symlinkPromise(target: PortablePath, p: PortablePath, type?: SymlinkType): Promise<void>

Inherited from FakeFS.symlinkPromise
Parameters
- target: PortablePath
- p: PortablePath
- optionaltype: SymlinkType
Returns Promise<void>

abstractsymlinkSync

symlinkSync(target: PortablePath, p: PortablePath, type?: SymlinkType): void

Inherited from FakeFS.symlinkSync
Parameters
- target: PortablePath
- p: PortablePath
- optionaltype: SymlinkType
Returns void

abstracttruncatePromise

truncatePromise(p: PortablePath, len?: number): Promise<void>

Inherited from FakeFS.truncatePromise
Parameters
- p: PortablePath
- optionallen: number
Returns Promise<void>

abstracttruncateSync

truncateSync(p: PortablePath, len?: number): void

Inherited from FakeFS.truncateSync
Parameters
- p: PortablePath
- optionallen: number
Returns void

abstractunlinkPromise

unlinkPromise(p: PortablePath): Promise<void>

Inherited from FakeFS.unlinkPromise
Parameters
- p: PortablePath
Returns Promise<void>

abstractunlinkSync

unlinkSync(p: PortablePath): void

Inherited from FakeFS.unlinkSync
Parameters
- p: PortablePath
Returns void

abstractunwatchFile

unwatchFile(p: PortablePath, cb?: WatchFileCallback): void

Inherited from FakeFS.unwatchFile
Parameters
- p: PortablePath
- optionalcb: WatchFileCallback
Returns void

abstractutimesPromise

utimesPromise(p: PortablePath, atime: string | number | Date, mtime: string | number | Date): Promise<void>

Inherited from FakeFS.utimesPromise
Parameters
- p: PortablePath
- atime: string | number | Date
- mtime: string | number | Date
Returns Promise<void>

abstractutimesSync

utimesSync(p: PortablePath, atime: string | number | Date, mtime: string | number | Date): void

Inherited from FakeFS.utimesSync
Parameters
- p: PortablePath
- atime: string | number | Date
- mtime: string | number | Date
Returns void

abstractwatch

watch(p: PortablePath, cb?: WatchCallback): Watcher
watch(p: PortablePath, opts: WatchOptions, cb?: WatchCallback): Watcher

Inherited from FakeFS.watch
Parameters
- p: PortablePath
- optionalcb: WatchCallback
Returns Watcher

abstractwatchFile

watchFile(p: PortablePath, cb: WatchFileCallback): StatWatcher
watchFile(p: PortablePath, opts: Partial<{ bigint: boolean; interval: number; persistent: boolean }>, cb: WatchFileCallback): StatWatcher

Inherited from FakeFS.watchFile
Parameters
- p: PortablePath
- cb: WatchFileCallback
Returns StatWatcher

abstractwriteFilePromise

writeFilePromise(p: FSPath<PortablePath>, content: string | ArrayBufferView, opts?: WriteFileOptions): Promise<void>

Inherited from FakeFS.writeFilePromise
Parameters
- p: FSPath<PortablePath>
- content: string | ArrayBufferView
- optionalopts: WriteFileOptions
Returns Promise<void>

abstractwriteFileSync

writeFileSync(p: FSPath<PortablePath>, content: string | ArrayBufferView, opts?: WriteFileOptions): void

Inherited from FakeFS.writeFileSync
Parameters
- p: FSPath<PortablePath>
- content: string | ArrayBufferView
- optionalopts: WriteFileOptions
Returns void

writeJsonPromise

writeJsonPromise(p: PortablePath, data: any, __namedParameters?: { compact?: boolean }): Promise<void>

Inherited from FakeFS.writeJsonPromise
Parameters
- p: PortablePath
- data: any
- __namedParameters: { compact?: boolean } = {}
Returns Promise<void>

writeJsonSync

writeJsonSync(p: PortablePath, data: any, __namedParameters?: { compact?: boolean }): void

Inherited from FakeFS.writeJsonSync
Parameters
- p: PortablePath
- data: any
- __namedParameters: { compact?: boolean } = {}
Returns void

abstractwritePromise

writePromise(fd: number, buffer: Buffer, offset?: number, length?: number, position?: number): Promise<number>
writePromise(fd: number, buffer: string, position?: number): Promise<number>

Inherited from FakeFS.writePromise
Parameters
- fd: number
- buffer: Buffer
- optionaloffset: number
- optionallength: number
- optionalposition: number
Returns Promise<number>

abstractwriteSync

writeSync(fd: number, buffer: Buffer, offset?: number, length?: number, position?: number): number
writeSync(fd: number, buffer: string, position?: number): number

Inherited from FakeFS.writeSync
Parameters
- fd: number
- buffer: Buffer
- optionaloffset: number
- optionallength: number
- optionalposition: number
Returns number

Hierarchy

Index

Properties

Methods

Properties

publicreadonlypathUtils

Methods

abstractaccessPromise

Parameters

p: PortablePath

optionalmode: number

Returns Promise<void>

abstractaccessSync

Parameters

p: PortablePath

optionalmode: number

Returns void

abstractappendFilePromise

Parameters

p: FSPath<PortablePath>

content: string | Uint8Array

optionalopts: WriteFileOptions

Returns Promise<void>

abstractappendFileSync

Parameters

p: FSPath<PortablePath>

content: string | Uint8Array

optionalopts: WriteFileOptions

Returns void

changeFilePromise

Parameters

p: PortablePath

content: Buffer

Returns Promise<void>

changeFileSync

Parameters

p: PortablePath

content: Buffer

Returns void

checksumFilePromise

Parameters

path: PortablePath

__namedParameters: { algorithm?: string } = {}

Returns Promise<string>

abstractchmodPromise

Parameters

p: PortablePath

mask: number

Returns Promise<void>

abstractchmodSync

Parameters

p: PortablePath

mask: number

Returns void

abstractchownPromise

Parameters

p: PortablePath

uid: number

gid: number

Returns Promise<void>

abstractchownSync

Parameters

p: PortablePath

uid: number

gid: number

Returns void

abstractclosePromise

Parameters

fd: number

Returns Promise<void>

abstractcloseSync

Parameters

fd: number

Returns void

abstractcopyFilePromise

Parameters

sourceP: PortablePath

destP: PortablePath

optionalflags: number

Returns Promise<void>