@atlaspack/fs 2.15.16-typescript-e99c742e9.0 → 2.15.16-typescript-5b4d3ad41.0

package/lib/MemoryFS.d.ts

@@ -0,0 +1,165 @@
+import type { FilePath, FileSystem, FileOptions, ReaddirOptions, Encoding } from '@atlaspack/types-internal';
+import type { Event, Options as WatcherOptions, AsyncSubscription } from '@parcel/watcher';
+import { Readable, Writable } from 'stream';
+import WorkerFarm, { Handle } from '@atlaspack/workers';
+import EventEmitter from 'events';
+type HandleFunction = (...args: Array<any>) => any;
+type SerializedMemoryFS = {
+    id: number;
+    handle: any;
+    dirs: Map<FilePath, Directory>;
+    files: Map<FilePath, File>;
+    symlinks: Map<FilePath, FilePath>;
+};
+type WorkerEvent = {
+    type: 'writeFile' | 'unlink' | 'mkdir' | 'symlink';
+    path: FilePath;
+    entry?: Entry;
+    target?: FilePath;
+};
+type ResolveFunction = () => unknown;
+export declare class MemoryFS implements FileSystem {
+    dirs: Map<FilePath, Directory>;
+    files: Map<FilePath, File>;
+    symlinks: Map<FilePath, FilePath>;
+    watchers: Map<FilePath, Set<Watcher>>;
+    events: Array<Event>;
+    id: number;
+    handle: Handle;
+    farm: WorkerFarm;
+    _cwd: FilePath;
+    _eventQueue: Array<Event>;
+    _watcherTimer: number;
+    _numWorkerInstances: number;
+    _workerHandles: Array<Handle>;
+    _workerRegisterResolves: Array<ResolveFunction>;
+    _emitter: EventEmitter;
+    constructor(workerFarm: WorkerFarm);
+    static deserialize(opts: SerializedMemoryFS): MemoryFS | WorkerFS;
+    serialize(): SerializedMemoryFS;
+    decrementWorkerInstance(): void;
+    cwd(): FilePath;
+    chdir(dir: FilePath): void;
+    _normalizePath(filePath: FilePath, realpath?: boolean): FilePath;
+    writeFile(filePath: FilePath, contents: Buffer | string, options?: FileOptions | null): Promise<void>;
+    readFile(filePath: FilePath, encoding?: Encoding): Promise<any>;
+    readFileSync(filePath: FilePath, encoding?: Encoding): any;
+    copyFile(source: FilePath, destination: FilePath): Promise<void>;
+    statSync(filePath: FilePath): Stat;
+    stat(filePath: FilePath): Promise<Stat>;
+    readdirSync(dir: FilePath, opts?: ReaddirOptions): any;
+    readdir(dir: FilePath, opts?: ReaddirOptions): Promise<any>;
+    unlink(filePath: FilePath): Promise<void>;
+    mkdirp(dir: FilePath): Promise<void>;
+    rimraf(filePath: FilePath): Promise<void>;
+    ncp(source: FilePath, destination: FilePath): Promise<void>;
+    createReadStream(filePath: FilePath): ReadStream;
+    createWriteStream(filePath: FilePath, options?: FileOptions | null): WriteStream;
+    realpathSync(filePath: FilePath): FilePath;
+    realpath(filePath: FilePath): Promise<FilePath>;
+    symlink(target: FilePath, path: FilePath): Promise<void>;
+    existsSync(filePath: FilePath): boolean;
+    exists(filePath: FilePath): Promise<boolean>;
+    _triggerEvent(event: Event): void;
+    _registerWorker(handle: Handle): void;
+    _sendWorkerEvent(event: WorkerEvent): Promise<void>;
+    watch(dir: FilePath, fn: (err: Error | null | undefined, events: Array<Event>) => unknown, opts: WatcherOptions): Promise<AsyncSubscription>;
+    getEventsSince(dir: FilePath, snapshot: FilePath, opts: WatcherOptions): Promise<Array<Event>>;
+    writeSnapshot(dir: FilePath, snapshot: FilePath): Promise<void>;
+    findAncestorFile(fileNames: Array<string>, fromDir: FilePath, root: FilePath): FilePath | null | undefined;
+    findNodeModule(moduleName: string, fromDir: FilePath): FilePath | null | undefined;
+    findFirstFile(filePaths: Array<FilePath>): FilePath | null | undefined;
+}
+declare class Watcher {
+    fn: (err: Error | null | undefined, events: Array<Event>) => unknown;
+    options: WatcherOptions;
+    constructor(fn: (err: Error | null | undefined, events: Array<Event>) => unknown, options: WatcherOptions);
+    trigger(events: Array<Event>): void;
+}
+export declare class FSError extends Error {
+    code: string;
+    path: FilePath;
+    constructor(code: string, path: FilePath, message: string);
+}
+declare class ReadStream extends Readable {
+    fs: FileSystem;
+    filePath: FilePath;
+    reading: boolean;
+    bytesRead: number;
+    constructor(fs: FileSystem, filePath: FilePath);
+    _read(): void;
+}
+declare class WriteStream extends Writable {
+    fs: FileSystem;
+    filePath: FilePath;
+    options: FileOptions | null | undefined;
+    buffer: Buffer;
+    constructor(fs: FileSystem, filePath: FilePath, options?: FileOptions | null);
+    _write(chunk: Buffer | string, encoding: any, callback: (error?: Error) => void): void;
+    _final(callback: (error?: Error) => void): void;
+}
+declare class Entry {
+    mode: number;
+    atime: number;
+    mtime: number;
+    ctime: number;
+    birthtime: number;
+    constructor(mode: number);
+    access(): void;
+    modify(mode: number): void;
+    getSize(): number;
+    stat(): Stat;
+}
+declare class Stat {
+    dev: number;
+    ino: number;
+    mode: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    rdev: number;
+    size: number;
+    blksize: number;
+    blocks: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+    constructor(entry: Entry);
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export declare class File extends Entry {
+    buffer: Buffer;
+    constructor(buffer: Buffer, mode: number);
+    read(): Buffer;
+    write(buffer: Buffer, mode: number): void;
+    getSize(): number;
+}
+declare class Directory extends Entry {
+    constructor();
+}
+export declare function makeShared(contents: Buffer | string): Buffer;
+declare class WorkerFS extends MemoryFS {
+    id: number;
+    handleFn: HandleFunction;
+    constructor(id: number, handle: Handle);
+    static deserialize(opts: SerializedMemoryFS): MemoryFS;
+    serialize(): SerializedMemoryFS;
+    writeFile(filePath: FilePath, contents: Buffer | string, options?: FileOptions | null): Promise<void>;
+    unlink(filePath: FilePath): Promise<void>;
+    mkdirp(dir: FilePath): Promise<void>;
+    rimraf(filePath: FilePath): Promise<void>;
+    ncp(source: FilePath, destination: FilePath): Promise<void>;
+    symlink(target: FilePath, path: FilePath): Promise<void>;
+}
+export {};