@atlaspack/ts-utils 2.14.1-canary.32 → 2.14.1-canary.320

package/CHANGELOG.md

@@ -1,5 +1,99 @@
 # @atlaspack/ts-utils
 
+## 2.14.14
+
+### Patch Changes
+
+- Updated dependencies [[`c372f3f`](https://github.com/atlassian-labs/atlaspack/commit/c372f3fd6fce8200d5cf47f41bc7895c6cbb5558)]:
+  - @atlaspack/types-internal@2.20.5
+
+## 2.14.13
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.20.4
+
+## 2.14.12
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.20.3
+
+## 2.14.11
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.20.2
+
+## 2.14.10
+
+### Patch Changes
+
+- [#785](https://github.com/atlassian-labs/atlaspack/pull/785) [`0e7dd5e`](https://github.com/atlassian-labs/atlaspack/commit/0e7dd5ec6fbe05aa9e0bb5775a9d0975f206a922) Thanks [@matt-koko](https://github.com/matt-koko)! - We need to re-publish every package in Atlaspack with the corrected types field.
+
+- Updated dependencies [[`0e7dd5e`](https://github.com/atlassian-labs/atlaspack/commit/0e7dd5ec6fbe05aa9e0bb5775a9d0975f206a922)]:
+  - @atlaspack/types-internal@2.20.1
+
+## 2.14.9
+
+### Patch Changes
+
+- Updated dependencies [[`eedcbc4`](https://github.com/atlassian-labs/atlaspack/commit/eedcbc408fc1e86a2a8e25f1a41c57146d8529e1), [`f6532d7`](https://github.com/atlassian-labs/atlaspack/commit/f6532d7a4f7f007bd4e5e36af04dd466f0b9f572)]:
+  - @atlaspack/types-internal@2.20.0
+
+## 2.14.8
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.19.5
+
+## 2.14.7
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.19.4
+
+## 2.14.6
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.19.3
+
+## 2.14.5
+
+### Patch Changes
+
+- [#742](https://github.com/atlassian-labs/atlaspack/pull/742) [`ee040bb`](https://github.com/atlassian-labs/atlaspack/commit/ee040bb6428f29b57d892ddd8107e29077d08ffd) Thanks [@yamadapc](https://github.com/yamadapc)! - Internal changes and bug fixes to environmentDeduplication flag
+
+- Updated dependencies [[`ee040bb`](https://github.com/atlassian-labs/atlaspack/commit/ee040bb6428f29b57d892ddd8107e29077d08ffd)]:
+  - @atlaspack/types-internal@2.19.2
+
+## 2.14.4
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.19.1
+
+## 2.14.3
+
+### Patch Changes
+
+- Updated dependencies [[`7f5841c`](https://github.com/atlassian-labs/atlaspack/commit/7f5841c39df049f9546cccbeea2a7337e0337b45)]:
+  - @atlaspack/types-internal@2.19.0
+
+## 2.14.2
+
+### Patch Changes
+
+- [#720](https://github.com/atlassian-labs/atlaspack/pull/720) [`d2fd849`](https://github.com/atlassian-labs/atlaspack/commit/d2fd849770fe6305e9c694bd97b1bd905abd9d94) Thanks [@alshdavid](https://github.com/alshdavid)! - Migrate to TypeScript
+
 ## 2.14.1
 
 ### Patch Changes

package/dist/CompilerHost.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompilerHost = void 0;
+const path_1 = __importDefault(require("path"));
+const FSHost_1 = require("./FSHost");
+class CompilerHost extends FSHost_1.FSHost {
+    // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
+    constructor(fs, ts, logger) {
+        super(fs, ts);
+        // workaround for https://github.com/microsoft/TypeScript/issues/39547
+        this.redirectTypes = new Map();
+        this.logger = logger;
+    }
+    readFile(filePath) {
+        let contents = super.readFile(filePath);
+        if (contents && path_1.default.basename(filePath) === 'package.json') {
+            let json = JSON.parse(contents);
+            if (json.types != null &&
+                json.source != null &&
+                !super.fileExists(path_1.default.posix.join(path_1.default.posix.dirname(filePath), json.types))) {
+                let source = path_1.default.posix.join(path_1.default.posix.dirname(filePath), 
+                // @ts-expect-error Argument of type 'string | string[]' is not assignable to parameter of type 'string'.
+                json.source);
+                let fakeTypes = source.slice(0, -path_1.default.posix.extname(source).length) + '.d.ts';
+                this.redirectTypes.set(fakeTypes, source);
+                json.types = fakeTypes;
+                this.logger.verbose({
+                    message: `Faking missing \`types\` field in ${filePath} to be ${source}`,
+                });
+                return JSON.stringify(json);
+            }
+        }
+        return contents;
+    }
+    fileExists(filePath) {
+        if (this.redirectTypes.has(filePath)) {
+            return true;
+        }
+        else {
+            return super.fileExists(filePath);
+        }
+    }
+    getSourceFile(filePath, languageVersion) {
+        let redirect = this.redirectTypes.get(filePath);
+        if (redirect != null) {
+            const sourceText = this.readFile(redirect);
+            return sourceText !== undefined
+                ? this.ts.createSourceFile(filePath, sourceText, languageVersion)
+                : undefined;
+        }
+        else {
+            const sourceText = this.readFile(filePath);
+            return sourceText !== undefined
+                ? this.ts.createSourceFile(filePath, sourceText, languageVersion)
+                : undefined;
+        }
+    }
+    getDefaultLibFileName(options) {
+        return this.ts.getDefaultLibFilePath(options);
+    }
+    writeFile(filePath, content) {
+        if (path_1.default.extname(filePath) === '.map') {
+            this.outputMap = content;
+        }
+        else {
+            this.outputCode = content;
+        }
+    }
+    getCanonicalFileName(fileName) {
+        return this.ts.sys.useCaseSensitiveFileNames
+            ? fileName
+            : fileName.toLowerCase();
+    }
+    useCaseSensitiveFileNames() {
+        return this.ts.sys.useCaseSensitiveFileNames;
+    }
+    getNewLine() {
+        return this.ts.sys.newLine;
+    }
+}
+exports.CompilerHost = CompilerHost;

package/dist/FSHost.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FSHost = void 0;
+const path_1 = __importDefault(require("path"));
+class FSHost {
+    // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
+    constructor(fs, ts) {
+        this.getCurrentDirectory = () => {
+            return this.fs.cwd();
+        };
+        this.fs = fs;
+        this.ts = ts;
+    }
+    fileExists(filePath) {
+        try {
+            return this.fs.statSync(filePath).isFile();
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    readFile(filePath) {
+        try {
+            return this.fs.readFileSync(filePath, 'utf8');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                return undefined;
+            }
+            throw err;
+        }
+    }
+    directoryExists(filePath) {
+        try {
+            return this.fs.statSync(filePath).isDirectory();
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    realpath(filePath) {
+        try {
+            return this.fs.realpathSync(filePath);
+        }
+        catch (err) {
+            return filePath;
+        }
+    }
+    getAccessibleFileSystemEntries(dirPath) {
+        try {
+            let entries = this.fs.readdirSync(dirPath || '.').sort();
+            let files = [];
+            let directories = [];
+            for (let entry of entries) {
+                let filePath = path_1.default.join(dirPath, entry);
+                let stat;
+                try {
+                    stat = this.fs.statSync(filePath);
+                }
+                catch (e) {
+                    continue;
+                }
+                if (stat.isFile()) {
+                    files.push(entry);
+                }
+                else if (stat.isDirectory()) {
+                    directories.push(entry);
+                }
+            }
+            return { files, directories };
+        }
+        catch (err) {
+            return { files: [], directories: [] };
+        }
+    }
+    readDirectory(root, extensions, excludes, includes, depth) {
+        return this.ts.matchFiles(root, extensions, excludes, includes, this.ts.sys.useCaseSensitiveFileNames, this.getCurrentDirectory(), depth, (dirPath) => this.getAccessibleFileSystemEntries(dirPath), (filePath) => this.realpath(filePath), (dirPath) => this.directoryExists(dirPath));
+    }
+}
+exports.FSHost = FSHost;

package/dist/LanguageServiceHost.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageServiceHost = void 0;
+const FSHost_1 = require("./FSHost");
+// the typings from flow-typed define the ILanguageServiceHost interface as
+// having its methods as properties with arrow functions. These should probably
+// be methods instead.
+class LanguageServiceHost extends FSHost_1.FSHost {
+    // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
+    constructor(fs, ts, config) {
+        super(fs, ts);
+        this.config = config;
+        this.files = {};
+    }
+    invalidate(fileName) {
+        // When the typescript language server calls "getScriptVersion", it will normalize paths for cross-platform (e.g. C:\myFile.ts on Windows becomes C:/myFile.ts). We need to do the same thing.
+        const normalizedFileName = this.ts.getNormalizedAbsolutePath(fileName);
+        const entry = this.files[normalizedFileName];
+        if (entry) {
+            entry.version++;
+        }
+        else {
+            this.files[normalizedFileName] = {
+                version: 0,
+            };
+        }
+    }
+    getScriptFileNames() {
+        return this.config.fileNames;
+    }
+    getScriptVersion(fileName) {
+        // @ts-expect-error string | undefined
+        return this.files[fileName] && this.files[fileName].version.toString();
+    }
+    getScriptSnapshot(fileName) {
+        if (!this.fileExists(fileName)) {
+            return;
+        }
+        const content = this.readFile(fileName);
+        if (content) {
+            return this.ts.ScriptSnapshot.fromString(content);
+        }
+    }
+    getCompilationSettings() {
+        return this.config.options;
+    }
+    getDefaultLibFileName(projectOptions) {
+        return this.ts.getDefaultLibFilePath(projectOptions);
+    }
+}
+exports.LanguageServiceHost = LanguageServiceHost;

package/dist/ParseConfigHost.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseConfigHost = void 0;
+const FSHost_1 = require("./FSHost");
+class ParseConfigHost extends FSHost_1.FSHost {
+    // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
+    constructor(fs, ts) {
+        super(fs, ts);
+        this.filesRead = new Set();
+        this.useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;
+    }
+    readFile(filePath) {
+        this.filesRead.add(filePath);
+        return super.readFile(filePath);
+    }
+}
+exports.ParseConfigHost = ParseConfigHost;

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTSConfig = exports.LanguageServiceHost = exports.ParseConfigHost = exports.CompilerHost = exports.FSHost = void 0;
+var FSHost_1 = require("./FSHost");
+Object.defineProperty(exports, "FSHost", { enumerable: true, get: function () { return FSHost_1.FSHost; } });
+var CompilerHost_1 = require("./CompilerHost");
+Object.defineProperty(exports, "CompilerHost", { enumerable: true, get: function () { return CompilerHost_1.CompilerHost; } });
+var ParseConfigHost_1 = require("./ParseConfigHost");
+Object.defineProperty(exports, "ParseConfigHost", { enumerable: true, get: function () { return ParseConfigHost_1.ParseConfigHost; } });
+var LanguageServiceHost_1 = require("./LanguageServiceHost");
+Object.defineProperty(exports, "LanguageServiceHost", { enumerable: true, get: function () { return LanguageServiceHost_1.LanguageServiceHost; } });
+var loadTSConfig_1 = require("./loadTSConfig");
+Object.defineProperty(exports, "loadTSConfig", { enumerable: true, get: function () { return loadTSConfig_1.loadTSConfig; } });

package/dist/loadTSConfig.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTSConfig = loadTSConfig;
+const ParseConfigHost_1 = require("./ParseConfigHost");
+const path_1 = __importDefault(require("path"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const typescript_1 = __importDefault(require("typescript"));
+async function loadTSConfig(config, options) {
+    let configResult = await config.getConfig(['tsconfig.json']);
+    if (!configResult) {
+        return;
+    }
+    let host = new ParseConfigHost_1.ParseConfigHost(options.inputFS, typescript_1.default);
+    let parsedConfig = typescript_1.default.parseJsonConfigFileContent(configResult.contents, host, path_1.default.dirname((0, nullthrows_1.default)(configResult.filePath)));
+    // Add all of the extended config files to be watched
+    for (let file of host.filesRead) {
+        config.invalidateOnFileChange(path_1.default.resolve(file));
+    }
+    return parsedConfig.options;
+}

package/lib/CompilerHost.js

@@ -14,10 +14,14 @@ function _path() {
 var _FSHost = require("./FSHost");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // eslint-disable-line import/no-extraneous-dependencies
+
 // eslint-disable-line import/no-extraneous-dependencies
+
 class CompilerHost extends _FSHost.FSHost {
   // workaround for https://github.com/microsoft/TypeScript/issues/39547
   redirectTypes = new Map();
+
+  // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
   constructor(fs, ts, logger) {
     super(fs, ts);
     this.logger = logger;
@@ -27,7 +31,9 @@ class CompilerHost extends _FSHost.FSHost {
     if (contents && _path().default.basename(filePath) === 'package.json') {
       let json = JSON.parse(contents);
       if (json.types != null && json.source != null && !super.fileExists(_path().default.posix.join(_path().default.posix.dirname(filePath), json.types))) {
-        let source = _path().default.posix.join(_path().default.posix.dirname(filePath), json.source);
+        let source = _path().default.posix.join(_path().default.posix.dirname(filePath),
+        // @ts-expect-error Argument of type 'string | string[]' is not assignable to parameter of type 'string'.
+        json.source);
         let fakeTypes = source.slice(0, -_path().default.posix.extname(source).length) + '.d.ts';
         this.redirectTypes.set(fakeTypes, source);
         json.types = fakeTypes;

package/lib/FSHost.js

@@ -13,7 +13,11 @@ function _path() {
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // eslint-disable-line import/no-extraneous-dependencies
+
 class FSHost {
+  // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
+
+  // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
   constructor(fs, ts) {
     this.fs = fs;
     this.ts = ts;
@@ -83,7 +87,6 @@ class FSHost {
     }
   }
   readDirectory(root, extensions, excludes, includes, depth) {
-    // $FlowFixMe[prop-missing]
     return this.ts.matchFiles(root, extensions, excludes, includes, this.ts.sys.useCaseSensitiveFileNames, this.getCurrentDirectory(), depth, dirPath => this.getAccessibleFileSystemEntries(dirPath), filePath => this.realpath(filePath), dirPath => this.directoryExists(dirPath));
   }
 }

package/lib/LanguageServiceHost.js

@@ -6,11 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.LanguageServiceHost = void 0;
 var _FSHost = require("./FSHost");
 // eslint-disable-line import/no-extraneous-dependencies
+
 // the typings from flow-typed define the ILanguageServiceHost interface as
 // having its methods as properties with arrow functions. These should probably
 // be methods instead.
-// $FlowFixMe[method-unbinding]
 class LanguageServiceHost extends _FSHost.FSHost {
+  // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
   constructor(fs, ts, config) {
     super(fs, ts);
     this.config = config;
@@ -18,7 +19,6 @@ class LanguageServiceHost extends _FSHost.FSHost {
   }
   invalidate(fileName) {
     // When the typescript language server calls "getScriptVersion", it will normalize paths for cross-platform (e.g. C:\myFile.ts on Windows becomes C:/myFile.ts). We need to do the same thing.
-    // $FlowFixMe getNormalizedAbsolutePath is missing from the flow-typed definition.
     const normalizedFileName = this.ts.getNormalizedAbsolutePath(fileName);
     const entry = this.files[normalizedFileName];
     if (entry) {
@@ -33,6 +33,7 @@ class LanguageServiceHost extends _FSHost.FSHost {
     return this.config.fileNames;
   }
   getScriptVersion(fileName) {
+    // @ts-expect-error string | undefined
     return this.files[fileName] && this.files[fileName].version.toString();
   }
   getScriptSnapshot(fileName) {
@@ -41,7 +42,6 @@ class LanguageServiceHost extends _FSHost.FSHost {
     }
     const content = this.readFile(fileName);
     if (content) {
-      // $FlowFixMe
       return this.ts.ScriptSnapshot.fromString(content);
     }
   }

package/lib/ParseConfigHost.js

@@ -7,7 +7,9 @@ exports.ParseConfigHost = void 0;
 var _FSHost = require("./FSHost");
 // eslint-disable-line import/no-extraneous-dependencies
 // eslint-disable-line import/no-extraneous-dependencies
+
 class ParseConfigHost extends _FSHost.FSHost {
+  // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
   constructor(fs, ts) {
     super(fs, ts);
     this.filesRead = new Set();

package/lib/types/CompilerHost.d.ts

@@ -0,0 +1,19 @@
+import type { FilePath, FileSystem, PluginLogger } from '@atlaspack/types-internal';
+import type { CompilerOptions, SourceFile } from 'typescript';
+import { ScriptTarget } from 'typescript';
+import { FSHost } from './FSHost';
+export declare class CompilerHost extends FSHost {
+    outputCode: string | null | undefined;
+    outputMap: string | null | undefined;
+    logger: PluginLogger;
+    redirectTypes: Map<FilePath, FilePath>;
+    constructor(fs: FileSystem, ts: TypeScriptModule, logger: PluginLogger);
+    readFile(filePath: FilePath): undefined | string;
+    fileExists(filePath: FilePath): boolean;
+    getSourceFile(filePath: FilePath, languageVersion: ScriptTarget[keyof ScriptTarget]): undefined | SourceFile;
+    getDefaultLibFileName(options: CompilerOptions): string;
+    writeFile(filePath: FilePath, content: string): void;
+    getCanonicalFileName(fileName: FilePath): FilePath;
+    useCaseSensitiveFileNames(): boolean;
+    getNewLine(): string;
+}

package/lib/types/FSHost.d.ts

@@ -0,0 +1,16 @@
+import type { FileSystem, FilePath } from '@atlaspack/types-internal';
+export declare class FSHost {
+    fs: FileSystem;
+    ts: TypeScriptModule;
+    constructor(fs: FileSystem, ts: TypeScriptModule);
+    getCurrentDirectory: () => FilePath;
+    fileExists(filePath: FilePath): boolean;
+    readFile(filePath: FilePath): undefined | string;
+    directoryExists(filePath: FilePath): boolean;
+    realpath(filePath: FilePath): FilePath;
+    getAccessibleFileSystemEntries(dirPath: FilePath): {
+        directories: Array<FilePath>;
+        files: Array<FilePath>;
+    };
+    readDirectory(root: FilePath, extensions?: ReadonlyArray<string>, excludes?: ReadonlyArray<string>, includes?: ReadonlyArray<string>, depth?: number): any;
+}

package/lib/types/LanguageServiceHost.d.ts

@@ -0,0 +1,16 @@
+import type { FileSystem, FilePath } from '@atlaspack/types-internal';
+import type { CompilerOptions, LanguageServiceHost as ILanguageServiceHost, IScriptSnapshot, ParsedCommandLine } from 'typescript';
+import { FSHost } from './FSHost';
+export declare class LanguageServiceHost extends FSHost implements ILanguageServiceHost {
+    config: ParsedCommandLine;
+    files: Partial<Record<FilePath, {
+        version: number;
+    }>>;
+    constructor(fs: FileSystem, ts: TypeScriptModule, config: ParsedCommandLine);
+    invalidate(fileName: FilePath): void;
+    getScriptFileNames(): Array<string>;
+    getScriptVersion(fileName: FilePath): string;
+    getScriptSnapshot(fileName: string): IScriptSnapshot | undefined;
+    getCompilationSettings(): CompilerOptions;
+    getDefaultLibFileName(projectOptions: any): string;
+}

package/lib/types/ParseConfigHost.d.ts

@@ -0,0 +1,9 @@
+import type { FileSystem, FilePath } from '@atlaspack/types-internal';
+import type { ParseConfigHost as IParseConfigHost } from 'typescript';
+import { FSHost } from './FSHost';
+export declare class ParseConfigHost extends FSHost implements IParseConfigHost {
+    filesRead: Set<FilePath>;
+    useCaseSensitiveFileNames: boolean;
+    constructor(fs: FileSystem, ts: TypeScriptModule);
+    readFile(filePath: FilePath): undefined | string;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,5 @@
+export { FSHost } from './FSHost';
+export { CompilerHost } from './CompilerHost';
+export { ParseConfigHost } from './ParseConfigHost';
+export { LanguageServiceHost } from './LanguageServiceHost';
+export { loadTSConfig } from './loadTSConfig';

package/lib/types/loadTSConfig.d.ts

@@ -0,0 +1,2 @@
+import type { Config, PluginOptions } from '@atlaspack/types-internal';
+export declare function loadTSConfig(config: Config, options: PluginOptions): Promise<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/ts-utils",
-  "version": "2.14.1-canary.32+e27fbfb75",
+  "version": "2.14.1-canary.320+01868d011",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -9,12 +9,14 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "source": "src/index.js",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/types/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "dependencies": {
+    "@atlaspack/types-internal": "2.14.1-canary.320+01868d011",
     "nullthrows": "^1.1.1"
   },
   "devDependencies": {
@@ -24,5 +26,8 @@
     "typescript": ">=3.0.0"
   },
   "type": "commonjs",
-  "gitHead": "e27fbfb75c4809f493e2a48548546fbeddb375af"
-}
+  "scripts": {
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
+  },
+  "gitHead": "01868d0116693b7e80b5f7d3ba9fd3d21934525c"
+}

package/src/{CompilerHost.js → CompilerHost.ts}

@@ -1,26 +1,30 @@
-// @flow
-import type {FileSystem} from '@atlaspack/fs';
-import type {FilePath, PackageJSON, PluginLogger} from '@atlaspack/types';
-import typeof TypeScriptModule from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
+import type {
+  FilePath,
+  FileSystem,
+  PackageJSON,
+  PluginLogger,
+} from '@atlaspack/types-internal';
+import TypeScriptModule from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
 import type {CompilerOptions, SourceFile} from 'typescript';
-import typeof {ScriptTarget} from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
+import {ScriptTarget} from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
 
 import path from 'path';
 import {FSHost} from './FSHost';
 
 export class CompilerHost extends FSHost {
-  outputCode: ?string;
-  outputMap: ?string;
+  outputCode: string | null | undefined;
+  outputMap: string | null | undefined;
   logger: PluginLogger;
   // workaround for https://github.com/microsoft/TypeScript/issues/39547
   redirectTypes: Map<FilePath, FilePath> = new Map();
 
+  // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
   constructor(fs: FileSystem, ts: TypeScriptModule, logger: PluginLogger) {
     super(fs, ts);
     this.logger = logger;
   }
 
-  readFile(filePath: FilePath): void | string {
+  readFile(filePath: FilePath): undefined | string {
     let contents = super.readFile(filePath);
     if (contents && path.basename(filePath) === 'package.json') {
       let json: PackageJSON = JSON.parse(contents);
@@ -31,7 +35,11 @@ export class CompilerHost extends FSHost {
           path.posix.join(path.posix.dirname(filePath), json.types),
         )
       ) {
-        let source = path.posix.join(path.posix.dirname(filePath), json.source);
+        let source = path.posix.join(
+          path.posix.dirname(filePath),
+          // @ts-expect-error Argument of type 'string | string[]' is not assignable to parameter of type 'string'.
+          json.source,
+        );
         let fakeTypes =
           source.slice(0, -path.posix.extname(source).length) + '.d.ts';
         this.redirectTypes.set(fakeTypes, source);
@@ -55,8 +63,8 @@ export class CompilerHost extends FSHost {
 
   getSourceFile(
     filePath: FilePath,
-    languageVersion: $Values<ScriptTarget>,
-  ): void | SourceFile {
+    languageVersion: ScriptTarget[keyof ScriptTarget],
+  ): undefined | SourceFile {
     let redirect = this.redirectTypes.get(filePath);
     if (redirect != null) {
       const sourceText = this.readFile(redirect);