@zenfs/core 1.9.2 → 1.9.3

package/dist/internal/devices.js

@@ -69,6 +69,8 @@ import { alert, debug, err, info, log_deprecated } from './log.js';
  * This class only does some simple things:
  * It implements `truncate` using `write` and it has non-device methods throw.
  * It is up to device drivers to implement the rest of the functionality.
+ * @category Internals
+ * @internal
  */
 export class DeviceFile extends File {
     constructor(fs, path, device) {
@@ -162,6 +164,7 @@ export class DeviceFile extends File {
 }
 /**
  * A temporary file system that manages and interfaces with devices
+ * @category Internals
  */
 export class DeviceFS extends StoreFS {
     /* node:coverage disable */
@@ -439,6 +442,7 @@ const emptyBuffer = new Uint8Array();
  * Simulates the `/dev/null` device.
  * - Reads return 0 bytes (EOF).
  * - Writes discard data, advancing the file position.
+ * @category Internals
  * @internal
  */
 export const nullDevice = {
@@ -463,6 +467,7 @@ export const nullDevice = {
  * - Reads fill the buffer with zeroes.
  * - Writes discard data but update the file position.
  * - Provides basic file metadata, treating it as a character device.
+ * @category Internals
  * @internal
  */
 export const zeroDevice = {
@@ -480,6 +485,7 @@ export const zeroDevice = {
  * Simulates the `/dev/full` device.
  * - Reads behave like `/dev/zero` (returns zeroes).
  * - Writes always fail with ENOSPC (no space left on device).
+ * @category Internals
  * @internal
  */
 export const fullDevice = {
@@ -502,6 +508,7 @@ export const fullDevice = {
  * Simulates the `/dev/random` device.
  * - Reads return random bytes.
  * - Writes discard data, advancing the file position.
+ * @category Internals
  * @internal
  */
 export const randomDevice = {
@@ -519,6 +526,7 @@ export const randomDevice = {
 };
 /**
  * Simulates the `/dev/console` device.
+ * @category Internals
  * @experimental @internal
  */
 const consoleDevice = {
@@ -537,6 +545,8 @@ const consoleDevice = {
 };
 /**
  * Shortcuts for importing.
+ * @category Internals
+ * @internal
  */
 export const devices = {
     null: nullDevice,

package/dist/internal/error.d.ts

@@ -1,6 +1,7 @@
 /**
  * Standard libc error codes. More will be added to this enum and error strings as they are
  * needed.
+ * @category Internals
  * @see https://en.wikipedia.org/wiki/Errno.h
  */
 export declare enum Errno {
@@ -155,11 +156,15 @@ export declare enum Errno {
 }
 /**
  * Strings associated with each error code.
+ * @category Internals
  * @internal
  */
 export declare const errorMessages: {
     [K in Errno]: string;
 };
+/**
+ * @category Internals
+ */
 export interface ErrnoErrorJSON {
     errno: Errno;
     message: string;
@@ -170,6 +175,7 @@ export interface ErrnoErrorJSON {
 }
 /**
  * An error with additional information about what happened
+ * @category Internals
  */
 export declare class ErrnoError extends Error implements NodeJS.ErrnoException {
     /**

package/dist/internal/error.js

@@ -1,6 +1,7 @@
 /**
  * Standard libc error codes. More will be added to this enum and error strings as they are
  * needed.
+ * @category Internals
  * @see https://en.wikipedia.org/wiki/Errno.h
  */
 export var Errno;
@@ -156,6 +157,7 @@ export var Errno;
 })(Errno || (Errno = {}));
 /**
  * Strings associated with each error code.
+ * @category Internals
  * @internal
  */
 export const errorMessages = {
@@ -236,6 +238,7 @@ export const errorMessages = {
 };
 /**
  * An error with additional information about what happened
+ * @category Internals
  */
 export class ErrnoError extends Error {
     static fromJSON(json) {

package/dist/internal/file.d.ts

@@ -1,24 +1,44 @@
 import { Stats, type StatsLike } from '../stats.js';
 import type { FileSystem } from './filesystem.js';
 import '../polyfills.js';
+/**
+ * @internal @hidden
+ */
 export declare function parseFlag(flag: string | number): string;
+/**
+ * @internal @hidden
+ */
 export declare function flagToString(flag: number): string;
+/**
+ * @internal @hidden
+ */
 export declare function flagToNumber(flag: string): number;
 /**
  * Parses a flag as a mode (W_OK, R_OK, and/or X_OK)
  * @param flag the flag to parse
+ * @internal @hidden
  */
 export declare function flagToMode(flag: string): number;
+/** @hidden */
 export declare function isReadable(flag: string): boolean;
+/** @hidden */
 export declare function isWriteable(flag: string): boolean;
+/** @hidden */
 export declare function isTruncating(flag: string): boolean;
+/** @hidden */
 export declare function isAppendable(flag: string): boolean;
+/** @hidden */
 export declare function isSynchronous(flag: string): boolean;
+/** @hidden */
 export declare function isExclusive(flag: string): boolean;
+/** @hidden */
 export interface FileReadResult<T extends ArrayBufferView> {
     bytesRead: number;
     buffer: T;
 }
+/**
+ * @category Internals
+ */
 export declare abstract class File<FS extends FileSystem = FileSystem> {
     /**
      * @internal
@@ -108,6 +128,7 @@ export declare abstract class File<FS extends FileSystem = FileSystem> {
 /**
  * An implementation of `File` that operates completely in-memory.
  * `PreloadFile`s are backed by a `Uint8Array`.
+ * @category Internals
  */
 export declare class PreloadFile<FS extends FileSystem> extends File<FS> {
     readonly flag: string;
@@ -217,6 +238,7 @@ export declare class PreloadFile<FS extends FileSystem> extends File<FS> {
 }
 /**
  * For the file systems which do not sync to anything.
+ * @category Internals
  * @deprecated
  */
 export declare class NoSyncFile<T extends FileSystem> extends PreloadFile<T> {
@@ -228,6 +250,7 @@ export declare class NoSyncFile<T extends FileSystem> extends PreloadFile<T> {
 }
 /**
  * An implementation of `File` that uses the FS
+ * @category Internals
  */
 export declare class LazyFile<FS extends FileSystem> extends File<FS> {
     readonly flag: string;

package/dist/internal/file.js

@@ -5,8 +5,11 @@ import * as c from '../vfs/constants.js';
 import { Errno, ErrnoError } from './error.js';
 import { log_deprecated } from './log.js';
 import '../polyfills.js';
-const maxByteLength = 0x100000; // 1 MiB
+const maxByteLength = 0xffff; // 64 KiB
 const validFlags = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', 'ax', 'a+', 'ax+'];
+/**
+ * @internal @hidden
+ */
 export function parseFlag(flag) {
     if (typeof flag === 'number') {
         return flagToString(flag);
@@ -16,6 +19,9 @@ export function parseFlag(flag) {
     }
     return flag;
 }
+/**
+ * @internal @hidden
+ */
 export function flagToString(flag) {
     switch (flag) {
         case c.O_RDONLY:
@@ -46,6 +52,9 @@ export function flagToString(flag) {
             throw new Error('Invalid flag number: ' + flag);
     }
 }
+/**
+ * @internal @hidden
+ */
 export function flagToNumber(flag) {
     switch (flag) {
         case 'r':
@@ -79,6 +88,7 @@ export function flagToNumber(flag) {
 /**
  * Parses a flag as a mode (W_OK, R_OK, and/or X_OK)
  * @param flag the flag to parse
+ * @internal @hidden
  */
 export function flagToMode(flag) {
     let mode = 0;
@@ -89,24 +99,33 @@ export function flagToMode(flag) {
     mode <<= 1;
     return mode;
 }
+/** @hidden */
 export function isReadable(flag) {
     return flag.indexOf('r') !== -1 || flag.indexOf('+') !== -1;
 }
+/** @hidden */
 export function isWriteable(flag) {
     return flag.indexOf('w') !== -1 || flag.indexOf('a') !== -1 || flag.indexOf('+') !== -1;
 }
+/** @hidden */
 export function isTruncating(flag) {
     return flag.indexOf('w') !== -1;
 }
+/** @hidden */
 export function isAppendable(flag) {
     return flag.indexOf('a') !== -1;
 }
+/** @hidden */
 export function isSynchronous(flag) {
     return flag.indexOf('s') !== -1;
 }
+/** @hidden */
 export function isExclusive(flag) {
     return flag.indexOf('x') !== -1;
 }
+/**
+ * @category Internals
+ */
 export class File {
     constructor(
     /**
@@ -139,6 +158,7 @@ export class File {
 /**
  * An implementation of `File` that operates completely in-memory.
  * `PreloadFile`s are backed by a `Uint8Array`.
+ * @category Internals
  */
 export class PreloadFile extends File {
     /**
@@ -437,6 +457,7 @@ export class PreloadFile extends File {
 /* node:coverage disable */
 /**
  * For the file systems which do not sync to anything.
+ * @category Internals
  * @deprecated
  */
 export class NoSyncFile extends PreloadFile {
@@ -456,6 +477,7 @@ export class NoSyncFile extends PreloadFile {
 /* node:coverage enable */
 /**
  * An implementation of `File` that uses the FS
+ * @category Internals
  */
 export class LazyFile extends File {
     /**

package/dist/internal/file_index.d.ts

@@ -11,6 +11,7 @@ export interface IndexData {
 export declare const version = 1;
 /**
  * An index of files
+ * @category Internals
  * @internal
  */
 export declare class Index extends Map<string, Inode> {

package/dist/internal/file_index.js

@@ -7,6 +7,7 @@ import { Inode } from './inode.js';
 export const version = 1;
 /**
  * An index of files
+ * @category Internals
  * @internal
  */
 export class Index extends Map {

package/dist/internal/filesystem.d.ts

@@ -3,6 +3,8 @@ import type { Stats, StatsLike } from '../stats.js';
 import type { File } from './file.js';
 /**
  * Usage information about a file system
+ * @category Internals
+ * @internal
  */
 export interface UsageInfo {
     /**
@@ -29,6 +31,7 @@ export interface UsageInfo {
 }
 /**
  * Metadata about a FileSystem
+ * @category Internals
  * @deprecated
  */
 export interface FileSystemMetadata extends UsageInfo {
@@ -69,6 +72,8 @@ export interface FileSystemMetadata extends UsageInfo {
 /**
  * Attributes that control how the file system interacts with the VFS.
  * No options are set by default.
+ * @category Internals
+ * @internal
  */
 export type FileSystemAttributes = {
     /** The FS supports setuid and setgid when creating files and directories. */
@@ -96,6 +101,7 @@ export type FileSystemAttributes = {
  * Options used when creating files and directories.
  * This weird naming and such is to preserve backward compatibility.
  * @todo [BREAKING] Move the `mode` parameter of `createFile` and `mkdir` into this
+ * @category Internals
  * @internal
  */
 export interface CreationOptions {
@@ -116,6 +122,8 @@ export interface CreationOptions {
 }
 /**
  * This is the correct type that will be used when the API is updated in a breaking release
+ * @category Internals
+ * @internal
  */
 export interface PureCreationOptions extends CreationOptions {
     /**
@@ -127,6 +135,7 @@ export interface PureCreationOptions extends CreationOptions {
  * Provides a consistent and easy to use internal API.
  * Default implementations for `exists` and `existsSync` are included.
  * If you are extending this class, note that every path is an absolute path and all arguments are present.
+ * @category Internals
  * @internal
  */
 export declare abstract class FileSystem {

package/dist/internal/filesystem.js

@@ -2,6 +2,7 @@
  * Provides a consistent and easy to use internal API.
  * Default implementations for `exists` and `existsSync` are included.
  * If you are extending this class, note that every path is an absolute path and all arguments are present.
+ * @category Internals
  * @internal
  */
 export class FileSystem {

package/dist/internal/index_fs.d.ts

@@ -5,6 +5,8 @@ import { FileSystem, type CreationOptions, type PureCreationOptions } from './fi
 import { Inode, type InodeLike } from './inode.js';
 /**
  * Uses an `Index` for metadata.
+ * @category Internals
+ * @internal
  */
 export declare abstract class IndexFS extends FileSystem {
     readonly index: Index;

package/dist/internal/index_fs.js

@@ -10,6 +10,8 @@ import { FileSystem } from './filesystem.js';
 import { Inode } from './inode.js';
 /**
  * Uses an `Index` for metadata.
+ * @category Internals
+ * @internal
  */
 export class IndexFS extends FileSystem {
     constructor(id, name, index = new Index()) {
@@ -34,8 +36,6 @@ export class IndexFS extends FileSystem {
      * Finds all the paths in the index that need to be moved for a rename
      */
     pathsForRename(oldPath, newPath) {
-        if (newPath === oldPath)
-            return [];
         if (!this.index.has(oldPath))
             throw ErrnoError.With('ENOENT', oldPath, 'rename');
         if ((dirname(newPath) + '/').startsWith(oldPath + '/'))
@@ -53,6 +53,8 @@ export class IndexFS extends FileSystem {
         return toRename;
     }
     async rename(oldPath, newPath) {
+        if (oldPath == newPath)
+            return;
         for (const { from, to, inode } of this.pathsForRename(oldPath, newPath)) {
             const data = new Uint8Array(inode.size);
             await this.read(from, data, 0, inode.size);
@@ -63,6 +65,8 @@ export class IndexFS extends FileSystem {
         await this.remove(oldPath);
     }
     renameSync(oldPath, newPath) {
+        if (oldPath == newPath)
+            return;
         for (const { from, to, inode } of this.pathsForRename(oldPath, newPath)) {
             const data = new Uint8Array(inode.size);
             this.readSync(from, data, 0, inode.size);

package/dist/internal/inode.d.ts

@@ -4,10 +4,17 @@ import { Stats, type StatsLike } from '../stats.js';
  * @hidden
  */
 export declare const rootIno = 0;
+/**
+ * @internal @hidden
+ */
 export interface InodeFields {
     data?: number;
     flags?: number;
 }
+/**
+ * @category Internals
+ * @internal
+ */
 export interface InodeLike extends StatsLike<number>, InodeFields {
 }
 /**
@@ -16,6 +23,7 @@ export interface InodeLike extends StatsLike<number>, InodeFields {
 export declare const _inode_fields: readonly ["ino", "data", "size", "mode", "flags", "nlink", "uid", "gid", "atimeMs", "birthtimeMs", "mtimeMs", "ctimeMs"];
 /**
  * Generic inode definition that can easily be serialized.
+ * @category Internals
  * @internal
  * @todo [BREAKING] Remove 58 byte Inode upgrade path
  */

package/dist/internal/inode.js

@@ -51,6 +51,7 @@ export const rootIno = 0;
 export const _inode_fields = ['ino', 'data', 'size', 'mode', 'flags', 'nlink', 'uid', 'gid', 'atimeMs', 'birthtimeMs', 'mtimeMs', 'ctimeMs'];
 /**
  * Generic inode definition that can easily be serialized.
+ * @category Internals
  * @internal
  * @todo [BREAKING] Remove 58 byte Inode upgrade path
  */

package/dist/mixins/async.d.ts

@@ -1,11 +1,15 @@
 import type { FileSystem } from '../internal/filesystem.js';
 import type { _SyncFSKeys, AsyncFSMethods, Mixin } from './shared.js';
-/** @internal */
+/**
+ * @internal
+ * @category Internals
+ */
 export type AsyncOperation = {
     [K in keyof AsyncFSMethods]: [K, ...Parameters<FileSystem[K]>];
 }[keyof AsyncFSMethods];
 /**
  * @internal
+ * @category Internals
  */
 export interface AsyncMixin extends Pick<FileSystem, Exclude<_SyncFSKeys, 'existsSync'>> {
     /**
@@ -23,6 +27,6 @@ export interface AsyncMixin extends Pick<FileSystem, Exclude<_SyncFSKeys, 'exist
  * Synchronous methods on an asynchronous FS are implemented by performing operations over the in-memory copy,
  * while asynchronously pipelining them to the backing store.
  * During loading, the contents of the async file system are preloaded into the synchronous store.
- *
+ * @category Internals
  */
 export declare function Async<const T extends abstract new (...args: any[]) => FileSystem>(FS: T): Mixin<T, AsyncMixin>;

package/dist/mixins/async.js

@@ -63,7 +63,7 @@ import { join } from '../vfs/path.js';
  * Synchronous methods on an asynchronous FS are implemented by performing operations over the in-memory copy,
  * while asynchronously pipelining them to the backing store.
  * During loading, the contents of the async file system are preloaded into the synchronous store.
- *
+ * @category Internals
  */
 export function Async(FS) {
     class AsyncFS extends FS {

package/dist/mixins/mutexed.d.ts

@@ -4,6 +4,10 @@ import type { InodeLike } from '../internal/inode.js';
 import type { Stats } from '../stats.js';
 import type { Concrete } from '../utils.js';
 import '../polyfills.js';
+/**
+ * @category Internals
+ * @internal
+ */
 export declare class MutexLock {
     protected readonly previous?: MutexLock | undefined;
     protected current: PromiseWithResolvers<void>;
@@ -16,6 +20,7 @@ export declare class MutexLock {
 }
 /**
  * @hidden
+ * @category Internals
  */
 export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     /**
@@ -99,6 +104,7 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
  * `MutexedFS` implements it in order to make sure all of the methods are passed through
  *
  * @todo Change `using _` to `using void` pending https://github.com/tc39/proposal-discard-binding
+ * @category Internals
  * @internal
  */
 export declare function Mutexed<const T extends Concrete<typeof FileSystem>>(FS: T): typeof _MutexedFS<InstanceType<T>> & {

package/dist/mixins/mutexed.js

@@ -53,6 +53,10 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 import { ErrnoError } from '../internal/error.js';
 import { err } from '../internal/log.js';
 import '../polyfills.js';
+/**
+ * @category Internals
+ * @internal
+ */
 export class MutexLock {
     get isLocked() {
         return this._isLocked;
@@ -77,6 +81,7 @@ export class MutexLock {
 }
 /**
  * @hidden
+ * @category Internals
  */
 export class _MutexedFS {
     get id() {
@@ -541,6 +546,7 @@ export class _MutexedFS {
  * `MutexedFS` implements it in order to make sure all of the methods are passed through
  *
  * @todo Change `using _` to `using void` pending https://github.com/tc39/proposal-discard-binding
+ * @category Internals
  * @internal
  */
 export function Mutexed(FS) {

package/dist/mixins/readonly.d.ts

@@ -25,5 +25,6 @@ export interface ReadonlyMixin {
 }
 /**
  * Implements the non-readonly methods to throw `EROFS`
+ * @category Internals
  */
 export declare function Readonly<T extends abstract new (...args: any[]) => FileSystem>(FS: T): Mixin<T, ReadonlyMixin>;

package/dist/mixins/readonly.js

@@ -1,6 +1,7 @@
 import { Errno, ErrnoError } from '../internal/error.js';
 /**
  * Implements the non-readonly methods to throw `EROFS`
+ * @category Internals
  */
 /* eslint-disable @typescript-eslint/require-await */
 export function Readonly(FS) {

package/dist/mixins/shared.d.ts

@@ -2,6 +2,7 @@ import type { ExtractProperties } from 'utilium';
 import type { FileSystem } from '../internal/filesystem.js';
 /**
  * `TBase` with `TMixin` mixed-in.
+ * @category Internals
  * @internal
  */
 export type Mixin<TBase extends typeof FileSystem, TMixin> = (abstract new (...args: any[]) => TMixin) & TBase;
@@ -19,11 +20,13 @@ export type _AsyncFSKeys = {
 }[_SyncFSKeys];
 /**
  * Asynchronous `FileSystem` methods. This is a convenience type for all of the async operations.
+ * @category Internals
  * @internal
  */
 export type AsyncFSMethods = Pick<FileSystem, _AsyncFSKeys>;
 /**
  * Concrete `FileSystem`. This is a convenience type.
+ * @category Internals
  * @internal
  */
 export type ConcreteFS = ExtractProperties<FileSystem, any>;

package/dist/mixins/sync.d.ts

@@ -2,5 +2,6 @@ import type { FileSystem } from '../internal/filesystem.js';
 import type { AsyncFSMethods, Mixin } from './shared.js';
 /**
  * Implements the asynchronous API in terms of the synchronous API.
+ * @category Internals
  */
 export declare function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): Mixin<T, AsyncFSMethods>;

package/dist/mixins/sync.js

@@ -1,5 +1,6 @@
 /**
  * Implements the asynchronous API in terms of the synchronous API.
+ * @category Internals
  */
 /* eslint-disable @typescript-eslint/require-await */
 export function Sync(FS) {

package/dist/vfs/shared.d.ts

@@ -22,16 +22,19 @@ export declare function fd2file(fd: number): File;
 export type MountObject = Record<AbsolutePath, FileSystem>;
 /**
  * The map of mount points
+ * @category Backends and Configuration
  * @internal
  */
 export declare const mounts: Map<string, FileSystem>;
 /**
  * Mounts the file system at `mountPoint`.
+ * @category Backends and Configuration
  * @internal
  */
 export declare function mount(mountPoint: string, fs: FileSystem): void;
 /**
  * Unmounts the file system at `mountPoint`.
+ * @category Backends and Configuration
  */
 export declare function umount(mountPoint: string): void;
 /**
@@ -69,7 +72,7 @@ export declare function _statfs<const T extends boolean>(fs: FileSystem, bigint?
 /**
  * Change the root path
  * @param inPlace if true, this changes the root for the current context instead of creating a new one (if associated with a context).
- * @experimental
+ * @category Backends and Configuration
  */
 export declare function chroot(this: V_Context, path: string, inPlace?: false): BoundContext;
 export declare function chroot<T extends V_Context>(this: T, path: string, inPlace: true): T;

package/dist/vfs/shared.js

@@ -7,7 +7,6 @@ import { normalizePath } from '../utils.js';
 import { paths as pathCache } from './cache.js';
 import { size_max } from './constants.js';
 import { join, resolve } from './path.js';
-import { ZenFsType } from '../stats.js';
 // descriptors
 /**
  * @internal @hidden
@@ -33,6 +32,7 @@ export function fd2file(fd) {
 }
 /**
  * The map of mount points
+ * @category Backends and Configuration
  * @internal
  */
 export const mounts = new Map();
@@ -40,6 +40,7 @@ export const mounts = new Map();
 mount('/', InMemory.create({ name: 'root' }));
 /**
  * Mounts the file system at `mountPoint`.
+ * @category Backends and Configuration
  * @internal
  */
 export function mount(mountPoint, fs) {
@@ -57,6 +58,7 @@ export function mount(mountPoint, fs) {
 }
 /**
  * Unmounts the file system at `mountPoint`.
+ * @category Backends and Configuration
  */
 export function umount(mountPoint) {
     if (mountPoint[0] != '/')

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.9.2",
+	"version": "1.9.3",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/readme.md

@@ -1,3 +1,7 @@
+---
+title: Overview
+---
+
 # ZenFS
 
 ZenFS is a cross-platform library that emulates the [NodeJS filesystem API](http://nodejs.org/api/fs.html). It works using a system of backends, which are used by ZenFS to store and retrieve data. ZenFS can also integrate with other tools.