@zenfs/core 0.12.1 → 0.12.3

package/dist/config.d.ts

@@ -6,7 +6,7 @@ import type { AbsolutePath } from './emulation/path.js';
 export type MountConfiguration<T extends Backend> = FilesystemOf<T> | BackendConfiguration<T> | T;
 /**
  * Retrieve a file system with the given configuration.
- * @param config A BackendConfig object.
+ * @see MountConfiguration
  */
 export declare function resolveMountConfig<T extends Backend>(config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
 type ConfigMounts = {

package/dist/config.js

@@ -8,7 +8,7 @@ function isMountConfig(arg) {
 }
 /**
  * Retrieve a file system with the given configuration.
- * @param config A BackendConfig object.
+ * @see MountConfiguration
  */
 export async function resolveMountConfig(config, _depth = 0) {
     if (typeof config !== 'object' || config == null) {

package/dist/cred.d.ts

@@ -1,6 +1,7 @@
 /**
  * Credentials used for various operations.
- * Similar to Linux's cred struct. See https://github.com/torvalds/linux/blob/master/include/linux/cred.h
+ * Similar to Linux's cred struct.
+ * @see https://github.com/torvalds/linux/blob/master/include/linux/cred.h
  */
 export interface Cred {
     uid: number;

package/dist/emulation/async.d.ts

@@ -4,9 +4,10 @@
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
 import type { FileContents } from '../filesystem.js';
-import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { BigIntStats, type Stats } from '../stats.js';
 import { type Callback } from '../utils.js';
-import { Dirent, type Dir } from './dir.js';
+import type { Dirent } from './dir.js';
+import { type Dir } from './dir.js';
 import * as promises from './promises.js';
 import { ReadStream, WriteStream } from './streams.js';
 /**
@@ -441,12 +442,12 @@ export declare function opendir(path: fs.PathLike, cb: Callback<[Dir]>): void;
 export declare function opendir(path: fs.PathLike, options: fs.OpenDirOptions, cb: Callback<[Dir]>): void;
 export declare function cp(source: fs.PathLike, destination: fs.PathLike, callback: Callback): void;
 export declare function cp(source: fs.PathLike, destination: fs.PathLike, opts: fs.CopyOptions, callback: Callback): void;
-export declare function statfs(path: fs.PathLike, callback: Callback<[StatsFs]>): void;
+export declare function statfs(path: fs.PathLike, callback: Callback<[fs.StatsFs]>): void;
 export declare function statfs(path: fs.PathLike, options: fs.StatFsOptions & {
     bigint?: false;
-}, callback: Callback<[StatsFs]>): void;
+}, callback: Callback<[fs.StatsFs]>): void;
 export declare function statfs(path: fs.PathLike, options: fs.StatFsOptions & {
     bigint: true;
-}, callback: Callback<[BigIntStatsFs]>): void;
+}, callback: Callback<[fs.BigIntStatsFs]>): void;
 export declare function openAsBlob(path: fs.PathLike, options?: fs.OpenAsBlobOptions): Promise<Blob>;
 export {};

package/dist/emulation/index.d.ts

@@ -5,4 +5,4 @@ export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
 export { mountObject, mounts, mount, umount } from './shared.js';
-export { Stats, BigIntStats, StatsFs } from '../stats.js';
+export { Stats, StatsFs, BigIntStatsFs } from '../stats.js';

package/dist/emulation/index.js

@@ -5,4 +5,4 @@ export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
 export { mountObject, mounts, mount, umount } from './shared.js';
-export { Stats, BigIntStats, StatsFs } from '../stats.js';
+export { Stats, StatsFs, BigIntStatsFs } from '../stats.js';

package/dist/emulation/promises.d.ts

@@ -12,9 +12,9 @@ import type { CreateReadStreamOptions, CreateWriteStreamOptions, FileChangeInfo,
 import type { Stream } from 'node:stream';
 import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
-import { File } from '../file.js';
+import type { File } from '../file.js';
 import type { FileContents } from '../filesystem.js';
-import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { BigIntStats, type Stats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
@@ -437,8 +437,8 @@ export declare function cp(source: fs.PathLike, destination: fs.PathLike, opts?:
  */
 export declare function statfs(path: fs.PathLike, opts?: fs.StatFsOptions & {
     bigint?: false;
-}): Promise<StatsFs>;
+}): Promise<fs.StatsFs>;
 export declare function statfs(path: fs.PathLike, opts: fs.StatFsOptions & {
     bigint: true;
-}): Promise<BigIntStatsFs>;
-export declare function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<StatsFs | BigIntStatsFs>;
+}): Promise<fs.BigIntStatsFs>;
+export declare function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<fs.StatsFs | fs.BigIntStatsFs>;

package/dist/emulation/promises.js

@@ -1,12 +1,12 @@
 import { Buffer } from 'buffer';
-import { ErrnoError, Errno } from '../error.js';
-import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
+import { Errno, ErrnoError } from '../error.js';
+import { isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
 export class FileHandle {
@@ -83,7 +83,7 @@ export class FileHandle {
             throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-        await this.file.write(encodedData, 0, encodedData.length, null);
+        await this.file.write(encodedData, 0, encodedData.length);
     }
     /**
      * Asynchronously reads data from the file.
@@ -386,55 +386,33 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
     const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
     path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
-    try {
-        switch (pathExistsAction(flag)) {
-            case ActionType.THROW:
-                throw ErrnoError.With('EEXIST', path, '_open');
-            case ActionType.TRUNCATE:
-                /*
-                    In a previous implementation, we deleted the file and
-                    re-created it. However, this created a race condition if another
-                    asynchronous request was trying to read the file, as the file
-                    would not exist for a small period of time.
-                */
-                const file = await fs.openFile(resolved, flag, cred);
-                await file.truncate(0);
-                await file.sync();
-                return new FileHandle(file);
-            case ActionType.NOP:
-                // Must await so thrown errors are caught by the catch below
-                return new FileHandle(await fs.openFile(resolved, flag, cred));
-            default:
-                throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
-        }
-    }
-    catch (_) {
-        const original = _;
-        if (original.code != 'ENOENT') {
-            throw original;
+    if (!(await fs.exists(path, cred))) {
+        if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
+            throw ErrnoError.With('ENOENT', path, '_open');
         }
-        try {
-            switch (pathNotExistsAction(flag)) {
-                case ActionType.CREATE:
-                    // Ensure parent exists.
-                    const parentStats = await fs.stat(dirname(resolved), cred);
-                    if (parentStats && !parentStats.isDirectory()) {
-                        throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
-                    }
-                    return new FileHandle(await fs.createFile(resolved, flag, mode, cred));
-                case ActionType.THROW:
-                    throw ErrnoError.With('ENOENT', path, '_open');
-                default:
-                    throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
-            }
-        }
-        catch (_) {
-            const ex = _;
-            ex.stack += '\n<original>\n';
-            ex.stack += original.stack;
-            throw ex;
+        // Create the file
+        const parentStats = await fs.stat(dirname(resolved), cred);
+        if (parentStats && !parentStats.isDirectory()) {
+            throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
         }
+        return new FileHandle(await fs.createFile(resolved, flag, mode, cred));
+    }
+    if (isExclusive(flag)) {
+        throw ErrnoError.With('EEXIST', path, '_open');
     }
+    if (!isTruncating(flag)) {
+        return new FileHandle(await fs.openFile(resolved, flag, cred));
+    }
+    /*
+        In a previous implementation, we deleted the file and
+        re-created it. However, this created a race condition if another
+        asynchronous request was trying to read the file, as the file
+        would not exist for a small period of time.
+    */
+    const file = await fs.openFile(resolved, flag, cred);
+    await file.truncate(0);
+    await file.sync();
+    return new FileHandle(file);
 }
 /**
  * Asynchronous file open.
@@ -859,5 +837,7 @@ export async function cp(source, destination, opts) {
 }
 cp;
 export async function statfs(path, opts) {
-    throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
+    path = normalizePath(path);
+    const { fs } = resolveMount(path);
+    return _statfs(fs, opts?.bigint);
 }

package/dist/emulation/shared.d.ts

@@ -1,6 +1,8 @@
-import { Cred } from '../cred.js';
+/// <reference types="node" resolution-mode="require"/>
+import type { BigIntStatsFs, StatsFs } from 'node:fs';
+import type { Cred } from '../cred.js';
 import type { File } from '../file.js';
-import { FileSystem } from '../filesystem.js';
+import type { FileSystem } from '../filesystem.js';
 import { type AbsolutePath } from './path.js';
 export declare let cred: Cred;
 export declare function setCred(val: Cred): void;
@@ -35,3 +37,7 @@ export declare function resolveMount(path: string): {
 export declare function fixPaths(text: string, paths: Record<string, string>): string;
 export declare function fixError<E extends Error>(e: E, paths: Record<string, string>): E;
 export declare function mountObject(mounts: MountObject): void;
+/**
+ * @hidden
+ */
+export declare function _statfs<const T extends boolean>(fs: FileSystem, bigint?: T): T extends true ? BigIntStatsFs : StatsFs;

package/dist/emulation/shared.js

@@ -1,7 +1,8 @@
 // Utilities and shared data
-import { ErrnoError, Errno } from '../error.js';
 import { InMemory } from '../backends/memory.js';
 import { rootCred } from '../cred.js';
+import { Errno, ErrnoError } from '../error.js';
+import { size_max } from '../inode.js';
 import { normalizePath } from '../utils.js';
 import { resolve } from './path.js';
 // credentials
@@ -100,3 +101,19 @@ export function mountObject(mounts) {
         mount(point, fs);
     }
 }
+/**
+ * @hidden
+ */
+export function _statfs(fs, bigint) {
+    const md = fs.metadata();
+    const bs = md.blockSize || 4096;
+    return {
+        type: (bigint ? BigInt : Number)(md.type),
+        bsize: (bigint ? BigInt : Number)(bs),
+        ffree: (bigint ? BigInt : Number)(md.freeNodes || size_max),
+        files: (bigint ? BigInt : Number)(md.totalNodes || size_max),
+        bavail: (bigint ? BigInt : Number)(md.freeSpace / bs),
+        bfree: (bigint ? BigInt : Number)(md.freeSpace / bs),
+        blocks: (bigint ? BigInt : Number)(md.totalSpace / bs),
+    };
+}

package/dist/emulation/streams.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" resolution-mode="require"/>
 import type * as Node from 'fs';
 import { Readable, Writable } from 'readable-stream';
-import { Callback } from '../utils.js';
+import type { Callback } from '../utils.js';
 export declare class ReadStream extends Readable implements Node.ReadStream {
     close(callback?: Callback): void;
     bytesRead: number;

package/dist/emulation/sync.d.ts

@@ -3,8 +3,8 @@
 /// <reference types="node" resolution-mode="require"/>
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
-import { FileContents } from '../filesystem.js';
-import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import type { FileContents } from '../filesystem.js';
+import { BigIntStats, type Stats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
 /**
  * Synchronous rename.
@@ -368,8 +368,8 @@ export declare function cpSync(source: fs.PathLike, destination: fs.PathLike, op
  */
 export declare function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions & {
     bigint?: false;
-}): StatsFs;
+}): fs.StatsFs;
 export declare function statfsSync(path: fs.PathLike, options: fs.StatFsOptions & {
     bigint: true;
-}): BigIntStatsFs;
-export declare function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): StatsFs | BigIntStatsFs;
+}): fs.BigIntStatsFs;
+export declare function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): fs.StatsFs | fs.BigIntStatsFs;

