@atlaspack/types-internal 2.14.1-canary.51 → 2.14.1-canary.511

package/lib/types/FileSystem.d.ts

@@ -0,0 +1,90 @@
+import type { FilePath } from './FilePath';
+import type { Readable, Writable } from 'stream';
+import type { Event, Options as WatcherOptions, AsyncSubscription } from '@parcel/watcher';
+export type FileOptions = {
+    mode?: number;
+};
+export type ReaddirOptions = {
+    withFileTypes?: false;
+} | {
+    withFileTypes: true;
+};
+export interface Stats {
+    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;
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export type Encoding = 'hex' | 'utf8' | 'utf-8' | 'ascii' | 'binary' | 'base64' | 'ucs2' | 'ucs-2' | 'utf16le' | 'latin1';
+export interface FileSystem {
+    readFile(filePath: FilePath): Promise<Buffer>;
+    readFile(filePath: FilePath, encoding: Encoding): Promise<string>;
+    readFileSync(filePath: FilePath): Buffer;
+    readFileSync(filePath: FilePath, encoding: Encoding): string;
+    writeFile(filePath: FilePath, contents: Buffer | string, options?: FileOptions | null | undefined): Promise<void>;
+    copyFile(source: FilePath, destination: FilePath, flags?: number): Promise<void>;
+    stat(filePath: FilePath): Promise<Stats>;
+    statSync(filePath: FilePath): Stats;
+    readdir(path: FilePath, opts?: {
+        withFileTypes?: false;
+    }): Promise<FilePath[]>;
+    readdir(path: FilePath, opts: {
+        withFileTypes: true;
+    }): Promise<Dirent[]>;
+    readdirSync(path: FilePath, opts?: {
+        withFileTypes?: false;
+    }): FilePath[];
+    readdirSync(path: FilePath, opts: {
+        withFileTypes: true;
+    }): Dirent[];
+    symlink(target: FilePath, path: FilePath): Promise<void>;
+    unlink(path: FilePath): Promise<void>;
+    realpath(path: FilePath): Promise<FilePath>;
+    realpathSync(path: FilePath): FilePath;
+    exists(path: FilePath): Promise<boolean>;
+    existsSync(path: FilePath): boolean;
+    mkdirp(path: FilePath): Promise<void>;
+    rimraf(path: FilePath): Promise<void>;
+    ncp(source: FilePath, destination: FilePath): Promise<void>;
+    createReadStream(path: FilePath, options?: FileOptions | null | undefined): Readable;
+    createWriteStream(path: FilePath, options?: FileOptions | null | undefined): Writable;
+    cwd(): FilePath;
+    chdir(dir: FilePath): 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, opts: WatcherOptions): 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;
+}
+export interface Dirent {
+    readonly name: string;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isDirectory(): boolean;
+    isFIFO(): boolean;
+    isFile(): boolean;
+    isSocket(): boolean;
+    isSymbolicLink(): boolean;
+}

package/lib/types/NapiWorkerPool.d.ts

@@ -0,0 +1,5 @@
+export type Transferable = Record<any, any>;
+export interface NapiWorkerPool {
+    getWorkers(): Promise<Array<Transferable>>;
+    shutdown(): void;
+}

package/lib/types/PackageManager.d.ts

@@ -0,0 +1,50 @@
+import type { FileCreateInvalidation, PackageJSON } from './index';
+import type { SemverRange } from './SemverRange';
+import type { DependencySpecifier } from './DependencySpecifier';
+import type { FileSystem } from './FileSystem';
+import type { FilePath } from './FilePath';
+export type PackageManagerResolveResult = {
+    resolved: FilePath | DependencySpecifier;
+    pkg?: PackageJSON | null | undefined;
+    invalidateOnFileCreate: Array<FileCreateInvalidation>;
+    invalidateOnFileChange: Set<FilePath>;
+    type: number;
+};
+export type InstallOptions = {
+    installPeers?: boolean;
+    saveDev?: boolean;
+    packageInstaller?: PackageInstaller | null | undefined;
+};
+export type InstallerOptions = {
+    modules: Array<ModuleRequest>;
+    fs: FileSystem;
+    cwd: FilePath;
+    packagePath?: FilePath | null | undefined;
+    saveDev?: boolean;
+};
+export interface PackageInstaller {
+    install(opts: InstallerOptions): Promise<void>;
+}
+export type Invalidations = {
+    invalidateOnFileCreate: Array<FileCreateInvalidation>;
+    invalidateOnFileChange: Set<FilePath>;
+    invalidateOnStartup: boolean;
+};
+export interface PackageManager {
+    require(id: DependencySpecifier, from: FilePath, arg3?: {
+        range?: SemverRange | null | undefined;
+        shouldAutoInstall?: boolean;
+        saveDev?: boolean;
+    } | null | undefined): Promise<any>;
+    resolve(id: DependencySpecifier, from: FilePath, arg3?: {
+        range?: SemverRange | null | undefined;
+        shouldAutoInstall?: boolean;
+        saveDev?: boolean;
+    } | null | undefined): Promise<PackageManagerResolveResult>;
+    getInvalidations(id: DependencySpecifier, from: FilePath): Invalidations;
+    invalidate(id: DependencySpecifier, from: FilePath): void;
+}
+export type ModuleRequest = {
+    readonly name: string;
+    readonly range: SemverRange | null | undefined;
+};