@parcel/types-internal 2.12.1-canary.3182

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-present Devon Govett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/Cache.d.ts

@@ -0,0 +1,24 @@
+import type { Readable } from "stream";
+export interface Cache {
+  ensure(): Promise<void>;
+  has(key: string): Promise<boolean>;
+  get<T>(key: string): Promise<T | null | undefined>;
+  set(key: string, value: unknown): Promise<void>;
+  getStream(key: string): Readable;
+  setStream(key: string, stream: Readable): Promise<void>;
+  getBlob(key: string): Promise<Buffer>;
+  setBlob(key: string, contents: Buffer | string): Promise<void>;
+  hasLargeBlob(key: string): Promise<boolean>;
+  getLargeBlob(key: string): Promise<Buffer>;
+  setLargeBlob(key: string, contents: Buffer | string, options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  getBuffer(key: string): Promise<Buffer | null | undefined>;
+
+  /**
+   * In a multi-threaded environment, where there are potentially multiple Cache
+   * instances writing to the cache, ensure that this instance has the latest view
+   * of the changes that may have been written to the cache in other threads.
+   */
+  refresh(): void;
+}

package/lib/DependencySpecifier.d.ts

@@ -0,0 +1,2 @@
+/** See Dependency */
+export type DependencySpecifier = string;

package/lib/FileCreateInvalidation.d.ts

@@ -0,0 +1,13 @@
+import type { Glob } from "./Glob";
+import type { FilePath } from "./FilePath";
+export type GlobInvalidation = {
+  glob: Glob;
+};
+export type FileInvalidation = {
+  filePath: FilePath;
+};
+export type FileAboveInvalidation = {
+  fileName: string;
+  aboveFilePath: FilePath;
+};
+export type FileCreateInvalidation = FileInvalidation | GlobInvalidation | FileAboveInvalidation;

package/lib/FilePath.d.ts

@@ -0,0 +1 @@
+export type FilePath = string;

package/lib/FileSystem.d.ts

@@ -0,0 +1,91 @@
+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;
+}
+// https://nodejs.org/api/fs.html#fs_class_fs_dirent
+export interface Dirent {
+  readonly name: string;
+  isBlockDevice(): boolean;
+  isCharacterDevice(): boolean;
+  isDirectory(): boolean;
+  isFIFO(): boolean;
+  isFile(): boolean;
+  isSocket(): boolean;
+  isSymbolicLink(): boolean;
+}

package/lib/Glob.d.ts

@@ -0,0 +1 @@
+export type Glob = string;

package/lib/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, arg2: {
+    range?: SemverRange | null | undefined;
+    shouldAutoInstall?: boolean;
+    saveDev?: boolean;
+  } | null | undefined): Promise<any>;
+  resolve(id: DependencySpecifier, from: FilePath, arg2: {
+    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;
+};

package/lib/PackageName.d.ts

@@ -0,0 +1 @@
+export type PackageName = string;

package/lib/SemverRange.d.ts

@@ -0,0 +1 @@
+export type SemverRange = string;