ZipFS

Hierarchy

BasePortableFakeFS
- ZipFS

Index

Constructors

constructor

Properties

pathUtils

Methods

Constructors

constructor

new ZipFS(): ZipFS
new ZipFS(p: PortablePath, opts?: ZipPathOptions): ZipFS
new ZipFS(data: null | Buffer, opts?: ZipBufferOptions): ZipFS

Overrides BasePortableFakeFS.constructor
Returns ZipFS

Properties

publicreadonlypathUtils

pathUtils: PathUtils<PortablePath>

Methods

accessPromise

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

Overrides BasePortableFakeFS.accessPromise
Parameters
- p: PortablePath
- optionalmode: number
Returns Promise<void>

accessSync

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

Overrides BasePortableFakeFS.accessSync
Parameters
- p: PortablePath
- mode: number = constants.F_OK
Returns void

appendFilePromise

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

Overrides BasePortableFakeFS.appendFilePromise
Parameters
- p: FSPath<PortablePath>
- content: string | Uint8Array
- optionalopts: WriteFileOptions
Returns Promise<void>

appendFileSync

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

Overrides BasePortableFakeFS.appendFileSync
Parameters
- p: FSPath<PortablePath>
- content: string | Uint8Array
- opts: 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 BasePortableFakeFS.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 BasePortableFakeFS.changeFileSync
Parameters
- p: PortablePath
- content: Buffer
Returns void

checksumFilePromise

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

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

chmodPromise

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

Overrides BasePortableFakeFS.chmodPromise
Parameters
- p: PortablePath
- mask: number
Returns Promise<void>

chmodSync

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

Overrides BasePortableFakeFS.chmodSync
Parameters
- p: PortablePath
- mask: number
Returns void

chownPromise

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

Overrides BasePortableFakeFS.chownPromise
Parameters
- p: PortablePath
- uid: number
- gid: number
Returns Promise<void>

chownSync

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

Overrides BasePortableFakeFS.chownSync
Parameters
- p: PortablePath
- uid: number
- gid: number
Returns void

closePromise

closePromise(fd: number): Promise<void>

Overrides BasePortableFakeFS.closePromise
Parameters
- fd: number
Returns Promise<void>

closeSync

closeSync(fd: number): void

Overrides BasePortableFakeFS.closeSync
Parameters
- fd: number
Returns void

copyFilePromise

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

Overrides BasePortableFakeFS.copyFilePromise
Parameters
- sourceP: PortablePath
- destP: PortablePath
- optionalflags: number
Returns Promise<void>

copyFileSync

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

Overrides BasePortableFakeFS.copyFileSync
Parameters
- sourceP: PortablePath
- destP: PortablePath
- flags: number = 0
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 BasePortableFakeFS.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 BasePortableFakeFS.copySync
@deprecated
Prefer using copyPromise instead
Parameters
- destination: PortablePath
- source: PortablePath
- optionaloptions: { baseFs?: undefined; overwrite?: boolean }
Returns void

createReadStream

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

Overrides BasePortableFakeFS.createReadStream
Parameters
- p: null | PortablePath
- __namedParameters: Partial<{ encoding: BufferEncoding; fd: number }> = {}
Returns ReadStream

createWriteStream

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

Overrides BasePortableFakeFS.createWriteStream
Parameters
- p: null | PortablePath
- __namedParameters: Partial<{ encoding: BufferEncoding; fd: number; flags: a }> = {}
Returns WriteStream

discardAndClose

discardAndClose(): void

Returns void

existsPromise

existsPromise(p: PortablePath): Promise<boolean>

Overrides BasePortableFakeFS.existsPromise
Parameters
- p: PortablePath
Returns Promise<boolean>

existsSync

existsSync(p: PortablePath): boolean

Overrides BasePortableFakeFS.existsSync
Parameters
- p: PortablePath
Returns boolean

fchmodPromise

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

Overrides BasePortableFakeFS.fchmodPromise
Parameters
- fd: number
- mask: number
Returns Promise<void>

fchmodSync

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

Overrides BasePortableFakeFS.fchmodSync
Parameters
- fd: number
- mask: number
Returns void

fchownPromise

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

Overrides BasePortableFakeFS.fchownPromise
Parameters
- fd: number
- uid: number
- gid: number
Returns Promise<void>

fchownSync

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

Overrides BasePortableFakeFS.fchownSync
Parameters
- fd: number
- uid: number
- gid: number
Returns void

fstatPromise

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

Overrides BasePortableFakeFS.fstatPromise
Parameters
- fd: number
Returns Promise<Stats>

fstatSync

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

Overrides BasePortableFakeFS.fstatSync
Parameters
- fd: number
Returns Stats

ftruncatePromise

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

Overrides BasePortableFakeFS.ftruncatePromise
Parameters
- fd: number
- optionallen: number
Returns Promise<void>

ftruncateSync

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

Overrides BasePortableFakeFS.ftruncateSync
Parameters
- fd: number
- optionallen: number
Returns void

