@atlaspack/ts-utils 2.14.2-typescript-e769947a5.0 → 2.14.2-typescript-08dcc1c9b.0

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/ts-utils",
-  "version": "2.14.2-typescript-e769947a5.0",
+  "version": "2.14.2-typescript-08dcc1c9b.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -10,7 +10,7 @@
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
   "main": "lib/index.js",
-  "source": "src/index.js",
+  "source": "src/index.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
@@ -24,5 +24,9 @@
     "typescript": ">=3.0.0"
   },
   "type": "commonjs",
-  "gitHead": "e769947a5b0c22d9477211ac1ce6614e6bf9def3"
+  "scripts": {
+    "check-ts": "tsc --noEmit"
+  },
+  "types": "src/index.ts",
+  "gitHead": "08dcc1c9bcdc6ab931d55e05ccc0f45669de2f22"
 }

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

@@ -1,26 +1,26 @@
-// @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 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 +31,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 +59,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);

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

@@ -1,13 +1,14 @@
-// @flow
 import type {FileSystem} from '@atlaspack/fs';
 import type {FilePath} from '@atlaspack/types';
-import typeof TypeScriptModule from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
+import TypeScriptModule from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
 import path from 'path';
 
 export class FSHost {
   fs: FileSystem;
+  // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
   ts: TypeScriptModule;
 
+  // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
   constructor(fs: FileSystem, ts: TypeScriptModule) {
     this.fs = fs;
     this.ts = ts;
@@ -20,15 +21,15 @@ export class FSHost {
   fileExists(filePath: FilePath): boolean {
     try {
       return this.fs.statSync(filePath).isFile();
-    } catch (err) {
+    } catch (err: any) {
       return false;
     }
   }
 
-  readFile(filePath: FilePath): void | string {
+  readFile(filePath: FilePath): undefined | string {
     try {
       return this.fs.readFileSync(filePath, 'utf8');
-    } catch (err) {
+    } catch (err: any) {
       if (err.code === 'ENOENT') {
         return undefined;
       }
@@ -40,7 +41,7 @@ export class FSHost {
   directoryExists(filePath: FilePath): boolean {
     try {
       return this.fs.statSync(filePath).isDirectory();
-    } catch (err) {
+    } catch (err: any) {
       return false;
     }
   }
@@ -48,26 +49,26 @@ export class FSHost {
   realpath(filePath: FilePath): FilePath {
     try {
       return this.fs.realpathSync(filePath);
-    } catch (err) {
+    } catch (err: any) {
       return filePath;
     }
   }
 
-  getAccessibleFileSystemEntries(dirPath: FilePath): {|
-    directories: Array<FilePath>,
-    files: Array<FilePath>,
-  |} {
+  getAccessibleFileSystemEntries(dirPath: FilePath): {
+    directories: Array<FilePath>;
+    files: Array<FilePath>;
+  } {
     try {
       let entries = this.fs.readdirSync(dirPath || '.').sort();
-      let files = [];
-      let directories = [];
+      let files: Array<FilePath> = [];
+      let directories: Array<FilePath> = [];
       for (let entry of entries) {
         let filePath = path.join(dirPath, entry);
 
         let stat;
         try {
           stat = this.fs.statSync(filePath);
-        } catch (e) {
+        } catch (e: any) {
           continue;
         }
 
@@ -79,19 +80,18 @@ export class FSHost {
       }
 
       return {files, directories};
-    } catch (err) {
+    } catch (err: any) {
       return {files: [], directories: []};
     }
   }
 
   readDirectory(
     root: FilePath,
-    extensions?: $ReadOnlyArray<string>,
-    excludes?: $ReadOnlyArray<string>,
-    includes?: $ReadOnlyArray<string>,
+    extensions?: ReadonlyArray<string>,
+    excludes?: ReadonlyArray<string>,
+    includes?: ReadonlyArray<string>,
     depth?: number,
   ): any {
-    // $FlowFixMe[prop-missing]
     return this.ts.matchFiles(
       root,
       extensions,
@@ -100,9 +100,9 @@ export class FSHost {
       this.ts.sys.useCaseSensitiveFileNames,
       this.getCurrentDirectory(),
       depth,
-      (dirPath) => this.getAccessibleFileSystemEntries(dirPath),
-      (filePath) => this.realpath(filePath),
-      (dirPath) => this.directoryExists(dirPath),
+      (dirPath: any) => this.getAccessibleFileSystemEntries(dirPath),
+      (filePath: any) => this.realpath(filePath),
+      (dirPath: any) => this.directoryExists(dirPath),
     );
   }
 }

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

@@ -1,7 +1,6 @@
-// @flow
 import type {FileSystem} from '@atlaspack/fs';
 import type {FilePath} from '@atlaspack/types';
-import typeof TypeScriptModule from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
+import TypeScriptModule from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
 import type {
   CompilerOptions,
   LanguageServiceHost as ILanguageServiceHost,
@@ -13,14 +12,21 @@ import {FSHost} from './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.
-// $FlowFixMe[method-unbinding]
 export class LanguageServiceHost
   extends FSHost
   implements ILanguageServiceHost
 {
   config: ParsedCommandLine;
-  files: {|[key: FilePath]: {|version: number|}|};
+  files: Partial<
+    Record<
+      FilePath,
+      {
+        version: number;
+      }
+    >
+  >;
 
+  // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
   constructor(fs: FileSystem, ts: TypeScriptModule, config: ParsedCommandLine) {
     super(fs, ts);
     this.config = config;
@@ -29,7 +35,6 @@ export class LanguageServiceHost
 
   invalidate(fileName: FilePath) {
     // 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];
 
@@ -47,10 +52,11 @@ export class LanguageServiceHost
   }
 
   getScriptVersion(fileName: FilePath): string {
+    // @ts-expect-error string | undefined
     return this.files[fileName] && this.files[fileName].version.toString();
   }
 
-  getScriptSnapshot(fileName: string): IScriptSnapshot | void {
+  getScriptSnapshot(fileName: string): IScriptSnapshot | undefined {
     if (!this.fileExists(fileName)) {
       return;
     }
@@ -58,7 +64,6 @@ export class LanguageServiceHost
     const content = this.readFile(fileName);
 
     if (content) {
-      // $FlowFixMe
       return this.ts.ScriptSnapshot.fromString(content);
     }
   }

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

@@ -1,7 +1,6 @@
-// @flow
 import type {FileSystem} from '@atlaspack/fs';
 import type {FilePath} from '@atlaspack/types';
-import typeof TypeScriptModule from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
+import TypeScriptModule from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
 import type {ParseConfigHost as IParseConfigHost} from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
 import {FSHost} from './FSHost';
 
@@ -9,13 +8,14 @@ export class ParseConfigHost extends FSHost implements IParseConfigHost {
   filesRead: Set<FilePath>;
   useCaseSensitiveFileNames: boolean;
 
+  // @ts-expect-error Cannot use namespace 'TypeScriptModule' as a type.
   constructor(fs: FileSystem, ts: TypeScriptModule) {
     super(fs, ts);
     this.filesRead = new Set();
     this.useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;
   }
 
-  readFile(filePath: FilePath): void | string {
+  readFile(filePath: FilePath): undefined | string {
     this.filesRead.add(filePath);
     return super.readFile(filePath);
   }

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

@@ -1,4 +1,3 @@
-// @flow
 export {FSHost} from './FSHost';
 export {CompilerHost} from './CompilerHost';
 export {ParseConfigHost} from './ParseConfigHost';

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

@@ -1,4 +1,3 @@
-// @flow
 import type {Config, PluginOptions} from '@atlaspack/types';
 import {ParseConfigHost} from './ParseConfigHost';
 import path from 'path';
@@ -8,7 +7,7 @@ import ts from 'typescript';
 export async function loadTSConfig(
   config: Config,
   options: PluginOptions,
-): any {
+): Promise<any> {
   let configResult = await config.getConfig(['tsconfig.json']);
   if (!configResult) {
     return;

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.json",
+  "include": ["src"]
+}