package/dist/emulation/sync.js

@@ -1,23 +1,12 @@
 import { Buffer } from 'buffer';
-import { ErrnoError, Errno } from '../error.js';
-import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
+import { Errno, ErrnoError } from '../error.js';
+import { isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { COPYFILE_EXCL, F_OK, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK } from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { cred, fd2file, fdMap, fixError, file2fd, mounts, resolveMount } from './shared.js';
-function wrap(...[name, resolveSymlinks, path, ...args]) {
-    path = normalizePath(path);
-    const { fs, path: resolvedPath } = resolveMount(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
-    try {
-        // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
-        return fs[name](resolvedPath, ...args);
-    }
-    catch (e) {
-        throw fixError(e, { [resolvedPath]: path });
-    }
-}
+import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 /**
  * Synchronous rename.
  * @param oldPath
@@ -60,13 +49,27 @@ export function existsSync(path) {
 }
 existsSync;
 export function statSync(path, options) {
-    const stats = wrap('statSync', true, path.toString(), cred);
-    return options?.bigint ? new BigIntStats(stats) : stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    try {
+        const stats = fs.statSync(resolved, cred);
+        return options?.bigint ? new BigIntStats(stats) : stats;
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 statSync;
 export function lstatSync(path, options) {
-    const stats = wrap('statSync', false, path.toString(), cred);
-    return options?.bigint ? new BigIntStats(stats) : stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path);
+    try {
+        const stats = fs.statSync(resolved, cred);
+        return options?.bigint ? new BigIntStats(stats) : stats;
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 lstatSync;
 /**
@@ -89,66 +92,51 @@ truncateSync;
  * @param path
  */
 export function unlinkSync(path) {
-    return wrap('unlinkSync', false, path.toString(), cred);
-}
-unlinkSync;
-function _openSync(_path, _flag, _mode, resolveSymlinks = true) {
-    const path = normalizePath(_path), mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
-    // Check if the path exists, and is a file.
-    let stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path);
     try {
-        stats = wrap('statSync', resolveSymlinks, path, cred);
+        return fs.unlinkSync(resolved, cred);
     }
-    catch (_) {
-        const original = _;
-        if (original.code != 'ENOENT') {
-            throw original;
-        }
-        try {
-            // File does not exist.
-            switch (pathNotExistsAction(flag)) {
-                case ActionType.CREATE:
-                    // Ensure parent exists.
-                    const parentStats = wrap('statSync', resolveSymlinks, dirname(path), cred);
-                    if (!parentStats.isDirectory()) {
-                        throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
-                    }
-                    return wrap('createFileSync', resolveSymlinks, path, flag, mode, cred);
-                case ActionType.THROW:
-                    throw ErrnoError.With('ENOENT', path, '_open');
-                default:
-                    throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
-            }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
+}
+unlinkSync;
+function _openSync(path, _flag, _mode, resolveSymlinks = true) {
+    path = normalizePath(path);
+    const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
+    path = resolveSymlinks && existsSync(path) ? realpathSync(path) : path;
+    const { fs, path: resolved } = resolveMount(path);
+    if (!fs.existsSync(resolved, cred)) {
+        if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
+            throw ErrnoError.With('ENOENT', path, '_open');
         }
-        catch (_) {
-            const ex = _;
-            ex.stack += '\n<original>\n';
-            ex.stack += original.stack;
-            throw ex;
+        // Create the file
+        const parentStats = fs.statSync(dirname(resolved), cred);
+        if (!parentStats.isDirectory()) {
+            throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
         }
+        return fs.createFileSync(resolved, flag, mode, cred);
     }
+    const stats = fs.statSync(resolved, cred);
     if (!stats.hasAccess(mode, cred)) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
-    // File exists.
-    switch (pathExistsAction(flag)) {
-        case ActionType.THROW:
-            throw ErrnoError.With('EEXIST', path, '_open');
-        case ActionType.TRUNCATE:
-            // Delete file.
-            wrap('unlinkSync', resolveSymlinks, path, cred);
-            /*
-                Create file. Use the same mode as the old file.
-                Node itself modifies the ctime when this occurs, so this action
-                will preserve that behavior if the underlying file system
-                supports those properties.
-            */
-            return wrap('createFileSync', resolveSymlinks, path, flag, stats.mode, cred);
-        case ActionType.NOP:
-            return wrap('openFileSync', resolveSymlinks, path, flag, cred);
-        default:
-            throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
+    if (isExclusive(flag)) {
+        throw ErrnoError.With('EEXIST', path, '_open');
+    }
+    if (!isTruncating(flag)) {
+        return fs.openFileSync(resolved, flag, cred);
     }
+    // Delete file.
+    fs.unlinkSync(resolved, cred);
+    /*
+        Create file. Use the same mode as the old file.
+        Node itself modifies the ctime when this occurs, so this action
+        will preserve that behavior if the underlying file system
+        supports those properties.
+    */
+    return fs.createFileSync(resolved, flag, stats.mode, cred);
 }
 /**
  * Synchronous file open.
@@ -242,7 +230,7 @@ export function appendFileSync(filename, data, _options = {}) {
     const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
     const file = _openSync(typeof filename == 'number' ? fd2file(filename).path : filename.toString(), flag, options.mode, true);
     try {
-        file.writeSync(encodedData, 0, encodedData.byteLength, null);
+        file.writeSync(encodedData, 0, encodedData.byteLength);
     }
     finally {
         file.closeSync();
@@ -367,18 +355,39 @@ futimesSync;
  * @param path
  */
 export function rmdirSync(path) {
-    return wrap('rmdirSync', true, path.toString(), cred);
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    try {
+        fs.rmdirSync(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 rmdirSync;
 export function mkdirSync(path, options) {
-    const mode = typeof options == 'number' || typeof options == 'string' ? options : options?.mode;
+    const mode = normalizeMode(typeof options == 'number' || typeof options == 'string' ? options : options?.mode, 0o777);
     const recursive = typeof options == 'object' && options?.recursive;
-    wrap('mkdirSync', true, path.toString(), normalizeMode(mode, 0o777), cred);
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    try {
+        return fs.mkdirSync(resolved, mode, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 mkdirSync;
 export function readdirSync(path, options) {
     path = normalizePath(path);
-    const entries = wrap('readdirSync', true, path, cred);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    let entries;
+    try {
+        entries = fs.readdirSync(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
     for (const mount of mounts.keys()) {
         if (!mount.startsWith(path)) {
             continue;
@@ -408,8 +417,15 @@ readdirSync;
  * @param newpath
  */
 export function linkSync(existing, newpath) {
+    existing = normalizePath(existing);
     newpath = normalizePath(newpath);
-    return wrap('linkSync', false, existing.toString(), newpath.toString(), cred);
+    const { fs, path: resolved } = resolveMount(existing);
+    try {
+        return fs.linkSync(resolved, newpath, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: existing });
+    }
 }
 linkSync;
 /**
@@ -685,5 +701,7 @@ export function cpSync(source, destination, opts) {
 }
 cpSync;
 export function statfsSync(path, options) {
-    throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
+    path = normalizePath(path);
+    const { fs } = resolveMount(path);
+    return _statfs(fs, options?.bigint);
 }

package/dist/error.d.ts

@@ -2,7 +2,7 @@
 /**
  * Standard libc error codes. More will be added to this enum and error strings as they are
  * needed.
- * @url https://en.wikipedia.org/wiki/Errno.h
+ * @see https://en.wikipedia.org/wiki/Errno.h
  */
 export declare enum Errno {
     /** Operation not permitted */

package/dist/error.js

@@ -1,7 +1,7 @@
 /**
  * Standard libc error codes. More will be added to this enum and error strings as they are
  * needed.
- * @url https://en.wikipedia.org/wiki/Errno.h
+ * @see https://en.wikipedia.org/wiki/Errno.h
  */
 export var Errno;
 (function (Errno) {

package/dist/file.d.ts

@@ -20,15 +20,6 @@ declare global {
         }): ArrayBuffer;
     }
 }
-/**
- * @hidden
- */
-export declare enum ActionType {
-    NOP = 0,
-    THROW = 1,
-    TRUNCATE = 2,
-    CREATE = 3
-}
 export declare function parseFlag(flag: string | number): string;
 export declare function flagToString(flag: number): string;
 export declare function flagToNumber(flag: string): number;
@@ -43,8 +34,6 @@ export declare function isTruncating(flag: string): boolean;
 export declare function isAppendable(flag: string): boolean;
 export declare function isSynchronous(flag: string): boolean;
 export declare function isExclusive(flag: string): boolean;
-export declare function pathExistsAction(flag: string): ActionType;
-export declare function pathNotExistsAction(flag: string): ActionType;
 export declare abstract class File {
     /**
      * Get the current file position.
@@ -101,7 +90,7 @@ export declare abstract class File {
      *   the current position.
      * @returns Promise resolving to the new length of the buffer
      */
-    abstract write(buffer: Uint8Array, offset?: number, length?: number, position?: number | null): Promise<number>;
+    abstract write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number>;
     /**
      * Write buffer to the file.
      * Note that it is unsafe to use fs.writeSync multiple times on the same file
@@ -114,7 +103,7 @@ export declare abstract class File {
      *   data should be written. If position is null, the data will be written at
      *   the current position.
      */
-    abstract writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number | null): number;
+    abstract writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
     /**
      * Read data from the file.
      * @param buffer The buffer that the data will be
@@ -204,7 +193,7 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     readonly stats: Stats;
     protected _buffer: Uint8Array;
     protected _position: number;
-    protected _dirty: boolean;
+    protected dirty: boolean;
     /**
      * Creates a file with the given path and, optionally, the given contents. Note
      * that, if contents is specified, it will be mutated by the file!
@@ -259,14 +248,14 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     statSync(): Stats;
     /**
      * Asynchronous truncate.
-     * @param len
+     * @param length
      */
-    truncate(len: number): Promise<void>;
+    truncate(length: number): Promise<void>;
     /**
      * Synchronous truncate.
-     * @param len
+     * @param length
      */
-    truncateSync(len: number): void;
+    truncateSync(length: number): void;
     /**
      * Write buffer to the file.
      * Note that it is unsafe to use fs.write multiple times on the same file
@@ -345,11 +334,6 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     chownSync(uid: number, gid: number): void;
     utimes(atime: Date, mtime: Date): Promise<void>;
     utimesSync(atime: Date, mtime: Date): void;
-    protected isDirty(): boolean;
-    /**
-     * Resets the dirty bit. Should only be called after a sync has completed successfully.
-     */
-    protected resetDirty(): void;
     _setType(type: FileType): Promise<void>;
     _setTypeSync(type: FileType): void;
 }