abstractBasePortableFakeFS

Hierarchy

FakeFS<PortablePath>
- BasePortableFakeFS

Index

Properties

pathUtils

Methods

accessPromise
accessSync
appendFilePromise
appendFileSync
changeFilePromise
changeFileSync
checksumFilePromise
chmodPromise
chmodSync
chownPromise
chownSync
closePromise
closeSync
copyFilePromise
copyFileSync
copyPromise
copySync
createReadStream
createWriteStream
existsPromise
existsSync
fchmodPromise
fchmodSync
fchownPromise
fchownSync
fstatPromise
fstatSync
ftruncatePromise
ftruncateSync
genTraversePromise
getExtractHint
getRealPath
linkPromise
linkSync
lockPromise
lstatPromise
lstatSync
lutimesPromise
lutimesSync
mkdirPromise
mkdirSync
mkdirpPromise
mkdirpSync
movePromise
moveSync
openPromise
openSync
opendirPromise
opendirSync
preserveTimePromise
preserveTimeSync
readFilePromise
readFileSync
readJsonPromise
readJsonSync
readPromise
readSync
readdirPromise
readdirSync
readlinkPromise
readlinkSync
realpathPromise
realpathSync
removePromise
removeSync
renamePromise
renameSync
resolve
rmPromise
rmSync
rmdirPromise
rmdirSync
statPromise
statSync
symlinkPromise
symlinkSync
truncatePromise
truncateSync
unlinkPromise
unlinkSync
unwatchFile
utimesPromise
utimesSync
watch
watchFile
writeFilePromise
writeFileSync
writeJsonPromise
writeJsonSync
writePromise
writeSync

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<ArrayBufferLike>, opts?: WriteFileOptions): Promise<void>

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

abstractappendFileSync

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

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

changeFilePromise

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

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

changeFileSync

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

Inherited from FakeFS.changeFileSync
Parameters
- p: PortablePath
- content: Buffer<ArrayBufferLike>
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

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

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<NonSharedBuffer>
readFilePromise(p: FSPath<PortablePath>, encoding: BufferEncoding): Promise<string>
readFilePromise(p: FSPath<PortablePath>, encoding?: null | BufferEncoding): Promise<string | NonSharedBuffer>

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

abstractreadFileSync

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

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

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<ArrayBufferLike>, offset?: number, length?: number, position?: null | number): Promise<number>

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

abstractreadSync

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

Inherited from FakeFS.readSync
Parameters
- fd: number
- buffer: Buffer<ArrayBufferLike>
- 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

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<ArrayBufferLike>, opts?: WriteFileOptions): Promise<void>

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

abstractwriteFileSync

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

Inherited from FakeFS.writeFileSync
Parameters
- p: FSPath<PortablePath>
- content: string | ArrayBufferView<ArrayBufferLike>
- 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<ArrayBufferLike>, 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<ArrayBufferLike>
- optionaloffset: number
- optionallength: number
- optionalposition: number
Returns Promise<number>

abstractwriteSync

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

Inherited from FakeFS.writeSync
Parameters
- fd: number
- buffer: Buffer<ArrayBufferLike>
- 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<ArrayBufferLike>

optionalopts: WriteFileOptions

Returns Promise<void>

abstractappendFileSync

Parameters

p: FSPath<PortablePath>

content: string | Uint8Array<ArrayBufferLike>

optionalopts: WriteFileOptions

Returns void

changeFilePromise

Parameters

p: PortablePath

content: Buffer<ArrayBufferLike>

Returns Promise<void>

changeFileSync

Parameters

p: PortablePath

content: Buffer<ArrayBufferLike>

Returns void

checksumFilePromise

Parameters

path: PortablePath

__namedParameters: { algorithm?: string } = {}

optionalalgorithm: 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