genTraversePromise

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

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

getAllFiles

getAllFiles(): PortablePath[]

Returns PortablePath[]

getBufferAndClose

getBufferAndClose(): Buffer

Returns Buffer

getExtractHint

getExtractHint(hints: ExtractHintOptions): boolean

Overrides BasePortableFakeFS.getExtractHint
@deprecated: Moved to jsInstallUtils
Parameters
- hints: ExtractHintOptions
Returns boolean

getRealPath

getRealPath(): PortablePath

Overrides BasePortableFakeFS.getRealPath
Returns PortablePath

hasOpenFileHandles

hasOpenFileHandles(): boolean

Returns boolean

linkPromise

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

Overrides BasePortableFakeFS.linkPromise
Parameters
- existingP: PortablePath
- newP: PortablePath
Returns Promise<void>

linkSync

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

Overrides BasePortableFakeFS.linkSync
Parameters
- existingP: PortablePath
- newP: PortablePath
Returns void

lockPromise

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

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

lstatPromise

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>

Overrides BasePortableFakeFS.lstatPromise
Parameters
- p: PortablePath
Returns Promise<Stats>

lstatSync

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

Overrides BasePortableFakeFS.lstatSync
Parameters
- p: PortablePath
Returns Stats

lutimesPromise

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

Overrides BasePortableFakeFS.lutimesPromise
Parameters
- p: PortablePath
- atime: string | number | Date
- mtime: string | number | Date
Returns Promise<void>

lutimesSync

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

Overrides BasePortableFakeFS.lutimesSync
Parameters
- p: PortablePath
- atime: string | number | Date
- mtime: string | number | Date
Returns void

makeLibzipError

makeLibzipError(error: number): LibzipError

Parameters
- error: number
Returns LibzipError

mkdirPromise

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

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

mkdirSync

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

Overrides BasePortableFakeFS.mkdirSync
Parameters
- p: PortablePath
- __namedParameters: 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 BasePortableFakeFS.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 BasePortableFakeFS.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 BasePortableFakeFS.movePromise
Parameters
- fromP: PortablePath
- toP: PortablePath
Returns Promise<void>

moveSync

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

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

openPromise

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

Overrides BasePortableFakeFS.openPromise
Parameters
- p: PortablePath
- flags: string
- optionalmode: number
Returns Promise<number>

openSync

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

Overrides BasePortableFakeFS.openSync
Parameters
- p: PortablePath
- flags: string
- optionalmode: number
Returns number

opendirPromise

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

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

opendirSync

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

Overrides BasePortableFakeFS.opendirSync
Parameters
- p: PortablePath
- opts: Partial<{ bufferSize: number; recursive: boolean }> = {}
Returns Dir<PortablePath>

preserveTimePromise

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

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

preserveTimeSync

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

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

readFilePromise

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>

Overrides BasePortableFakeFS.readFilePromise
Parameters
- p: FSPath<PortablePath>
- optionalencoding: null
Returns Promise<Buffer>

readFileSync

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

Overrides BasePortableFakeFS.readFileSync
Parameters
- p: FSPath<PortablePath>
- optionalencoding: null
Returns Buffer

readJsonPromise

readJsonPromise(p: PortablePath): Promise<any>

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

readJsonSync

readJsonSync(p: PortablePath): any

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

readPromise

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

Overrides BasePortableFakeFS.readPromise
Parameters
- fd: number
- buffer: Buffer
- optionaloffset: number
- optionallength: number
- optionalposition: null | number
Returns Promise<number>

readSync

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

Overrides BasePortableFakeFS.readSync
Parameters
- fd: number
- buffer: Buffer
- offset: number = 0
- length: number = buffer.byteLength
- position: null | number = -1
Returns number

readdirPromise

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>)[]>

Overrides BasePortableFakeFS.readdirPromise
Parameters
- p: PortablePath
- optionalopts: null
Returns Promise<Filename[]>

readdirSync

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>)[]

Overrides BasePortableFakeFS.readdirSync
Parameters
- p: PortablePath
- optionalopts: null
Returns Filename[]

readlinkPromise

readlinkPromise(p: PortablePath): Promise<PortablePath>

Overrides BasePortableFakeFS.readlinkPromise
Parameters
- p: PortablePath
Returns Promise<PortablePath>

readlinkSync

readlinkSync(p: PortablePath): PortablePath

Overrides BasePortableFakeFS.readlinkSync
Parameters
- p: PortablePath
Returns PortablePath

realpathPromise

realpathPromise(p: PortablePath): Promise<PortablePath>

Overrides BasePortableFakeFS.realpathPromise
Parameters
- p: PortablePath
Returns Promise<PortablePath>

realpathSync

realpathSync(p: PortablePath): PortablePath

Overrides BasePortableFakeFS.realpathSync
Parameters
- p: PortablePath
Returns PortablePath

removePromise

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

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

removeSync

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

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

renamePromise

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

Overrides BasePortableFakeFS.renamePromise
Parameters
- oldP: PortablePath
- newP: PortablePath
Returns Promise<never>

