@zenfs/core 1.9.2 → 1.9.4

package/dist/internal/credentials.d.ts

@@ -1,6 +1,7 @@
 /**
  * Credentials used for various operations.
  * Similar to Linux's cred struct.
+ * @category Internals
  * @see https://github.com/torvalds/linux/blob/master/include/linux/cred.h
  */
 export interface Credentials {
@@ -15,16 +16,24 @@ export interface Credentials {
      */
     groups: number[];
 }
+/**
+ * @category Internals
+ */
 export declare const credentials: Credentials;
 /**
  * Initialization for a set of credentials
+ * @category Internals
  */
 export interface CredentialInit extends Partial<Credentials> {
     uid: number;
     gid: number;
 }
+/**
+ * @category Internals
+ */
 export declare function createCredentials(source: CredentialInit): Credentials;
 /**
  * Uses credentials from the provided uid and gid.
+ * @category Internals
  */
 export declare function useCredentials(source: CredentialInit): void;

package/dist/internal/credentials.js

@@ -1,3 +1,6 @@
+/**
+ * @category Internals
+ */
 export const credentials = {
     uid: 0,
     gid: 0,
@@ -7,6 +10,9 @@ export const credentials = {
     egid: 0,
     groups: [],
 };
+/**
+ * @category Internals
+ */
 export function createCredentials(source) {
     return {
         suid: source.uid,
@@ -19,6 +25,7 @@ export function createCredentials(source) {
 }
 /**
  * Uses credentials from the provided uid and gid.
+ * @category Internals
  */
 export function useCredentials(source) {
     Object.assign(credentials, createCredentials(source));

package/dist/internal/devices.d.ts

@@ -8,6 +8,7 @@ import { Inode } from './inode.js';
 /**
  * A device
  * @todo Maybe add some other device information, like a UUID?
+ * @category Internals
  * @privateRemarks
  * UUIDs were considered, however they don't make sense without an easy mechanism for persistence
  */
@@ -34,6 +35,9 @@ export interface Device<TData = any> {
      */
     minor: number;
 }
+/**
+ * @category Internals
+ */
 export interface DeviceInit<TData = any> {
     data?: TData;
     minor?: number;
@@ -42,6 +46,7 @@ export interface DeviceInit<TData = any> {
 }
 /**
  * A device driver
+ * @category Internals
  */
 export interface DeviceDriver<TData = any> {
     /**
@@ -108,6 +113,8 @@ export interface DeviceDriver<TData = any> {
  * 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 declare class DeviceFile<TData = any> extends File {
     fs: DeviceFS;
@@ -137,6 +144,7 @@ export declare class DeviceFile<TData = any> extends File {
 }
 /**
  * A temporary file system that manages and interfaces with devices
+ * @category Internals
  */
 export declare class DeviceFS extends StoreFS<InMemoryStore> {
     protected readonly devices: Map<string, Device<any>>;
@@ -184,6 +192,7 @@ export declare class DeviceFS extends StoreFS<InMemoryStore> {
  * Simulates the `/dev/null` device.
  * - Reads return 0 bytes (EOF).
  * - Writes discard data, advancing the file position.
+ * @category Internals
  * @internal
  */
 export declare const nullDevice: DeviceDriver;
@@ -195,6 +204,7 @@ export declare const nullDevice: DeviceDriver;
  * - 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 declare const zeroDevice: DeviceDriver;
@@ -202,6 +212,7 @@ export declare const zeroDevice: DeviceDriver;
  * 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 declare const fullDevice: DeviceDriver;
@@ -209,11 +220,14 @@ export declare const fullDevice: DeviceDriver;
  * Simulates the `/dev/random` device.
  * - Reads return random bytes.
  * - Writes discard data, advancing the file position.
+ * @category Internals
  * @internal
  */
 export declare const randomDevice: DeviceDriver;
 /**
  * Shortcuts for importing.
+ * @category Internals
+ * @internal
  */
 export declare const devices: {
     null: DeviceDriver<any>;

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

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

package/dist/internal/file_index.js

@@ -6,7 +6,8 @@ import { Errno, ErrnoError } from './error.js';
 import { Inode } from './inode.js';
 export const version = 1;
 /**
- * An index of files
+ * An index of file metadata
+ * @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

@@ -4,7 +4,9 @@ import { Index } from './file_index.js';
 import { FileSystem, type CreationOptions, type PureCreationOptions } from './filesystem.js';
 import { Inode, type InodeLike } from './inode.js';
 /**
- * Uses an `Index` for metadata.
+ * A file system that uses an `Index` for metadata.
+ * @category Internals
+ * @internal
  */
 export declare abstract class IndexFS extends FileSystem {
     readonly index: Index;

package/dist/internal/index_fs.js

@@ -9,7 +9,9 @@ import { Index } from './file_index.js';
 import { FileSystem } from './filesystem.js';
 import { Inode } from './inode.js';
 /**
- * Uses an `Index` for metadata.
+ * A file system that 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>;