JailFS

Hierarchy

ProxiedFS<PortablePath, PortablePath>
- JailFS

Index

Constructors

constructor

Properties

pathUtils

Methods

Constructors

constructor

new JailFS(target: PortablePath, __namedParameters?: JailFSOptions): JailFS

Overrides ProxiedFS<PortablePath, PortablePath>.constructor
Parameters
- target: PortablePath
- __namedParameters: JailFSOptions = {}
Returns JailFS

Properties

publicreadonlypathUtils

pathUtils: PathUtils<PortablePath>

Methods

accessPromise

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

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

accessSync

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

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

appendFilePromise

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

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

appendFileSync

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

Inherited from ProxiedFS.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 ProxiedFS.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 ProxiedFS.changeFileSync
Parameters
- p: PortablePath
- content: Buffer
Returns void

checksumFilePromise

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

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

chmodPromise

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

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

chmodSync

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

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

chownPromise

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

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

chownSync

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

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

closePromise

closePromise(fd: number): Promise<void>

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

closeSync

closeSync(fd: number): void

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

copyFilePromise

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

Inherited from ProxiedFS.copyFilePromise
Parameters
- sourceP: PortablePath
- destP: PortablePath
- flags: number = 0
Returns Promise<void>

copyFileSync

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

Inherited from ProxiedFS.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 ProxiedFS.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 ProxiedFS.copySync
@deprecated
Prefer using copyPromise instead
Parameters
- destination: PortablePath
- source: PortablePath
- optionaloptions: { baseFs?: undefined; overwrite?: boolean }
Returns void

createReadStream

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

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

createWriteStream

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

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

existsPromise

existsPromise(p: PortablePath): Promise<boolean>

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

existsSync

existsSync(p: PortablePath): boolean

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

fchmodPromise

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

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

fchmodSync

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

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

fchownPromise

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

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

fchownSync

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

Inherited from ProxiedFS.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>

Inherited from ProxiedFS.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

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

ftruncatePromise

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

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

ftruncateSync

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

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

genTraversePromise

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

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

getBaseFs

getBaseFs(): FakeFS<PortablePath>

Returns FakeFS<PortablePath>

getExtractHint

getExtractHint(hints: ExtractHintOptions): boolean

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

getRealPath

getRealPath(): PortablePath

Overrides ProxiedFS.getRealPath
Returns PortablePath

getTarget

getTarget(): PortablePath

Returns PortablePath

linkPromise

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

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

linkSync

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

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

lockPromise

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

Inherited from ProxiedFS.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>

Inherited from ProxiedFS.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

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

lutimesPromise

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

Inherited from ProxiedFS.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

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

mkdirPromise

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

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

mkdirSync

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

Inherited from ProxiedFS.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 ProxiedFS.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 ProxiedFS.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 ProxiedFS.movePromise
Parameters
- fromP: PortablePath
- toP: PortablePath
Returns Promise<void>

moveSync

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

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

openPromise

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

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

openSync

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

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

opendirPromise

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

Inherited from ProxiedFS.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>

Inherited from ProxiedFS.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 ProxiedFS.preserveTimePromise
Parameters
- p: PortablePath
- cb: () => Promise<void | PortablePath>
Returns Promise<void>

preserveTimeSync

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

Inherited from ProxiedFS.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>

Inherited from ProxiedFS.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

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

readJsonPromise

readJsonPromise(p: PortablePath): Promise<any>

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

readJsonSync

readJsonSync(p: PortablePath): any

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

readPromise

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

Inherited from ProxiedFS.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: number): number

Inherited from ProxiedFS.readSync
Parameters
- fd: number
- buffer: Buffer
- offset: number
- length: number
- position: number
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>)[]>

Inherited from ProxiedFS.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>)[]

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

readlinkPromise

readlinkPromise(p: PortablePath): Promise<PortablePath>

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

readlinkSync

readlinkSync(p: PortablePath): PortablePath

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

realpathPromise

realpathPromise(p: PortablePath): Promise<PortablePath>

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

realpathSync

realpathSync(p: PortablePath): PortablePath

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

removePromise

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

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

removeSync

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

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

renamePromise

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

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

renameSync

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

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

resolve

resolve(path: PortablePath): PortablePath

Inherited from ProxiedFS.resolve
Parameters
- path: PortablePath
Returns PortablePath

rmPromise

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

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

rmSync

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

Inherited from ProxiedFS.rmSync
Parameters
- p: PortablePath
- optionalopts: 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>

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

rmdirSync

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

Inherited from ProxiedFS.rmdirSync
Parameters
- p: PortablePath
- optionalopts: Partial<{ maxRetries: number; recursive: boolean; retryDelay: number }>
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>

Inherited from ProxiedFS.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

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

symlinkPromise

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

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

symlinkSync

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

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

truncatePromise

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

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

truncateSync

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

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

unlinkPromise

unlinkPromise(p: PortablePath): Promise<void>

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

unlinkSync

unlinkSync(p: PortablePath): void

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

unwatchFile

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

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

utimesPromise

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

Inherited from ProxiedFS.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

Inherited from ProxiedFS.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

Inherited from ProxiedFS.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

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

writeFilePromise

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

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

writeFileSync

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

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

writeJsonSync

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

Inherited from ProxiedFS.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>

Inherited from ProxiedFS.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

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

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

target: PortablePath

__namedParameters: JailFSOptions = {}

Returns JailFS

Properties

publicreadonlypathUtils

Methods

accessPromise

Parameters

p: PortablePath

optionalmode: number

Returns Promise<void>

accessSync

Parameters

p: PortablePath

optionalmode: number

Returns void

appendFilePromise

Parameters

p: FSPath<PortablePath>

content: string | Uint8Array

optionalopts: WriteFileOptions

Returns Promise<void>

appendFileSync

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>

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