ngs - v1.0.6

njs/fs

Types

Dirent

</> 
pub type Dirent

FileHandle

</> 
pub type FileHandle

FileOption

</> 
pub type FileOption {
  ReadFileOption(encoding: String, flag: String)
  WriteFileOption(mode: Int, flag: String)
}

Constructors 

  • ReadFileOption(encoding: String, flag: String)
  • WriteFileOption(mode: Int, flag: String)

FileReadResult

</> 
pub type FileReadResult {
  FileReadResult(bytes_read: Int, buffer: buffer.Buffer)
}

Constructors

Stats

</> 
pub type Stats

Values

access

</> 
pub fn access(
  path: String,
  mode: Int,
) -> promise.Promise(Result(Bool, Nil))

access_sync

</> 
pub fn access_sync(path: String, mode: Int) -> Result(Bool, Nil)

append_file

</> 
pub fn append_file(
  filename f: String,
  data d: a,
  option o: FileOption,
) -> promise.Promise(Nil)

append_file_sync

</> 
pub fn append_file_sync(
  filename f: String,
  data d: a,
  option o: FileOption,
) -> Nil

base64

</> 
pub const base64: String

base64url

</> 
pub const base64url: String

buf

</> 
pub const buf: String

close

</> 
pub fn close(fd: Int) -> promise.Promise(Nil)

close_sync

</> 
pub fn close_sync(fd: Int) -> Nil

constants_f_ok

</> 
pub fn constants_f_ok() -> Int

constants_r_ok

</> 
pub fn constants_r_ok() -> Int

constants_w_ok

</> 
pub fn constants_w_ok() -> Int

constants_x_ok

</> 
pub fn constants_x_ok() -> Int

dirent_is_block_device

</> 
pub fn dirent_is_block_device(dirent: Dirent) -> Bool

dirent_is_character_device

</> 
pub fn dirent_is_character_device(dirent: Dirent) -> Bool

dirent_is_directory

</> 
pub fn dirent_is_directory(dirent: Dirent) -> Bool

dirent_is_fifo

</> 
pub fn dirent_is_fifo(dirent: Dirent) -> Bool

dirent_is_file

</> 
pub fn dirent_is_file(dirent: Dirent) -> Bool

dirent_is_socket

</> 
pub fn dirent_is_socket(dirent: Dirent) -> Bool
</> 
pub fn dirent_is_symbolic_link(dirent: Dirent) -> Bool

dirent_name

</> 
pub fn dirent_name(dirent: Dirent) -> String

exists

</> 
pub fn exists(path: String) -> promise.Promise(Bool)

exists_sync

</> 
pub fn exists_sync(path: String) -> Bool

file_handle_close

</> 
pub fn file_handle_close(
  handle: FileHandle,
) -> promise.Promise(Nil)

file_handle_fd

</> 
pub fn file_handle_fd(handle: FileHandle) -> Int

file_handle_read

</> 
pub fn file_handle_read(
  handle: FileHandle,
  length: Int,
  position: Int,
) -> promise.Promise(FileReadResult)

file_handle_stat

</> 
pub fn file_handle_stat(
  handle: FileHandle,
) -> promise.Promise(Stats)

file_handle_write

</> 
pub fn file_handle_write(
  handle: FileHandle,
  buffer: buffer.Buffer,
  offset: Int,
  length: Int,
  position: Int,
) -> promise.Promise(FileReadResult)

flag_a

</> 
pub const flag_a: String

flag_aplus

</> 
pub const flag_aplus: String

flag_as

</> 
pub const flag_as: String

flag_asplus

</> 
pub const flag_asplus: String

flag_ax

</> 
pub const flag_ax: String

flag_axplus

</> 
pub const flag_axplus: String

flag_r

</> 
pub const flag_r: String

flag_rplus

</> 
pub const flag_rplus: String

flag_rs

</> 
pub const flag_rs: String

flag_rsplus

</> 
pub const flag_rsplus: String

flag_w

</> 
pub const flag_w: String

flag_wplus

</> 
pub const flag_wplus: String

flag_wx

</> 
pub const flag_wx: String

flag_wxplus

</> 
pub const flag_wxplus: String

fstat

</> 
pub fn fstat(fd: Int) -> promise.Promise(Stats)

fstat_sync

</> 
pub fn fstat_sync(fd: Int) -> Stats

hex

</> 
pub const hex: String

lstat

</> 
pub fn lstat(path: String) -> promise.Promise(Result(Stats, Nil))

lstat_sync

</> 
pub fn lstat_sync(path: String) -> Result(Stats, Nil)

mkdir

</> 
pub fn mkdir(path: String, mode: Int) -> promise.Promise(Nil)

mkdir_sync

</> 
pub fn mkdir_sync(path: String, mode: Int) -> Nil

open

</> 
pub fn open(
  path: String,
  flags: String,
  mode: Int,
) -> promise.Promise(FileHandle)

open_sync

