@parcel/types-internal 2.12.1-canary.3182

package/lib/unsafe.d.ts

@@ -0,0 +1,6 @@
+export type ConfigResult = any;
+export type AST = {
+  type: string;
+  version: string;
+  program: any;
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@parcel/types-internal",
+  "version": "2.12.1-canary.3182+2df56ed28",
+  "license": "MIT",
+  "main": "src/index.js",
+  "types": "lib/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parcel-bundler/parcel.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build-ts": "./scripts/build-ts.sh",
+    "check-ts": "tsc --noEmit lib/index.d.ts"
+  },
+  "dependencies": {
+    "@parcel/diagnostic": "2.0.0-canary.1559+2df56ed28",
+    "@parcel/feature-flags": "2.12.1-canary.3182+2df56ed28",
+    "@parcel/source-map": "^2.1.1",
+    "utility-types": "^3.10.0"
+  },
+  "gitHead": "2df56ed286ae41610d5ed9d439c37d6cd02c8ead"
+}

package/scripts/build-ts.js

@@ -0,0 +1,15 @@
+const fs = require('fs');
+const path = require('path');
+
+const typesPath = path.join(__dirname, '../lib/index.d.ts');
+
+let contents = fs.readFileSync(typesPath, 'utf8');
+// Some fixups of flow-to-ts output
+contents = contents.replace(
+  'Record<string, JSONValue>',
+  '{[key: string]: JSONValue}',
+);
+contents = contents.replace(/\$ReadOnlyMap/g, 'ReadonlyMap');
+contents = contents.replace(/\$ReadOnlySet/g, 'ReadonlySet');
+
+fs.writeFileSync(typesPath, contents);

package/scripts/build-ts.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+set -x
+set -e
+
+mkdir -p lib
+
+for file in src/*.js; do
+  npx flow-to-ts $file > lib/$(basename $file .js).d.ts
+done
+
+node ./scripts/build-ts.js

package/src/Cache.js

@@ -0,0 +1,28 @@
+// @flow strict-local
+
+import type {Readable} from 'stream';
+
+export interface Cache {
+  ensure(): Promise<void>;
+  has(key: string): Promise<boolean>;
+  get<T>(key: string): Promise<?T>;
+  set(key: string, value: mixed): 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>;
+  /**
+   * 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/src/DependencySpecifier.js

@@ -0,0 +1,4 @@
+// @flow strict-local
+
+/** See Dependency */
+export type DependencySpecifier = string;

package/src/FileCreateInvalidation.js

@@ -0,0 +1,22 @@
+// @flow
+
+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/src/FilePath.js

@@ -0,0 +1,3 @@
+// @flow strict-local
+
+export type FilePath = string;

package/src/FileSystem.js

@@ -0,0 +1,127 @@
+// @flow
+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,
+  ): 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): Readable;
+  createWriteStream(path: FilePath, options?: ?FileOptions): Writable;
+  cwd(): FilePath;
+  chdir(dir: FilePath): void;
+  watch(
+    dir: FilePath,
+    fn: (err: ?Error, events: Array<Event>) => mixed,
+    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;
+  findNodeModule(moduleName: string, fromDir: FilePath): ?FilePath;
+  findFirstFile(filePaths: Array<FilePath>): ?FilePath;
+}
+
+// https://nodejs.org/api/fs.html#fs_class_fs_dirent
+export interface Dirent {
+  +name: string;
+  isBlockDevice(): boolean;
+  isCharacterDevice(): boolean;
+  isDirectory(): boolean;
+  isFIFO(): boolean;
+  isFile(): boolean;
+  isSocket(): boolean;
+  isSymbolicLink(): boolean;
+}

package/src/Glob.js

@@ -0,0 +1,3 @@
+// @flow strict-local
+
+export type Glob = string;

package/src/PackageManager.js

@@ -0,0 +1,60 @@
+// @flow
+
+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,
+  invalidateOnFileCreate: Array<FileCreateInvalidation>,
+  invalidateOnFileChange: Set<FilePath>,
+  type: number,
+|};
+
+export type InstallOptions = {
+  installPeers?: boolean,
+  saveDev?: boolean,
+  packageInstaller?: ?PackageInstaller,
+  ...
+};
+
+export type InstallerOptions = {|
+  modules: Array<ModuleRequest>,
+  fs: FileSystem,
+  cwd: FilePath,
+  packagePath?: ?FilePath,
+  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,
+    ?{|range?: ?SemverRange, shouldAutoInstall?: boolean, saveDev?: boolean|},
+  ): Promise<any>;
+  resolve(
+    id: DependencySpecifier,
+    from: FilePath,
+    ?{|range?: ?SemverRange, shouldAutoInstall?: boolean, saveDev?: boolean|},
+  ): Promise<PackageManagerResolveResult>;
+  getInvalidations(id: DependencySpecifier, from: FilePath): Invalidations;
+  invalidate(id: DependencySpecifier, from: FilePath): void;
+}
+
+export type ModuleRequest = {|
+  +name: string,
+  +range: ?SemverRange,
+|};

package/src/PackageName.js

@@ -0,0 +1,3 @@
+// @flow strict-local
+
+export type PackageName = string;

package/src/SemverRange.js

@@ -0,0 +1,3 @@
+// @flow strict-local
+
+export type SemverRange = string;