cljs-node-io.fs — com.github.pkpkpk/cljs-node-io 2.0.332

A wrapper around node's fs module.

absolute? cljs

(absolute? pathstr)

@param {!string} pathstr :: path to test @return {!boolean} is pathstr an absolute path

achmod cljs

(achmod pathstr mode)

Asynchronous chmod {@link https://nodejs.org/api/fs.html#fschmodpath-mode-callback} @param {!(string|Buffer|URL)} pathstr @param {!Number} mode :: must be an integer @return {!Channel} yielding [?err]

achown cljs

(achown pathstr uid gid)

Asynchronous chown {@link https://nodejs.org/api/fs.html#fschownpath-uid-gid-callback} @param {!(string|Buffer|URL)} pathstr @param {!Number} uid @param {!Number} gid @return {!Channel} yielding [?err]

aclose cljs

(aclose fd)

Asynchronously close a file-descriptor {@link https://nodejs.org/api/fs.html#fsclosefd-callback} @param {Number} fd :: the file descriptor to close @return {Channel} yielding [?err]

acopy-file cljs

(acopy-file src dst)

(acopy-file src dst mode)

Asynchronously copy file from src to dst. By default dst is overwritten. {@link https://nodejs.org/api/fs.html#fscopyfilesrc-dest-mode-callback} @param {(string|buffer.Buffer|URL)} src @param {(string|buffer.Buffer|URL)} dst @return {!Channel} yielding [?err]

acrawl cljs

(acrawl root af)

Asynchronous depth-first recursive crawl through a directory tree, calling the supplied potentially side-effecting function on every node. This function will short and return on an error.

The user supplied function must return a 'result-chan'...a Readport/channel yielding [?err, ?ok]. There is no easy way to get the compiler to enforce this!

@param {!string} root :: where to start the crawl. A file simply returns (af root) @param {!function<string>} af :: async function called on both files & directories @return {!Channel} yields a short circuited [err] or [nil ok]. This depends on the user following the result chan conventions.

adir? cljs

(adir? pathstr)

Asynchronous directory predicate. @param {!(string|Buffer|URL)} pathstr @return {!Channel} yielding boolean

aexecutable? cljs

(aexecutable? pathstr)

Asynchronously test if a file is executable to the process @param {!(string|Buffer|URL)} pathstr :: path to test for process execute permission @return {!Channel} yielding boolean

aexists? cljs

(aexists? pathstr)

Asynchronously test if a file or directory exists @param {!(string|Buffer|URL)} pathstr @return {!Channel} yielding boolean

afexists? cljs

@deprecated

afile? cljs

(afile? pathstr)

Asynchronous file predicate. @param {!(string|Buffer|URL)} pathstr @return {!Channel} yielding boolean

afstat cljs

(afstat fd)

Asynchronously retrieve a stats map from the file descriptor {@link https://nodejs.org/api/fs.html#fsfstatfd-options-callback} @param {!Number} fd @param {!Channel} yielding [?err edn-stats]

afsync cljs

(afsync fd)

Asynchronously flush to storage {@link https://nodejs.org/api/fs.html#fsfsyncfd-callback} @param {!Number} fd @return {Channel} yielding [?err]

aftruncate cljs

(aftruncate fd)

(aftruncate fd len)

Asynchronous ftruncate {@link https://nodejs.org/api/fs.html#fsftruncatefd-len-callback} @param {!Number} fd @param {?Number} len @return {!Channel} yielding [?err]

alchown cljs

(alchown pathstr uid gid)

Asynchronous lchown {@link https://nodejs.org/api/fs.html#fslchownpath-uid-gid-callback} @param {!(string|Buffer|URL)} pathstr @param {!Number} uid @param {!Number} gid @return {!Channel} yielding [?err]

alink cljs

(alink src dst)

Asynchronously creates a new link from the src to dst. Will not overwrite newpath if it exists. {@link https://nodejs.org/api/fs.html#fslinkexistingpath-newpath-callback} @param {!(string|Buffer|URL)} src @param {!(string|Buffer|URL)} dst @return {!Channel} yielding [?err]

alock-file cljs

(alock-file pathstr)

Attempts to asynchronously open a lock-file exclusively. This prevents future openings until the holding lock has been released, thereby can use to prevent reads and writes within a process. A yielded err indicates a failure to obtain a lock, & AsyncLockFile is a record with .release() method to unlock the file, returning a promise-chan yielding [?err] @param {string} pathstr :: the file you want to lock @return {Channel} yielding [?err ?AsyncLockFile]

alstat cljs

(alstat pathstr)

Asynchronous lstat @param {!(string|Buffer|URL)} pathstr @return {!Channel} yielding [?err ?edn-stats]

alutimes cljs

(alutimes pathstr atime mtime)

asynchronous lutimes

• same as utimes but symbolic links are not derefed
• If the value is NaN or Infinity, the value would get converted to Date.now()
• numerable strings ie '12235' are converted to numbers {@link https://nodejs.org/api/fs.html#fslutimespath-atime-mtime-callback} @param {!(string|Buffer|URL)} pathstr @param {(string|Number)} atime @param {(string|Number)} mtime @return {!Channel} yielding [?err]

amkdir cljs

(amkdir pathstr)

(amkdir pathstr opts)

Asynchronously create a directory {@link https://nodejs.org/api/fs.html#fsmkdirpath-options-callback} @param {!(string|Buffer|URL)} pathstr :: path of directory to create @param {?IMap} opts :recursive (boolean) -> the first directory path created. :mode (string|number) @return {!Channel} yielding [?err]

aopen cljs

(aopen pathstr)

(aopen pathstr flags)

(aopen pathstr flags mode)

Asynchronously open a file-descriptor {@link https://nodejs.org/api/fs.html#fsopenpath-flags-mode-callback} @param {!string} pathstr @return {!Channel} yielding [?err ?fd]

aread cljs

(aread fd opts)

(aread fd buffer opts)

(aread fd buffer offset length position)

Asynchronously read data from the fd into the specified buffer {@link https://nodejs.org/api/fs.html#fsreadfd-buffer-offset-length-position-callback} Can pass arguments individually or as a map: :buffer (Buffer|ArrayBuffer) - where data will be written :offset (Number) - where to start writing in the buffer :length (Number) - how many bytes to read from fd :pos (Number|Bigint) - Where to begin reading. if -1 reads from current-pos @return {!Channel} yielding [?err bytes-read buffer]

aread-file cljs

(aread-file pathstr enc)

@param {!string} pathstr @param {!string} enc :: if "" (an explicit empty string) => raw buffer @return {!Channel} yielding [?err (str|Buffer)]

areadable? cljs

(areadable? pathstr)

Asynchronously test if a file is readable to the process @param {!(string|Buffer|URL)} pathstr @return {!Channel} yielding boolean

areaddir cljs

(areaddir dirpath)

(areaddir dirpath opts)

Asynchronously reads directory content {@link https://nodejs.org/api/fs.html#fsreaddirpath-options-callback} @param {!(string|Buffer|URL)} dirpath :: directory path to read @param {?IMap} opts :: options :encoding (string) -> defaults to 'utf8' :withFileTypes (bool) -> return fs.Dirent objects instead of strings. see {@link https://nodejs.org/api/fs.html#class-fsdirent} @return {!Channel} yielding [?err, ?Vector<string|fs.Dirent>]

areadlink cljs

(areadlink pathstr)

Asynchronous readlink. Reads the contents of the symbolic link referred to by path. {@link https://nodejs.org/api/fs.html#fsreadlinkpath-options-callback} @param {!(string|Buffer|URL)} pathstr :: the symbolic link to read @return {!Channel} yielding [?err ?linkstring]

arealpath cljs

(arealpath pathstr)

Asynchronous realpath. Computes the canonical pathname by resolving ., .., and symbolic links. {@link https://nodejs.org/api/fs.html#fsrealpathpath-options-callback} @param {!(string|Buffer|URL)} pathstr @return {!Channel} yielding [?err ?resolvedPathstr]

arename cljs

(arename oldpathstr newpathstr)

Asynchronously rename a file {@link https://nodejs.org/api/fs.html#fsrenameoldpath-newpath-callback} @param {!(string|Buffer|URL)} oldpathstr :: file to rename @param {!(string|Buffer|URL)} newpathstr :: what to rename it to @return {!Channel} yielding [?err]

arm cljs

(arm pathstr)

Asynchronously delete the file or directory path @param {!(string|Buffer|URL)} pathstr @return {!Channel} yielding [?err]

arm-f cljs

(arm-f pathstr)

Asynchronously delete the file or directory path Ignores paths that do not exist. @param {!(string|Buffer|URL)} pathstr @return {!Channel} yielding [?err]

arm-r cljs

(arm-r pathstr)

Asynchronous recursive delete. Ignores paths that do not exist. Crawls in order provided by readdir and makes unlink/rmdir calls sequentially after the previous has completed. Breaks on any err which is returned as [err] Returns err on does not exist. @param {!(string|Buffer|URL)} pathstr @return {!Channel} yielding [?err]

arm-rf cljs

(arm-rf pathstr)

Asynchronous recursive delete. Ignores paths that do not exist. Crawls in order provided by readdir and makes unlink/rmdir calls sequentially after the previous has completed. Breaks on any err which is returned as [err] Returns err on does not exist. @param {!(string|Buffer|URL)} pathstr @return {!Channel} yielding [?err]

armdir cljs

(armdir pathstr)

(armdir pathstr opts)

Asynchronously remove a directory {@link https://nodejs.org/api/fs.html#fsrmdirpath-options-callback} @param {!(string|Buffer|URL)} pathstr :: path of directory to remove @param {?IMap} opts :maxRetries (number) :retryDelay (number) @return {!Channel} yielding [?err]

astat cljs

(astat pathstr)

Asynchronous stat @param {!(string|Buffer|URL)} pathstr @return {!Channel} yielding [?err ?edn-stats]

asymlink cljs

(asymlink targetstr pathstr)

(asymlink targetstr pathstr link_type)

Synchronous symlink. {@link https://nodejs.org/api/fs.html#fssymlinktarget-path-type-callback} @param {!(string|Buffer|URL)} targetstr :: what gets pointed to @param {!(string|Buffer|URL)} pathstr :: the new symbolic link that points to target @param {?string} link_type ::'file' or 'dir' @return {!Channel} yielding [?err]

asymlink? cljs

(asymlink? pathstr)

Asynchronously test if path is a symbolic link @param {!(string|Buffer|URL)} pathstr :: path to test @return {!Channel} yielding boolean

AsyncLockFile cljs

atouch cljs

(atouch pathstr)

creates a file if non-existent @param {!string} pathstr @return {!Channel} yielding [?err]

atruncate cljs

(atruncate pathstr)

(atruncate pathstr len)

Asynchronous truncate {@link https://nodejs.org/api/fs.html#fstruncatepath-len-callback} @param {!(string|Buffer|URL)} pathstr @param {?number} len @return {!Channel} yielding [?err]

aunlink cljs

(aunlink pathstr)

Asynchronously unlink a file {@link https://nodejs.org/api/fs.html#fsunlinkpath-callback} @param {!(string|Buffer|URL)} pathstr :: path of file to unlink @return {!Channel} yielding [?err]

autimes cljs

(autimes pathstr atime mtime)

asynchronous utimes. Change the file system timestamps of the object referenced by path.

• If the value is NaN or Infinity, the value would get converted to Date.now()
• numerable strings ie '12235' are converted to numbers {@link https://nodejs.org/api/fs.html#fsutimespath-atime-mtime-callback} @param {!(string|Buffer|URL)} pathstr @param {(string|Number)} atime @param {(string|Number)} mtime @return {!Channel} yielding [?err]

awritable? cljs

(awritable? pathstr)

Asynchronously test if a file is writable to the process @param {!(string|Buffer|URL)} pathstr :: path to test for process write permission @return {!Channel} yielding boolean

awrite cljs

(awrite fd opts)

(awrite fd buffer opts)

(awrite fd buffer offset length position)

Asynchronously write data from the buffer to the fd {@link https://nodejs.org/api/fs.html#fswritesyncfd-buffer-offset-length-position} Can pass arguments individually or as a map: :buffer (Buffer|ArrayBuffer) - data to be written :offset (Number) - where to start reading in the buffer :length (Number) - how many bytes to read :pos (Number|Bigint) - where to begin writing in the fd @return {!Channel} yielding [?err bytes-written buffer]

awrite-file cljs

(awrite-file pathstring content opts)

Asynchronously write to a file. @param {!string} pathstring : file to write to @param {(string|buffer.Buffer)} content : if buffer, :encoding is ignored @param {?IMap} opts : :encoding {string}, :append {bool}, :flags {string}, :mode {int}

• flags override append @return {!Channel} promise-chan recieving [?err]

basename cljs

(basename pathstring)

(basename pathstring ext)

@return {!string}

chmod cljs

(chmod pathstr mode)

Synchronous chmod {@link https://nodejs.org/api/fs.html#fsfchmodsyncfd-mode} @param {!(string|Buffer|URL)} pathstr @param {!Number} mode :: must be an integer @return {nil}

chown cljs

(chown pathstr uid gid)

Synchronous chown {@link https://nodejs.org/api/fs.html#fschownsyncpath-uid-gid} @param {!(string|Buffer|URL)} pathstr @param {!Number} uid @param {!Number} gid @return {nil}

close cljs

(close fd)

Synchronously close a file-descriptor {@link https://nodejs.org/api/fs.html#fsclosesyncfd} @param {Number} fd :: the file descriptor to close @return {nil}

copy-file cljs

(copy-file src dst)

(copy-file src dst mode)

Synchronously copy file from src to dst. By default dst is overwritten. {@link https://nodejs.org/api/fs.html#fscopyfilesyncsrc-dest-mode} @param {(string|buffer.Buffer|URL)} src @param {(string|buffer.Buffer|URL)} dst @return {nil}

crawl cljs

(crawl root f)

Synchronous depth-first recursive crawl through a directory tree, calling the supplied side-effecting function on every node. This function will throw if your supplied f throws on any node. @param {!string} root :: where to start the crawl. A file simply returns (f root) @param {!function<string>} f :: function called on both files & directories returns value of (f top-level-root)

dir? cljs

(dir? pathstr)

@param {!(string|Buffer|URL)} pathstring @return {!boolean} iff abstract pathname exists and is a directory

dirname cljs

(dirname pathstring)

@param {!string} pathstring :: path to get parent of @return {!string} the parent directory

executable? cljs

(executable? pathstr)

@param {!(string|Buffer|URL)} pathstr :: path to test for process executable permission @return {!boolean}

exists? cljs

(exists? pathstr)

Synchronously test if a file or directory exists @param {!(string|Buffer|URL)} pathstr :: file path to test @return {!boolean}

ext cljs

(ext pathstring)

@param {!string} pathstring :: file to get extension from @return {!string}

fexists? cljs

@deprecated

file? cljs

(file? pathstr)

Synchronous file predicate @param {!(string|Buffer|URL)} pathstring @return {!boolean} iff abstract pathname exists and is a file

fs cljs

fstat cljs

(fstat fd)

Synchronously retrieve a stats map from the file descriptor {@link https://nodejs.org/api/fs.html#fsfstatsyncfd-options} @param {!Number} fd @return {!IMap} edn stats

fsync cljs

(fsync fd)

Synchronously flush to storage {@link https://nodejs.org/api/fs.html#fsfstatsyncfd-options} @param {!Number} fd @return {nil}

ftruncate cljs

(ftruncate fd)

(ftruncate fd len)

Synchronous ftruncate {@link https://nodejs.org/api/fs.html#fsftruncatesyncfd-len} @param {!Number} fd @param {?Number} len @return {nil}

gid-uid cljs

(gid-uid)

@return {!IMap}

hidden? cljs

(hidden? pathstr)

@param {!(string|Buffer|URL)} pathstr @return {!boolean} is the file hidden (unix only)

lchown cljs

(lchown pathstr uid gid)

Synchronous lchown {@link https://nodejs.org/api/fs.html#fslchownsyncpath-uid-gid} @param {!(string|Buffer|URL)} pathstr @param {!Number} uid @param {!Number} gid @return {nil}

link cljs

(link src dst)

Synchronously creates a new link from the src to dst Will not overwrite newpath if it exists. {@link https://nodejs.org/api/fs.html#fslinksyncexistingpath-newpath} @param {!(string|Buffer|URL)} src @param {!(string|Buffer|URL)} dst @return {nil}

lock-file cljs

(lock-file pathstr)

Attempts to synchronously open a lock-file exclusively. This prevents future openings until the holding lock has been released, thereby can use to prevent reads and writes within a process. If a lock is already held, will throw @param {string} pathstr :: the file you want to lock @return {LockFile} record with .release() method to unlock the file

lock-path cljs

(lock-path pathstr)

LockFile cljs

lstat cljs

(lstat pathstr)

Synchronous lstat identical to stat(), except that if path is a symbolic link, then the link itself is stat-ed, not the file that it refers to @param {!(string|Buffer|URL)} pathstr @return {!IMap} file stats object converted to edn

lutimes cljs

(lutimes pathstr atime mtime)

synchronous lutimes

• same as utimes but symbolic links are not derefed
• If the value is NaN or Infinity, the value would get converted to Date.now()
• numerable strings ie '12235' are converted to numbers {@link https://nodejs.org/api/fs.html#fslutimessyncpath-atime-mtime} @param {!(string|Buffer|URL)} pathstr @param {(string|Number)} atime @param {(string|Number)} mtime @return {nil}

mkdir cljs

(mkdir pathstr)

(mkdir pathstr opts)

Synchronously create a directory {@link https://nodejs.org/api/fs.html#fsmkdirsyncpath-options} @param {!(string|Buffer|URL)} pathstr :: path of directory to create @param {?IMap} opts :recursive (boolean) -> the first directory path created. :mode (string|Number) @return {nil}

normalize-path cljs

(normalize-path pathstring)

@param {!string} pathstring :: pathstring to normalize @return {!string}

open cljs

(open pathstr)

(open pathstr flags)

(open pathstr flags mode)

Synchronously open a file-descriptor {@link https://nodejs.org/api/fs.html#fsopenpath-flags-mode-callback} @param {!string} pathstr @return {!Number} integer file-descriptor

path cljs

permissions cljs

(permissions st)

@param {!(fs.Stat|IMap)} s :: a fs.Stats object (or as edn) @return {!Number}

read cljs

(read fd opts)

(read fd buffer opts)

(read fd buffer offset length position)

Synchronously read data from the fd into the specified buffer {@link https://nodejs.org/api/fs.html#fsreadsyncfd-buffer-offset-length-position} Can pass arguments individually or as a map: :buffer (Buffer|ArrayBuffer) - where data will be written :offset (Number) - where to start writing in the buffer :length (Number) - how many bytes to read from fd :pos (Number|Bigint) - Where to begin reading. if -1 reads from current-pos @return {!Number} number of bytes read

read-file cljs

(read-file pathstr enc)

@param {!string} pathstr :: the file path to read @param {!string} enc :: encoding , if "" (an explicit empty string), => raw buffer @return {(buffer.Buffer|string)}

readable? cljs

(readable? pathstr)

Synchronously test if a file is readable to the process @param {!(string|Buffer|URL)} pathstr :: path to test for process read permission @return {!boolean}

readdir cljs

(readdir dirpath)

(readdir dirpath opts)

Synchronously reads directory content {@link https://nodejs.org/api/fs.html#fsreaddirsyncpath-options} @param {!(string|Buffer|URL)} dirpath :: directory path to read @param {?IMap} opts :: options :encoding (string) -> defaults to 'utf8' :withFileTypes (bool) -> return fs.Dirent objects instead of strings. see {@link https://nodejs.org/api/fs.html#class-fsdirent} @return {!IVector} Vector<strings> representing directory content

readline cljs

(readline pathstr)

A simple file line reader. @param {!string} pathstr @return {!Channel} chan receiving [?err ?line] until file is consumed, and then the channel closes.

readlink cljs

(readlink pathstr)

Synchronous readlink. Reads the contents of the symbolic link referred to by path. {@link https://nodejs.org/api/fs.html#fsreadlinksyncpath-options} @param {!(string|Buffer|URL)} pathstr :: the symbolic link to read @return {!string} the symbolic link's string value

realpath cljs

(realpath pathstr)

Synchronous realpath Computes the canonical pathname by resolving ., .., and symbolic links. {@link https://nodejs.org/api/fs.html#fsrealpathsyncpath-options} @param {!(string|Buffer|URL)} pathstr @return {!string} resolved path

rename cljs

(rename oldpathstr newpathstr)

Synchronously rename a file. {@link https://nodejs.org/api/fs.html#fsrenamesyncoldpath-newpath} @param {!(string|Buffer|URL)} oldpathstr :: file to rename @param {!(string|Buffer|URL)} newpathstr :: what to rename it to @return {nil}

resolve-path cljs

(resolve-path & paths)

@return {!string}

rl cljs

rm cljs

(rm pathstr)

Synchronously delete the file or directory path @param {!string} pathstr :: can be file or directory @return {nil}

rm-f cljs

(rm-f pathstr)

Synchronously delete the file or directory path Ignores paths that do not exist. @param {!string} pathstr :: can be file or directory @return {nil}

rm-r cljs

(rm-r pathstr)

Synchronous recursive delete. Throws when doesnt exist @param {!(string|Buffer|URL)} pathstr :: file/dir to recursively delete. @return {nil}

rm-rf cljs

(rm-rf pathstr)

Synchronous recursive delete. Ignores paths that do not exist. @param {!(string|Buffer|URL)} pathstr :: file/dir to recursively delete. @return {nil}

rmdir cljs

(rmdir pathstr)

(rmdir pathstr opts)

Synchronously remove a directory. {@link https://nodejs.org/api/fs.html#fsrmdirsyncpath-options} @param {!(string|Buffer|URL)} pathstr :: path of directory to remove @param {?IMap} opts :maxRetries (number) :retryDelay (number) @return {nil}

sep cljs

@type {!string}

stat cljs

(stat pathstr)

Synchronous stat @param {!(string|Buffer|URL)} pathstring @return {!IMap} file stats object converted to edn

symlink cljs

(symlink target pathstr)

(symlink target pathstr link_type)

Synchronous symlink. {@link https://nodejs.org/api/fs.html#fssymlinksynctarget-path-type} @param {!(string|Buffer|URL)} target :: what gets pointed to @param {!(string|Buffer|URL)} pathstr :: the new symbolic link that points to target @param {?string} link_type ::'file' or 'dir' @return {nil}

symlink? cljs

(symlink? pathstr)

Synchronous test for symbolic link @param {!(string|Buffer|URL)} pathstr :: path to test @return {!boolean}

touch cljs

(touch pathstr)

Creates a file if non-existent @param {!string} pathstr @return {nil}

truncate cljs

(truncate pathstr)

(truncate pathstr length)

Synchronous truncate {@link https://nodejs.org/api/fs.html#fstruncatesyncpath-len} @param {!(string|Buffer|URL)} pathstr @param {?number} length @return {nil}

unlink cljs

(unlink pathstr)

Synchronously unlink a file. {@link https://nodejs.org/api/fs.html#fsunlinksyncpath} @param {!(string|Buffer|URL)} pathstr :: path of file to unlink @return {nil}

unwatchFile cljs

(unwatchFile pathstr)

remove all watchers from a file @param {!string} pathstr @return {nil}

utimes cljs

(utimes pathstr atime mtime)

synchronous utimes Change the file system timestamps of the object referenced by path.

• If the value is NaN or Infinity, the value would get converted to Date.now()
• numerable strings ie '12235' are converted to numbers {@link https://nodejs.org/api/fs.html#fsutimessyncpath-atime-mtime} @param {!(string|Buffer|URL)} pathstr @param {(string|Number)} atime @param {(string|Number)} mtime @return {nil}

watch cljs

(watch filename)

(watch filename opts)

Watch a file or directory. Make note of caveats https://nodejs.org/api/fs.html#fs_caveats events : 'rename', 'change' , 'error', 'close' opts : :peristent {boolean} (true) :: whether the process should continue as long as files are being watched. :recursive {boolean} (false) :: watch subdirectories :buf-or-n {(impl/Buffer|number)} (10) :: channel buffer :encoding {string} ('utf8') :: used to interpret passed filename @return {!Watcher}

Watcher cljs

watcher->ch cljs

(watcher->ch FSWatcher out-ch)

(watcher->ch FSWatcher out-ch {:keys [key buf-or-n] :or {buf-or-n 10}})

watchFile cljs

(watchFile filename)

(watchFile filename opts)

Prefer watch. Polls files and returns stat objects. Opts: :peristent {boolean} (true) :: whether the process should continue as long as files are being watched. :interval {number} (5007) :: polling interval in msecs :buf-or-n {(impl/Buffer|number)} (10) :: channel buffer @return {!Channel} yielding [filename [current fs.stat, previous fs.stat]]

writable? cljs

(writable? pathstr)

Synchronously test if a file is writable to the process @param {!(string|Buffer|URL)} pathstr :: path to test for process write permission @return {!boolean}

write cljs

(write fd opts)

(write fd buffer opts)

(write fd buffer offset length position)

Synchronously write data from the buffer to the fd {@link https://nodejs.org/api/fs.html#fswritesyncfd-buffer-offset-length-position} Can pass arguments individually or as a map: :buffer (Buffer|ArrayBuffer) - data to be written :offset (Number) - where to start reading in the buffer :length (Number) - how many bytes to read :pos (Number|Bigint) - where to begin writing in the fd @return {!Number} number of bytes written

write-file cljs

(write-file pathstr content opts)

synchronously writes content to file represented by pathstring. @param {!string} pathstr :: file to write to @param {(string|buffer.Buffer)} content :: if buffer, :encoding is ignored @param {?IMap} opts :: {:encoding {string}, :append {boolean}, :flags {string}, :mode {int}}

• flags override append
• :encoding defaults to utf8 @return {nil}