</> 
pub fn open_sync(path: String, flags: String, mode: Int) -> Int

read

</> 
pub fn read(
  fd d: Int,
  length l: Int,
  position p: Int,
) -> promise.Promise(FileReadResult)

read_dir

</> 
pub fn read_dir(
  path p: String,
  encoding e: String,
) -> promise.Promise(array.Array(Dirent))

read_dir_sync

</> 
pub fn read_dir_sync(
  path p: String,
  encoding e: String,
) -> array.Array(Dirent)

read_file

</> 
pub fn read_file(
  filename f: String,
  option o: FileOption,
) -> promise.Promise(String)

read_file_sync

</> 
pub fn read_file_sync(
  filename f: String,
  option o: FileOption,
) -> String
</> 
pub fn read_link(
  path: String,
  encoding: String,
) -> promise.Promise(a)
</> 
pub fn read_link_sync(path: String, encoding: String) -> a

read_sync

</> 
pub fn read_sync(
  fd d: Int,
  length l: Int,
  position p: Int,
) -> FileReadResult

real_path

</> 
pub fn real_path(
  path: String,
  encoding: String,
) -> promise.Promise(String)

real_path_sync

</> 
pub fn real_path_sync(path: String, encoding: String) -> String

rename

</> 
pub fn rename(
  old_path: String,
  new_path: String,
) -> promise.Promise(Nil)

rename_sync

</> 
pub fn rename_sync(old_path: String, new_path: String) -> Nil

rmdir

</> 
pub fn rmdir(path: String) -> promise.Promise(Nil)

rmdir_sync

</> 
pub fn rmdir_sync(path: String) -> Nil

stat

</> 
pub fn stat(path: String) -> promise.Promise(Result(Stats, Nil))

stat_sync

</> 
pub fn stat_sync(path: String) -> Result(Stats, Nil)

stats_atime

</> 
pub fn stats_atime(stats: Stats) -> String

stats_atime_ms

</> 
pub fn stats_atime_ms(stats: Stats) -> Int

stats_birthtime

</> 
pub fn stats_birthtime(stats: Stats) -> String

stats_birthtime_ms

</> 
pub fn stats_birthtime_ms(stats: Stats) -> Int

stats_blksize

</> 
pub fn stats_blksize(stats: Stats) -> Int

stats_blocks

</> 
pub fn stats_blocks(stats: Stats) -> Int

stats_ctime

</> 
pub fn stats_ctime(stats: Stats) -> String

stats_ctime_ms

</> 
pub fn stats_ctime_ms(stats: Stats) -> Int

stats_dev

</> 
pub fn stats_dev(stats: Stats) -> Int

stats_gid

</> 
pub fn stats_gid(stats: Stats) -> Int

stats_ino

</> 
pub fn stats_ino(stats: Stats) -> Int

stats_is_block_device

</> 
pub fn stats_is_block_device(stats: Stats) -> Bool

stats_is_directory

</> 
pub fn stats_is_directory(stats: Stats) -> Bool

stats_is_fifo

</> 
pub fn stats_is_fifo(stats: Stats) -> Bool

stats_is_file

</> 
pub fn stats_is_file(stats: Stats) -> Bool

stats_is_socket

</> 
pub fn stats_is_socket(stats: Stats) -> Bool
</> 
pub fn stats_is_symbolic_link(stats: Stats) -> Bool

stats_mode

</> 
pub fn stats_mode(stats: Stats) -> Int

stats_mtime

</> 
pub fn stats_mtime(stats: Stats) -> String

stats_mtime_ms

</> 
pub fn stats_mtime_ms(stats: Stats) -> Int
</> 
pub fn stats_nlink(stats: Stats) -> Int

stats_rdev

</> 
pub fn stats_rdev(stats: Stats) -> Int

stats_size

</> 
pub fn stats_size(stats: Stats) -> Int

stats_uid

</> 
pub fn stats_uid(stats: Stats) -> Int
</> 
pub fn symlink(
  target: String,
  path: String,
) -> promise.Promise(Nil)
</> 
pub fn symlink_sync(target: String, path: String) -> Nil
</> 
pub fn unlink(path: String) -> promise.Promise(Nil)
</> 
pub fn unlink_sync(path: String) -> Nil

utf8

</> 
pub const utf8: String

write

</> 
pub fn write(
  fd: Int,
  buffer: buffer.Buffer,
  offset: Int,
  length: Int,
  position: Int,
) -> promise.Promise(Int)

write_file

</> 
pub fn write_file(
  filename f: String,
  data d: a,
  option o: FileOption,
) -> promise.Promise(Nil)

write_file_sync

</> 
pub fn write_file_sync(
  filename f: String,
  data d: a,
  option o: FileOption,
) -> Nil

write_sync

</> 
pub fn write_sync(
  fd: Int,
  buffer: buffer.Buffer,
  offset: Int,
  length: Int,
  position: Int,
) -> Int
✨ Search Document