@atlaspack/ts-utils 2.14.1-canary.26 → 2.14.1-canary.260

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # @atlaspack/ts-utils
 
+## 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
+
+- [#478](https://github.com/atlassian-labs/atlaspack/pull/478) [`570493b`](https://github.com/atlassian-labs/atlaspack/commit/570493beaf754e7985aebc7daaaf6dfcfa8fe56b) Thanks [@yamadapc](https://github.com/yamadapc)! - The first attempt at Version Packages didn't include the built artifacts.
+  This has hopefully been fixed, so this change will force those packages to re-release.
+
 ## 2.14.0
 
 ### Minor Changes

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.26+c7726ccfb",
+  "version": "2.14.1-canary.260+dc6e4b2bb",
   "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/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "dependencies": {
+    "@atlaspack/types-internal": "2.14.1-canary.260+dc6e4b2bb",
     "nullthrows": "^1.1.1"
   },
   "devDependencies": {
@@ -24,5 +26,9 @@
     "typescript": ">=3.0.0"
   },
   "type": "commonjs",
-  "gitHead": "c7726ccfbde03bad9f19e103d6b4ed0d279d837d"
-}
+  "scripts": {
+    "check-ts": "tsc --emitDeclarationOnly --rootDir src",
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
+  },
+  "gitHead": "dc6e4b2bb99f371d225c296dbf96363fdac52333"
+}

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);

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

@@ -1,13 +1,13 @@
-// @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 type {FileSystem, FilePath} from '@atlaspack/types-internal';
+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 +20,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 +40,7 @@ export class FSHost {
   directoryExists(filePath: FilePath): boolean {
     try {
       return this.fs.statSync(filePath).isDirectory();
-    } catch (err) {
+    } catch (err: any) {
       return false;
     }
   }
@@ -48,26 +48,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 +79,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 +99,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,5 @@
-// @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 type {FileSystem, FilePath} from '@atlaspack/types-internal';
+import TypeScriptModule from 'typescript'; // eslint-disable-line import/no-extraneous-dependencies
 import type {
   CompilerOptions,
   LanguageServiceHost as ILanguageServiceHost,
@@ -13,14 +11,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 +34,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 +51,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 +63,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,5 @@
-// @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 type {FileSystem, FilePath} from '@atlaspack/types-internal';
+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 +7,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,5 +1,4 @@
-// @flow
-import type {Config, PluginOptions} from '@atlaspack/types';
+import type {Config, PluginOptions} from '@atlaspack/types-internal';
 import {ParseConfigHost} from './ParseConfigHost';
 import path from 'path';
 import nullthrows from 'nullthrows';
@@ -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"]
+}