renameSync

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

Overrides BasePortableFakeFS.renameSync
Parameters
- oldP: PortablePath
- newP: PortablePath
Returns never

resolve

resolve(p: PortablePath): PortablePath

Overrides BasePortableFakeFS.resolve
Parameters
- p: PortablePath
Returns PortablePath

rmPromise

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

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

rmSync

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

Overrides BasePortableFakeFS.rmSync
Parameters
- p: PortablePath
- __namedParameters: Partial<{ force: boolean; maxRetries: number; recursive: boolean; retryDelay: number }> = {}
Returns void

rmdirPromise

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

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

rmdirSync

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

Overrides BasePortableFakeFS.rmdirSync
Parameters
- p: PortablePath
- __namedParameters: Partial<{ maxRetries: number; recursive: boolean; retryDelay: number }> = {}
Returns void

saveAndClose

saveAndClose(): void

Returns void

statPromise

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>

Overrides BasePortableFakeFS.statPromise
Parameters
- p: PortablePath
Returns Promise<Stats>

statSync

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

Overrides BasePortableFakeFS.statSync
Parameters
- p: PortablePath
Returns Stats

symlinkPromise

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

Overrides BasePortableFakeFS.symlinkPromise
Parameters
- target: PortablePath
- p: PortablePath
Returns Promise<void>

symlinkSync

symlinkSync(target: PortablePath, p: PortablePath): void

Overrides BasePortableFakeFS.symlinkSync
Parameters
- target: PortablePath
- p: PortablePath
Returns void

truncatePromise

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

Overrides BasePortableFakeFS.truncatePromise
Parameters
- p: PortablePath
- len: number = 0
Returns Promise<void>

truncateSync

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

Overrides BasePortableFakeFS.truncateSync
Parameters
- p: PortablePath
- len: number = 0
Returns void

unlinkPromise

unlinkPromise(p: PortablePath): Promise<void>

Overrides BasePortableFakeFS.unlinkPromise
Parameters
- p: PortablePath
Returns Promise<void>

unlinkSync

unlinkSync(p: PortablePath): void

Overrides BasePortableFakeFS.unlinkSync
Parameters
- p: PortablePath
Returns void

unwatchFile

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

Overrides BasePortableFakeFS.unwatchFile
Parameters
- p: PortablePath
- optionalcb: WatchFileCallback
Returns void

utimesPromise

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

Overrides BasePortableFakeFS.utimesPromise
Parameters
- p: PortablePath
- atime: string | number | Date
- mtime: string | number | Date
Returns Promise<void>

utimesSync

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

Overrides BasePortableFakeFS.utimesSync
Parameters
- p: PortablePath
- atime: string | number | Date
- mtime: string | number | Date
Returns void

watch

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

Overrides BasePortableFakeFS.watch
Parameters
- p: PortablePath
- optionalcb: WatchCallback
Returns Watcher

watchFile

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

Overrides BasePortableFakeFS.watchFile
Parameters
- p: PortablePath
- cb: WatchFileCallback
Returns StatWatcher

writeFilePromise

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

Overrides BasePortableFakeFS.writeFilePromise
Parameters
- p: FSPath<PortablePath>
- content: string | ArrayBufferView
- optionalopts: WriteFileOptions
Returns Promise<void>

writeFileSync

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

Overrides BasePortableFakeFS.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 BasePortableFakeFS.writeJsonPromise
Parameters
- p: PortablePath
- data: any
- __namedParameters: { compact?: boolean } = {}
Returns Promise<void>

writeJsonSync

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

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

writePromise

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

Overrides BasePortableFakeFS.writePromise
Parameters
- fd: number
- buffer: Buffer
- optionaloffset: number
- optionallength: number
- optionalposition: number
Returns Promise<number>

writeSync

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

Overrides BasePortableFakeFS.writeSync
Parameters
- fd: number
- buffer: Buffer
- optionaloffset: number
- optionallength: number
- optionalposition: number
Returns number

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Returns ZipFS

Properties

publicreadonlypathUtils

Methods

accessPromise

Parameters

p: PortablePath

optionalmode: number

Returns Promise<void>

accessSync

Parameters

p: PortablePath

mode: number = constants.F_OK

Returns void

appendFilePromise

Parameters

p: FSPath<PortablePath>

content: string | Uint8Array

optionalopts: WriteFileOptions

Returns Promise<void>

appendFileSync

Parameters

p: FSPath<PortablePath>

content: string | Uint8Array

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

chmodPromise

Parameters

p: PortablePath

mask: number

Returns Promise<void>

chmodSync

Parameters

p: PortablePath

mask: number

Returns void

chownPromise

Parameters

p: PortablePath

uid: number

gid: number

Returns Promise<void>

chownSync

Parameters

p: PortablePath

uid: number

gid: number

Returns void

closePromise

Parameters

fd: number

Returns Promise<void>

closeSync

Parameters

fd: number

Returns void

copyFilePromise

Parameters