@poe-platform/safe-fs 0.1.730 → 0.1.732

package/dist/safe-fs/contracts/virtual-path.d.ts

@@ -1,6 +1,7 @@
 export declare const MAX_PATH_BYTES = 65536;
 export declare const MAX_PATH_COMPONENTS = 2048;
 export declare function validatePath(path: string, maxComponents?: number): void;
+export declare function resolvePath2(cwd: string, path0: string): string;
 export declare function resolvePath(cwd: string, ...paths: string[]): string;
 export declare function normalizePath(path: string, cwd?: string): string;
 export declare function dirname(path: string): string;

package/dist/safe-fs/contracts/virtual-path.js

@@ -23,14 +23,44 @@ export function validatePath(path, maxComponents = MAX_PATH_COMPONENTS) {
         }
     }
 }
-export function resolvePath(cwd, ...paths) {
-    validatePath(cwd);
-    if (!cwd.startsWith("/"))
-        throw new FsError("EINVAL", { syscall: "resolve", path: cwd, message: "cwd must be absolute" });
-    for (const path of paths)
-        validatePath(path);
+function isFastCleanAbsPath(path) {
+    const len = path.length;
+    if (len === 0 || path.charCodeAt(0) !== 47)
+        return false;
+    if (len === 1)
+        return true;
+    if (path.charCodeAt(len - 1) === 47)
+        return false;
+    let segStart = 1;
+    for (let i = 1; i < len; i++) {
+        const c = path.charCodeAt(i);
+        if (c === 0)
+            return false;
+        if (c === 47) {
+            const segLen = i - segStart;
+            if (segLen === 0)
+                return false;
+            if (segLen === 1 && path.charCodeAt(segStart) === 46)
+                return false;
+            if (segLen === 2 && path.charCodeAt(segStart) === 46 && path.charCodeAt(segStart + 1) === 46)
+                return false;
+            segStart = i + 1;
+        }
+    }
+    const lastLen = len - segStart;
+    if (lastLen === 1 && path.charCodeAt(segStart) === 46)
+        return false;
+    if (lastLen === 2 && path.charCodeAt(segStart) === 46 && path.charCodeAt(segStart + 1) === 46)
+        return false;
+    return true;
+}
+function resolvePathSlow(cwd, paths) {
+    const argLen = paths.length + 1;
     const components = [];
-    for (const path of [cwd, ...paths]) {
+    for (let a = 0; a < argLen; a++) {
+        const path = a === 0 ? cwd : paths[a - 1];
+        if (a > 0)
+            validatePath(path);
         if (path.startsWith("/"))
             components.length = 0;
         for (const component of path.split("/")) {
@@ -44,8 +74,38 @@ export function resolvePath(cwd, ...paths) {
     }
     return `/${components.join("/")}`;
 }
+export function resolvePath2(cwd, path0) {
+    validatePath(cwd);
+    if (cwd.charCodeAt(0) !== 47)
+        throw new FsError("EINVAL", { syscall: "resolve", path: cwd, message: "cwd must be absolute" });
+    validatePath(path0);
+    if (isFastCleanAbsPath(path0))
+        return path0;
+    if (isFastCleanAbsPath(cwd) && path0.length > 0 && path0.charCodeAt(0) !== 47 && !path0.includes("/")) {
+        if (path0 === ".")
+            return cwd;
+        if (path0 !== "..")
+            return cwd === "/" ? `/${path0}` : `${cwd}/${path0}`;
+    }
+    return resolvePathSlow(cwd, [path0]);
+}
+export function resolvePath(cwd, ...paths) {
+    validatePath(cwd);
+    if (!cwd.startsWith("/"))
+        throw new FsError("EINVAL", { syscall: "resolve", path: cwd, message: "cwd must be absolute" });
+    const argLen = paths.length + 1;
+    if (argLen === 1) {
+        if (isFastCleanAbsPath(cwd))
+            return cwd;
+        return resolvePathSlow(cwd, paths);
+    }
+    if (argLen === 2) {
+        return resolvePath2(cwd, paths[0]);
+    }
+    return resolvePathSlow(cwd, paths);
+}
 export function normalizePath(path, cwd = "/") {
-    return resolvePath(cwd, path);
+    return resolvePath2(cwd, path);
 }
 export function dirname(path) {
     if (typeof path !== "string")

package/dist/safe-fs/fs/devices/index.js

@@ -46,8 +46,17 @@ function globalCapabilities(filesystem) {
                 let declared = filesystem.capabilities[key];
                 if (key === "atomicEntryRemovalReceipt")
                     declared = ownedMutationCapabilities(filesystem).atomicEntryRemovalReceipt;
-                if (declared === true && optional[key]?.some(method => typeof filesystem[method] !== "function"))
-                    declared = false;
+                if (declared === true) {
+                    const req = optional[key];
+                    if (req) {
+                        for (let i = 0; i < req.length; i++) {
+                            if (typeof filesystem[req[i]] !== "function") {
+                                declared = false;
+                                break;
+                            }
+                        }
+                    }
+                }
                 if (key === "retainedResize" && filesystem.capabilities.readOnly === true)
                     declared = false;
                 if (key === "descriptorWriteStream" && filesystem.capabilities.streamingWrite === false)

package/dist/safe-fs/fs/memory/index.d.ts

@@ -1,6 +1,6 @@
 import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileReadHandle, FileResizeHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, ChmodOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, FileDescriptor, OpenFileOptions, OpenReadFileOptions, OpenResizeFileOptions, WriteFileOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, ConditionalRemoveEntryReceiptOptions, CreateStagedFileOptions, FileStaging, FileStagingEntry, FileStagingResolution, PublishStagedFileOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
-import { MemoryAllocation } from "./ledger.js";
+import { MemoryAllocation, MemoryLedger } from "./ledger.js";
 import { type MemoryFileSystemOptions } from "./limits.js";
 export { defaultMemoryFileSystemLimits, type MemoryFileSystemLimits, type MemoryFileSystemOptions } from "./limits.js";
 interface Metadata {
@@ -16,11 +16,41 @@ interface Metadata {
 }
 interface FileNode extends Metadata {
     type: "file";
+    sourceRef?: Uint8Array | undefined;
     byteLength: number;
     view: Uint8Array | undefined;
     data: Uint8Array;
     allocation: MemoryAllocation;
 }
+interface DirectoryNode extends Metadata {
+    type: "directory";
+    entries: Map<string, MemoryNode>;
+    cachedNlink?: number;
+    cachedNlinkRev?: number;
+}
+interface SymlinkNode extends Metadata {
+    type: "symlink";
+    target: string;
+}
+type MemoryNode = FileNode | DirectoryNode | SymlinkNode;
+declare class MemoryCache {
+    readonly allocations: MemoryAllocation[];
+    readonly files: FileNode[];
+    readonly directories: DirectoryNode[];
+    readonly removedScratch: MemoryNode[];
+    lastFastDirPrefix: string;
+    lastFastDirNode: DirectoryNode | undefined;
+    lastFastFilePath: string;
+    lastFastFileName: string;
+    lastFastFileNode: FileNode | undefined;
+    clearWrites(): void;
+}
+type OwnedStore = {
+    root: DirectoryNode;
+    ledger: MemoryLedger;
+    capabilities: FileSystem["capabilities"];
+    intact: () => boolean;
+};
 export interface ConditionalMutationBinding {
     readonly path: string;
     readonly parent: FileStat;
@@ -34,6 +64,9 @@ export declare class MemoryFileSystem implements FileSystem {
     private readonly identityScope;
     private nextInode;
     private readonly ledger;
+    readonly _cache: MemoryCache;
+    mutationTick: number;
+    readonly _owner: OwnedStore;
     private readonly root;
     private totalBytes;
     symlinkCount: number;
@@ -69,8 +102,10 @@ export declare class MemoryFileSystem implements FileSystem {
     private openWrite;
     private writeData;
     private writeAt;
+    private writeAtRange;
     writeMemoryFileFast(path: string, data: Uint8Array, append: boolean, mode: number): void;
-    writeMemoryFileInDirFast(dirPrefix: string, name: string, data: Uint8Array, append: boolean, mode: number): void;
+    writeMemoryFilesInDirBatchFast(firstFileName: string, dirPrefix: string, fileNames: readonly string[], nameHashes: Int32Array, payloads: readonly Uint8Array[], totalNameBytes: number, payloadBytesSum: number, mode: number): void;
+    writeMemoryFileInDirFast(dirPrefix: string, name: string, data: Uint8Array, append: boolean, mode: number, nameHash?: number): void;
     readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
     private expectEntry;
     private stagingLocations;
@@ -95,6 +130,8 @@ export declare class MemoryFileSystem implements FileSystem {
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
     readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
+    tryMkdirFastSync(path: string, recursive: boolean, mode: number | undefined): boolean;
+    tryRmFastSync(path: string, recursive: boolean, force: boolean): boolean;
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rmdir(path: string, options?: FsOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions & Partial<ConditionalMutationBinding>): Promise<void>;
@@ -118,13 +155,16 @@ export declare class MemoryFileSystem implements FileSystem {
 }
 export declare function createMemoryFileSystem(options?: MemoryFileSystemOptions | Readonly<Record<string, unknown>>): MemoryFileSystem;
 export declare class MemoryRedirectHandle {
-    readonly fs: MemoryFileSystem;
-    readonly path: string;
-    readonly node: FileNode;
-    readonly append: boolean;
+    fs: MemoryFileSystem;
+    path: string;
+    node: FileNode;
+    append: boolean;
     position: number;
     closed: boolean;
     constructor(fs: MemoryFileSystem, path: string, node: FileNode, append: boolean);
+    reset(fs: MemoryFileSystem, path: string, node: FileNode, append: boolean): void;
+    writeRangeSync(src: Uint8Array, len: number, signal?: AbortSignal): void;
+    writeImmutableSync(immutableData: Uint8Array, signal?: AbortSignal): void;
     writeSync(chunk: Uint8Array, signal?: AbortSignal): void;
     close(): void;
 }
@@ -132,11 +172,12 @@ export declare function tryOpenMemoryRedirectHandleSync(filesystem: FileSystem,
 export declare function utf8ByteLength(value: string): number;
 export declare function isCleanAbsolutePath(path: string): boolean;
 export declare function tryResolveMemoryDevicePath(filesystem: FileSystem, path: string, resizeCreate?: boolean): string | undefined;
-export declare function tryReadMemoryFileViewSync(filesystem: FileSystem, path: string, maxBytes?: number, signal?: AbortSignal): Uint8Array | undefined;
+export declare function getLastReadMemoryFileSourceRef(view: Uint8Array): Uint8Array | undefined;
+export declare function tryReadMemoryFileViewSync(filesystem: FileSystem, path: string, maxBytes?: number, signal?: AbortSignal, captureSourceRef?: boolean): Uint8Array | undefined;
 export declare function tryGetMemoryDirectoryEntryNamesSync(filesystem: FileSystem, path: string): ReadonlyMap<string, {
     readonly type: "file" | "directory" | "symlink";
 }> | undefined;
 export declare function tryWriteMemoryFileSync(filesystem: FileSystem, path: string, data: Uint8Array, append: boolean, mode: number, signal?: AbortSignal): boolean;
-export declare function tryMkdirMemorySync(filesystem: FileSystem, path: string, recursive: boolean, mode: number, signal?: AbortSignal): boolean;
+export declare function tryMkdirMemorySync(filesystem: FileSystem, path: string, recursive: boolean, mode: number, signal?: AbortSignal, dirPrefixHint?: string): boolean;
 export declare function tryRmRfMemorySync(filesystem: FileSystem, path: string, signal?: AbortSignal): boolean;
 export declare function tryWriteMemoryFileInDirSync(filesystem: FileSystem, dirPrefix: string, name: string, data: Uint8Array, append: boolean, mode: number, signal?: AbortSignal): boolean;