dwindown/formipay
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d1de0015be1c19a073e4ad66cbb676283f5d47b5
formipay/node_modules/bare-fs/README.md
dwindown e8fbfb14c1 fix: prevent asset conflicts between React and Grid.js versions 
Add coexistence checks to all enqueue methods to prevent loading
both React and Grid.js assets simultaneously.

Changes:
- ReactAdmin.php: Only enqueue React assets when ?react=1
- Init.php: Skip Grid.js when React active on admin pages
- Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0
- Customer.php, Product.php, License.php: Add coexistence checks

Now the toggle between Classic and React versions works correctly.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
2026-04-18 17:02:14 +07:00

990 lines
21 KiB
Markdown
Raw Blame History

# bare-fs
Native file system operations for Bare. The API closely follows that of the Node.js `fs` module.
```
npm i bare-fs
```
## Usage
```js
const fs = require('bare-fs')
const fd = await fs.open('hello.txt')
const buffer = Buffer.alloc(1024)
try {
const length = await fs.read(fd, buffer)
console.log('Read', length, 'bytes')
} finally {
await fs.close(fd)
}
```
## API
#### `const fd = await fs.open(filepath[, flags[, mode]])`
Open a file, returning a file descriptor. `flags` defaults to `'r'` and `mode` defaults to `0o666`. `flags` may be a string such as `'r'`, `'w'`, `'a'`, `'r+'`, etc., or a numeric combination of `fs.constants` flags.
#### `fs.open(filepath[, flags[, mode]], callback)`
Callback version of `fs.open()`.
#### `const fd = fs.openSync(filepath[, flags[, mode]])`
Synchronous version of `fs.open()`.
#### `await fs.close(fd)`
Close a file descriptor.
#### `fs.close(fd, callback)`
Callback version of `fs.close()`.
#### `fs.closeSync(fd)`
Synchronous version of `fs.close()`.
#### `await fs.access(filepath[, mode])`
Check whether the file at `filepath` is accessible. `mode` defaults to `fs.constants.F_OK`.
#### `fs.access(filepath[, mode], callback)`
Callback version of `fs.access()`.
#### `fs.accessSync(filepath[, mode])`
Synchronous version of `fs.access()`.
#### `const exists = await fs.exists(filepath)`
Check whether a file exists at `filepath`. Returns `true` if the file is accessible, `false` otherwise.
#### `fs.exists(filepath, callback)`
Callback version of `fs.exists()`.
#### `const exists = fs.existsSync(filepath)`
Synchronous version of `fs.exists()`.
#### `const bytesRead = await fs.read(fd, buffer[, offset[, len[, pos]]])`
Read from a file descriptor into `buffer`. `offset` defaults to `0`, `len` defaults to `buffer.byteLength - offset`, and `pos` defaults to `-1` (current position). Returns the number of bytes read.
#### `fs.read(fd, buffer[, offset[, len[, pos]]], callback)`
Callback version of `fs.read()`.
#### `const bytesRead = fs.readSync(fd, buffer[, offset[, len[, pos]]])`
Synchronous version of `fs.read()`.
#### `const bytesRead = await fs.readv(fd, buffers[, pos])`
Read from a file descriptor into an array of `buffers`. `pos` defaults to `-1`.
#### `fs.readv(fd, buffers[, pos], callback)`
Callback version of `fs.readv()`.
#### `const bytesRead = fs.readvSync(fd, buffers[, pos])`
Synchronous version of `fs.readv()`.
#### `const bytesWritten = await fs.write(fd, data[, offset[, len[, pos]]])`
Write `data` to a file descriptor. When `data` is a string, the signature is `fs.write(fd, data[, pos[, encoding]])` where `encoding` defaults to `'utf8'`. Returns the number of bytes written.
#### `fs.write(fd, data[, offset[, len[, pos]]], callback)`
Callback version of `fs.write()`.
#### `const bytesWritten = fs.writeSync(fd, data[, offset[, len[, pos]]])`
Synchronous version of `fs.write()`.
#### `const bytesWritten = await fs.writev(fd, buffers[, pos])`
Write an array of `buffers` to a file descriptor. `pos` defaults to `-1`.
#### `fs.writev(fd, buffers[, pos], callback)`
Callback version of `fs.writev()`.
#### `const bytesWritten = fs.writevSync(fd, buffers[, pos])`
Synchronous version of `fs.writev()`.
#### `const stats = await fs.stat(filepath)`
Get the status of a file. Returns a `Stats` object.
#### `fs.stat(filepath, callback)`
Callback version of `fs.stat()`.
#### `const stats = fs.statSync(filepath)`
Synchronous version of `fs.stat()`.
#### `const stats = await fs.lstat(filepath)`
Like `fs.stat()`, but if `filepath` is a symbolic link, the link itself is statted, not the file it refers to.
#### `fs.lstat(filepath, callback)`
Callback version of `fs.lstat()`.
#### `const stats = fs.lstatSync(filepath)`
Synchronous version of `fs.lstat()`.
#### `const stats = await fs.fstat(fd)`
Get the status of a file by its file descriptor. Returns a `Stats` object.
#### `fs.fstat(fd, callback)`
Callback version of `fs.fstat()`.
#### `const stats = fs.fstatSync(fd)`
Synchronous version of `fs.fstat()`.
#### `const stats = await fs.statfs(filepath)`
Get filesystem statistics. Returns a `StatFs` object.
#### `fs.statfs(filepath, callback)`
Callback version of `fs.statfs()`.
#### `const stats = fs.statfsSync(filepath)`
Synchronous version of `fs.statfs()`.
#### `await fs.ftruncate(fd[, len])`
Truncate a file to `len` bytes. `len` defaults to `0`.
#### `fs.ftruncate(fd[, len], callback)`
Callback version of `fs.ftruncate()`.
#### `fs.ftruncateSync(fd[, len])`
Synchronous version of `fs.ftruncate()`.
#### `await fs.chmod(filepath, mode)`
Change the permissions of a file. `mode` may be a numeric mode or a string that will be parsed as octal.
#### `fs.chmod(filepath, mode, callback)`
Callback version of `fs.chmod()`.
#### `fs.chmodSync(filepath, mode)`
Synchronous version of `fs.chmod()`.
#### `await fs.fchmod(fd, mode)`
Change the permissions of a file by its file descriptor.
#### `fs.fchmod(fd, mode, callback)`
Callback version of `fs.fchmod()`.
#### `fs.fchmodSync(fd, mode)`
Synchronous version of `fs.fchmod()`.
#### `await fs.chown(filepath, uid, gid)`
Change the owner and group of a file.
**NOTE**: The `chown` functions are not implemented on Windows.
#### `fs.chown(filepath, uid, gid, callback)`
Callback version of `fs.chown()`.
#### `await fs.chownSync(filepath, uid, gid)`
Synchronous version of `fs.chown()`.
#### `await fs.lchown(filepath, uid, gid)`
Change the owner and group of a file, but if `filepath` is a symbolic link, the changes are applied only to the link, not the file it refers to.
#### `fs.lchown(filepath, uid, gid, callback)`
Callback version of `fs.lchown()`.
#### `fs.lchownSync(filepath, uid, gid)`
Synchronous version of `fs.lchown()`.
#### `await fs.fchown(filepath, uid, gid)`
Change the owner and group of a file by its file descriptor.
#### `fs.fchown(filepath, uid, gid, callback)`
Callback version of `fs.fchown()`.
#### `fs.fchownSync(filepath, uid, gid)`
Synchronous version of `fs.fchown()`.
#### `await fs.utimes(filepath, atime, mtime)`
Change the access and modification times of a file. Times may be numbers (seconds since epoch) or `Date` objects.
#### `fs.utimes(filepath, atime, mtime, callback)`
Callback version of `fs.utimes()`.
#### `fs.utimesSync(filepath, atime, mtime)`
Synchronous version of `fs.utimes()`.
#### `await fs.lutimes(filepath, atime, mtime)`
Like `fs.utimes()`, but if `filepath` is a symbolic link, the timestamps of the link is changed, not the file it refers to.
#### `fs.lutimes(filepath, atime, mtime, callback)`
Callback version of `fs.lutimes()`.
#### `fs.lutimesSync(filepath, atime, mtime)`
Synchronous version of `fs.lutimes()`.
#### `await fs.futimes(fd, atime, mtime)`
Change the access and modification times of a file by its file descriptor. Times may be numbers (seconds since epoch) or `Date` objects.
#### `fs.futimes(fd, atime, mtime, callback)`
Callback version of `fs.futimes()`.
#### `fs.futimesSync(fd, atime, mtime)`
Synchronous version of `fs.futimes()`.
#### `await fs.link(src, dst)`
Creates a new link (also known as a hard link) to an existing file.
#### `fs.link(src, dst, callback)`
Callback version of `fs.link()`.
#### `fs.linkSync(src, dst)`
Synchronous version of `fs.link()`.
#### `await fs.mkdir(filepath[, opts])`
Create a directory at `filepath`.
Options include:
```js
options = {
mode: 0o777,
recursive: false
}
```
If `opts` is a number, it is treated as the `mode`. When `recursive` is `true`, parent directories are created as needed.
#### `fs.mkdir(filepath[, opts], callback)`
Callback version of `fs.mkdir()`.
#### `fs.mkdirSync(filepath[, opts])`
Synchronous version of `fs.mkdir()`.
#### `const path = await fs.mkdtemp(prefix)`
Create a unique temporary directory.
#### `fs.mkdtemp(prefix, callback)`
Callback version of `fs.mkdtemp()`.
#### `const path = fs.mkdtempSync(prefix)`
Synchronous version of `fs.mkdtemp()`.
#### `await fs.rmdir(filepath)`
Remove an empty directory.
#### `fs.rmdir(filepath, callback)`
Callback version of `fs.rmdir()`.
#### `fs.rmdirSync(filepath)`
Synchronous version of `fs.rmdir()`.
#### `await fs.rm(filepath[, opts])`
Remove a file or directory at `filepath`.
Options include:
```js
options = {
force: false,
recursive: false
}
```
When `recursive` is `true`, directories are removed along with their contents. When `force` is `true`, no error is thrown if `filepath` does not exist.
#### `fs.rm(filepath[, opts], callback)`
Callback version of `fs.rm()`.
#### `fs.rmSync(filepath[, opts])`
Synchronous version of `fs.rm()`.
#### `await fs.unlink(filepath)`
Remove a file.
#### `fs.unlink(filepath, callback)`
Callback version of `fs.unlink()`.
#### `fs.unlinkSync(filepath)`
Synchronous version of `fs.unlink()`.
#### `await fs.rename(src, dst)`
Rename a file from `src` to `dst`.
#### `fs.rename(src, dst, callback)`
Callback version of `fs.rename()`.
#### `fs.renameSync(src, dst)`
Synchronous version of `fs.rename()`.
#### `await fs.copyFile(src, dst[, mode])`
Copy a file from `src` to `dst`. `mode` is an optional bitmask created from `fs.constants.COPYFILE_EXCL`, `fs.constants.COPYFILE_FICLONE`, or `fs.constants.COPYFILE_FICLONE_FORCE`.
#### `fs.copyFile(src, dst[, mode], callback)`
Callback version of `fs.copyFile()`.
#### `fs.copyFileSync(src, dst[, mode])`
Synchronous version of `fs.copyFile()`.
#### `await fs.cp(src, dst[, opts])`
Copy a file or directory from `src` to `dst`.
Options include:
```js
options = {
recursive: false
}
```
Set `recursive` to `true` to copy directories and their contents. Files are copied preserving their permissions.
#### `fs.cp(src, dst[, opts], callback)`
Callback version of `fs.cp()`.
#### `fs.cpSync(src, dst[, opts])`
Synchronous version of `fs.cp()`.
#### `const resolved = await fs.realpath(filepath[, opts])`
Resolve the real path of `filepath`, expanding all symbolic links.
Options include:
```js
options = {
encoding: 'utf8'
}
```
Set `encoding` to `'buffer'` to receive the result as a `Buffer`.
#### `fs.realpath(filepath[, opts], callback)`
Callback version of `fs.realpath()`.
#### `const resolved = fs.realpathSync(filepath[, opts])`
Synchronous version of `fs.realpath()`.
#### `const target = await fs.readlink(filepath[, opts])`
Read the target of a symbolic link.
Options include:
```js
options = {
encoding: 'utf8'
}
```
#### `fs.readlink(filepath[, opts], callback)`
Callback version of `fs.readlink()`.
#### `const target = fs.readlinkSync(filepath[, opts])`
Synchronous version of `fs.readlink()`.
#### `await fs.truncate(filename[, len])`
Truncate the file at `filename` to `len` bytes. `len` defaults to `0`.
#### `fs.truncate(filename[, len], callback)`
Callback version of `fs.truncate()`.
#### `fs.truncateSync(filename[, len])`
Synchronous version of `fs.truncate()`.
#### `await fs.symlink(target, filepath[, type])`
Create a symbolic link at `filepath` pointing to `target`. `type` may be `'file'`, `'dir'`, or `'junction'` (Windows only) or a numeric flag. On Windows, if `type` is not provided, it is inferred from the target.
#### `fs.symlink(target, filepath[, type], callback)`
Callback version of `fs.symlink()`.
#### `fs.symlinkSync(target, filepath[, type])`
Synchronous version of `fs.symlink()`.
#### `await fs.fsync(fd)`
Flush all modified in-core data of the file referred by its file descriptor to the disk device.
#### `fs.fsync(fs, callback)`
Callback version of `fs.fsync()`.
#### `fs.fsyncSync(fd)`
Synchronous version of `fs.fsync()`.
#### `await fs.fdatasync(fd)`
Similar to `fsync`, but does not flush modified metadata unless necessary.
#### `fs.fdatasync(fs, callback)`
Callback version of `fs.fdatasync()`.
#### `fs.fdatasyncSync(fd)`
Synchronous version of `fs.fdatasync()`.
#### `const dir = await fs.opendir(filepath[, opts])`
Open a directory for iteration. Returns a `Dir` object.
Options include:
```js
options = {
encoding: 'utf8',
bufferSize: 32
}
```
#### `fs.opendir(filepath[, opts], callback)`
Callback version of `fs.opendir()`.
#### `const dir = fs.opendirSync(filepath[, opts])`
Synchronous version of `fs.opendir()`.
#### `const entries = await fs.readdir(filepath[, opts])`
Read the contents of a directory. Returns an array of filenames or, if `withFileTypes` is `true`, an array of `Dirent` objects.
Options include:
```js
options = {
encoding: 'utf8',
withFileTypes: false,
recursive: false
}
```
#### `fs.readdir(filepath[, opts], callback)`
Callback version of `fs.readdir()`.
#### `const entries = fs.readdirSync(filepath[, opts])`
Synchronous version of `fs.readdir()`.
#### `const data = await fs.readFile(filepath[, opts])`
Read the entire contents of a file. Returns a `Buffer` by default, or a string if an `encoding` is specified.
Options include:
```js
options = {
encoding: 'buffer',
flag: 'r'
}
```
#### `fs.readFile(filepath[, opts], callback)`
Callback version of `fs.readFile()`.
#### `const data = fs.readFileSync(filepath[, opts])`
Synchronous version of `fs.readFile()`.
#### `await fs.writeFile(filepath, data[, opts])`
Write `data` to a file, replacing it if it already exists.
Options include:
```js
options = {
encoding: 'utf8',
flag: 'w',
mode: 0o666
}
```
#### `fs.writeFile(filepath, data[, opts], callback)`
Callback version of `fs.writeFile()`.
#### `fs.writeFileSync(filepath, data[, opts])`
Synchronous version of `fs.writeFile()`.
#### `await fs.appendFile(filepath, data[, opts])`
Append `data` to a file, creating it if it does not exist. Accepts the same options as `fs.writeFile()` but defaults to the `'a'` flag.
#### `fs.appendFile(filepath, data[, opts], callback)`
Callback version of `fs.appendFile()`.
#### `fs.appendFileSync(filepath, data[, opts])`
Synchronous version of `fs.appendFile()`.
#### `const watcher = fs.watch(filepath[, opts], callback)`
Watch a file or directory for changes. Returns a `Watcher` object. The `callback`, if provided, is called with `(eventType, filename)` on each change.
Options include:
```js
options = {
persistent: true,
recursive: false,
encoding: 'utf8'
}
```
#### `const stream = fs.createReadStream(path[, opts])`
Create a readable stream for a file. Returns a `ReadStream`.
Options include:
```js
options = {
fd: -1,
flags: 'r',
mode: 0o666,
start: 0,
end: Infinity
}
```
If `fd` is provided, `path` may be `null` and the stream reads from the given file descriptor.
#### `const stream = fs.createWriteStream(path[, opts])`
Create a writable stream for a file. Returns a `WriteStream`.
Options include:
```js
options = {
fd: -1,
flags: 'w',
mode: 0o666
}
```
If `fd` is provided, `path` may be `null` and the stream writes to the given file descriptor.
#### `fs.constants`
An object containing file system constants. See `fs/constants` for the full list. Commonly used constants include:
- `fs.constants.O_RDONLY`, `fs.constants.O_WRONLY`, `fs.constants.O_RDWR` — file access flags
- `fs.constants.O_CREAT`, `fs.constants.O_TRUNC`, `fs.constants.O_APPEND` — file creation flags
- `fs.constants.F_OK`, `fs.constants.R_OK`, `fs.constants.W_OK`, `fs.constants.X_OK` — file accessibility flags
- `fs.constants.S_IFMT`, `fs.constants.S_IFREG`, `fs.constants.S_IFDIR`, `fs.constants.S_IFLNK` — file type flags
- `fs.constants.COPYFILE_EXCL`, `fs.constants.COPYFILE_FICLONE`, `fs.constants.COPYFILE_FICLONE_FORCE` — copy flags
### `Stats`
Returned by `fs.stat()`, `fs.lstat()`, and `fs.fstat()`.
#### `stats.dev`
The device identifier.
#### `stats.mode`
The file mode (type and permissions).
#### `stats.nlink`
The number of hard links.
#### `stats.uid`
The user identifier of the file owner.
#### `stats.gid`
The group identifier of the file owner.
#### `stats.rdev`
The device identifier for special files.
#### `stats.blksize`
The file system block size for I/O operations.
#### `stats.ino`
The inode number.
#### `stats.size`
The size of the file in bytes.
#### `stats.blocks`
The number of 512-byte blocks allocated.
#### `stats.atimeMs`
The access time in milliseconds since the epoch.
#### `stats.mtimeMs`
The modification time in milliseconds since the epoch.
#### `stats.ctimeMs`
The change time in milliseconds since the epoch.
#### `stats.birthtimeMs`
The creation time in milliseconds since the epoch.
#### `stats.atime`
The access time as a `Date` object.
#### `stats.mtime`
The modification time as a `Date` object.
#### `stats.ctime`
The change time as a `Date` object.
#### `stats.birthtime`
The creation time as a `Date` object.
#### `stats.isDirectory()`
Returns `true` if the file is a directory.
#### `stats.isFile()`
Returns `true` if the file is a regular file.
#### `stats.isBlockDevice()`
Returns `true` if the file is a block device.
#### `stats.isCharacterDevice()`
Returns `true` if the file is a character device.
#### `stats.isFIFO()`
Returns `true` if the file is a FIFO (named pipe).
#### `stats.isSymbolicLink()`
Returns `true` if the file is a symbolic link. Only meaningful when using `fs.lstat()`.
#### `stats.isSocket()`
Returns `true` if the file is a socket.
### `Dir`
Returned by `fs.opendir()`. Supports both synchronous and asynchronous iteration.
#### `dir.path`
The path of the directory.
#### `const dirent = await dir.read()`
Read the next directory entry. Returns a `Dirent` or `null` when all entries have been read.
#### `dir.read(callback)`
Callback version of `dir.read()`.
#### `const dirent = dir.readSync()`
Synchronous version of `dir.read()`.
#### `await dir.close()`
Close the directory handle.
#### `dir.close(callback)`
Callback version of `dir.close()`.
#### `dir.closeSync()`
Synchronous version of `dir.close()`.
### `Dirent`
Represents a directory entry, returned when iterating a `Dir` or using `fs.readdir()` with `withFileTypes: true`.
#### `dirent.parentPath`
The path of the parent directory.
#### `dirent.name`
The name of the directory entry, as a string or `Buffer` depending on the encoding.
#### `dirent.type`
The numeric type of the directory entry.
#### `dirent.isFile()`
Returns `true` if the entry is a regular file.
#### `dirent.isDirectory()`
Returns `true` if the entry is a directory.
#### `dirent.isSymbolicLink()`
Returns `true` if the entry is a symbolic link.
#### `dirent.isFIFO()`
Returns `true` if the entry is a FIFO.
#### `dirent.isSocket()`
Returns `true` if the entry is a socket.
#### `dirent.isCharacterDevice()`
Returns `true` if the entry is a character device.
#### `dirent.isBlockDevice()`
Returns `true` if the entry is a block device.
### `ReadStream`
A readable stream for file data, created by `fs.createReadStream()`. Extends `Readable` from <https://github.com/holepunchto/bare-stream>.
#### `stream.path`
The file path, or `null` if opened by file descriptor.
#### `stream.fd`
The underlying file descriptor.
#### `stream.flags`
The flags the file was opened with.
#### `stream.mode`
The mode the file was opened with.
### `WriteStream`
A writable stream for file data, created by `fs.createWriteStream()`. Extends `Writable` from <https://github.com/holepunchto/bare-stream>.
#### `stream.path`
The file path, or `null` if opened by file descriptor.
#### `stream.fd`
The underlying file descriptor.
#### `stream.flags`
The flags the file was opened with.
#### `stream.mode`
The mode the file was opened with.
### `Watcher`
Watches for file system changes, created by `fs.watch()`. Extends `EventEmitter` from <https://github.com/holepunchto/bare-events>.
#### `watcher.close()`
Stop watching for changes.
#### `watcher.ref()`
Prevent the event loop from exiting while the watcher is active.
#### `watcher.unref()`
Allow the event loop to exit even if the watcher is still active.
#### `event: 'change'`
Emitted with `(eventType, filename)` when a change is detected. `eventType` is either `'rename'` or `'change'`.
#### `event: 'error'`
Emitted with `(err)` when an error occurs.
#### `event: 'close'`
Emitted when the watcher is closed.
### `FileHandle`
Returned by `require('bare-fs/promises').open()`. Provides an object-oriented API for working with file descriptors.
#### `await handle.close()`
Close the file handle.
#### `const { bytesRead, buffer } = await handle.read(buffer[, offset[, len[, pos]]])`
Read from the file into `buffer`.
#### `const { bytesRead, buffers } = await handle.readv(buffers[, pos])`
Read from the file into an array of `buffers`.
#### `const { bytesWritten, buffer } = await handle.write(data[, offset[, len[, pos]]])`
Write `data` to the file.
#### `const { bytesWritten, buffers } = await handle.writev(buffers[, pos])`
Write an array of `buffers` to the file.
#### `const stats = await handle.stat()`
Get the status of the file.
#### `await handle.chmod(mode)`
Change the permissions of the file.
#### `await handle.chown(uid, gid)`
Change the owner and group of the file.
**NOTE**: This function is not implemented on Windows.
#### `await handle.datasync()`
Similar to `fsync`, but does not flush modified metadata unless necessary.
#### `await handle.sync()`
Flush all modified in-core data of the file.
#### `await handle.truncate(len)`
Truncate the file.
#### `await handle.utimes(mode)`
Change the access and modification times of the file.
#### `const stream = handle.createReadStream([opts])`
Create a readable stream for the file.
#### `const stream = handle.createWriteStream([opts])`
Create a writable stream for the file.
#### `handle.fd`
The file descriptor number.
#### `event: 'close'`
Emitted when the file handle is closed.
## License
Apache-2.0
Reference in New Issue View Git Blame Copy Permalink