Fix strict issues

src/CommandLineParser.ts

@@ -224,16 +224,17 @@ function getArgumentValue(
 }
 
 function readValue(value: string | boolean, type: CommandLineOption["type"]): string | boolean {
-    if (type === "boolean") {
-        return value === true || value === "true" || value === "t";
-    } else if (type === "enum") {
-        return value.toString().toLowerCase();
+    switch (type) {
+        case "boolean":
+            return value === true || value === "true" || value === "t";
+        case "enum":
+            return value.toString().toLowerCase();
     }
 }
 
 export function parseConfigFileWithSystem(
     configFileName: string,
-    commandLineOptions: CompilerOptions,
+    commandLineOptions?: CompilerOptions,
     system = ts.sys
 ): ParsedCommandLine {
     const { config, error } = ts.readConfigFile(configFileName, system.readFile);

src/Emit.ts

@@ -16,7 +16,8 @@ export function emitTranspiledFiles(
     options: CompilerOptions,
     transpiledFiles: Map<string, TranspiledFile>
 ): OutputFile[] {
-    const { rootDir, outDir, outFile, luaLibImport } = options;
+    // TODO:
+    const { rootDir = "", outDir = "", outFile, luaLibImport } = options;
 
     const files: OutputFile[] = [];
     for (const [fileName, { lua, sourceMap, declaration, declarationMap }] of transpiledFiles) {
@@ -32,7 +33,7 @@ export function emitTranspiledFiles(
                 outPath = outFile;
             } else {
                 // append to workingDir or outDir
-                outPath = path.resolve(options.outDir, outFile);
+                outPath = path.resolve(outDir, outFile);
             }
         } else {
             outPath = trimExt(outPath) + ".lua";

src/index.ts

@@ -43,7 +43,7 @@ const libCache: { [key: string]: ts.SourceFile } = {};
 /** @internal */
 export function createVirtualProgram(
     input: Record<string, string>,
-    options?: CompilerOptions
+    options: CompilerOptions = {}
 ): ts.Program {
     const compilerHost: ts.CompilerHost = {
         fileExists: () => true,
@@ -86,40 +86,29 @@ export function createVirtualProgram(
     return ts.createProgram(Object.keys(input), options, compilerHost);
 }
 
-export interface VirtualProgramResult {
-    file: TranspiledFile;
+export interface TranspileStringResult {
     diagnostics: ts.Diagnostic[];
+    file?: TranspiledFile;
 }
 
 export function transpileString(
-    content: string,
+    main: string,
     options: CompilerOptions = {}
-): VirtualProgramResult {
-    const program = createVirtualProgram({ "main.ts": content }, options);
-    const { diagnostics, transpiledFiles } = getTranspileOutput({ program, options });
-    const allDiagnostics = ts.sortAndDeduplicateDiagnostics([
-        ...ts.getPreEmitDiagnostics(program),
-        ...diagnostics,
-    ]);
-
-    return { file: transpiledFiles.get("main.ts"), diagnostics: [...allDiagnostics] };
+): TranspileStringResult {
+    const { diagnostics, transpiledFiles } = transpileVirtualProgram({ "main.ts": main }, options);
+    return { diagnostics, file: transpiledFiles.get("main.ts") };
 }
 
 export function transpileVirtualProgram(
     files: Record<string, string>,
     options: CompilerOptions = {}
-): VirtualProgramResult {
-    const mainFileName = Object.keys(files).find(x => /\bmain\.[a-z]+$/.test(x));
-    if (mainFileName === undefined) {
-        throw new Error('Virtual program should have a file named "main"');
-    }
-
+): TranspilationResult {
     const program = createVirtualProgram(files, options);
-    const { diagnostics, transpiledFiles } = getTranspileOutput({ program, options });
+    const transpileOutput = getTranspileOutput({ program, options });
     const allDiagnostics = ts.sortAndDeduplicateDiagnostics([
         ...ts.getPreEmitDiagnostics(program),
-        ...diagnostics,
+        ...transpileOutput.diagnostics,
     ]);
 
-    return { file: transpiledFiles.get(mainFileName), diagnostics: [...allDiagnostics] };
+    return { ...transpileOutput, diagnostics: [...allDiagnostics] };
 }

src/tstl.ts

@@ -283,7 +283,7 @@ function updateWatchCompilationHost(
         // do a full recompile after an error
         fullRecompile = errors.length > 0;
 
-        host.onWatchStatusChange(
+        host.onWatchStatusChange!(
             cliDiagnostics.watchErrorSummary(errors.length),
             host.getNewLine(),
             compilerOptions

test/compiler/runner.ts

@@ -21,8 +21,8 @@ export async function runCli(args: string[]): Promise<CliResult> {
     const child = forkCli(args);
 
     let output = "";
-    child.stdout.on("data", data => (output += data));
-    child.stderr.on("data", data => (output += data));
+    child.stdout!.on("data", data => (output += data));
+    child.stderr!.on("data", data => (output += data));
 
     return new Promise(resolve => {
         child.on("close", exitCode => resolve({ exitCode, output }));

test/unit/sourcemaps.spec.ts

@@ -47,15 +47,14 @@ test.each([
     },
 ])("Source map has correct mapping (%p)", async ({ typeScriptSource, assertPatterns }) => {
     // Act
-    const {
-        file: { lua, sourceMap },
-    } = util.transpileStringResult(typeScriptSource);
+    const { file } = util.transpileStringResult(typeScriptSource);
 
     // Assert
-    const consumer = await new SourceMapConsumer(sourceMap);
+    if (!util.expectToBeDefined(file.lua) || !util.expectToBeDefined(file.sourceMap)) return;
 
+    const consumer = await new SourceMapConsumer(file.sourceMap);
     for (const { luaPattern, typeScriptPattern } of assertPatterns) {
-        const luaPosition = lineAndColumnOf(lua, luaPattern);
+        const luaPosition = lineAndColumnOf(file.lua, luaPattern);
         const mappedPosition = consumer.originalPositionFor(luaPosition);
 
         const typescriptPosition = lineAndColumnOf(typeScriptSource, typeScriptPattern);
@@ -125,17 +124,18 @@ test("Inline sourcemaps", () => {
         inlineSourceMap: true,
     };
 
-    const { lua, sourceMap } = util.transpileStringResult(typeScriptSource, compilerOptions);
+    const { file } = util.transpileStringResult(typeScriptSource, compilerOptions);
+    if (!util.expectToBeDefined(file.lua)) return;
 
-    const inlineSourceMapMatch = lua.match(
+    const inlineSourceMapMatch = file.lua.match(
         /--# sourceMappingURL=data:application\/json;base64,([A-Za-z0-9+/=]+)/,
     );
 
     if (util.expectToBeDefined(inlineSourceMapMatch)) {
         const inlineSourceMap = Buffer.from(inlineSourceMapMatch[1], "base64").toString();
-        expect(sourceMap).toBe(inlineSourceMap);
+        expect(file.sourceMap).toBe(inlineSourceMap);
 
-        expect(util.executeLua(lua)).toBe("foo");
+        expect(util.executeLua(file.lua)).toBe("foo");
     }
 });
 

test/util.ts

@@ -31,8 +31,9 @@ expect.extend({
         }
 
         // TODO:
-        expect(executionError).toBeDefined();
-        expect(executionError.message).toContain(error.message);
+        if (expectToBeDefined(executionError)) {
+            expect(executionError.message).toContain(error.message);
+        }
 
         return { pass: true, message: () => "" };
     },
@@ -43,10 +44,8 @@ export function transpileString(
     options: tstl.CompilerOptions = {},
     ignoreDiagnostics = true,
 ): string {
-    const {
-        diagnostics,
-        file: { lua },
-    } = transpileStringResult(str, options);
+    const { diagnostics, file } = transpileStringResult(str, options);
+    if (!expectToBeDefined(file) || !expectToBeDefined(file.lua)) return "";
 
     const errors = diagnostics
         .filter(d => d.category === ts.DiagnosticCategory.Error)
@@ -56,13 +55,13 @@ export function transpileString(
         throw new Error(errors.map(d => d.messageText).join("\n"));
     }
 
-    return lua.trim();
+    return file.lua.trim();
 }
 
 export function transpileStringResult(
-    input: string | { [filename: string]: string },
+    input: string | Record<string, string>,
     options: tstl.CompilerOptions = {},
-): tstl.VirtualProgramResult {
+): Required<tstl.TranspileStringResult> {
     const optionsWithDefaults = {
         luaTarget: tstl.LuaTarget.Lua53,
         noHeader: true,
@@ -78,9 +77,17 @@ export function transpileStringResult(
         ...options,
     };
 
-    return typeof input === "string"
-        ? tstl.transpileString(input, optionsWithDefaults)
-        : tstl.transpileVirtualProgram(input, optionsWithDefaults);
+    const { diagnostics, transpiledFiles } = tstl.transpileVirtualProgram(
+        typeof input === "string" ? { "main.ts": input } : input,
+        optionsWithDefaults,
+    );
+
+    const mainFileName = [...transpiledFiles.keys()].find(x => /\bmain\.[a-z]+$/.test(x));
+    if (mainFileName === undefined) {
+        throw new Error('Program should have a file named "main"');
+    }
+
+    return { diagnostics, file: transpiledFiles.get(mainFileName)! };
 }
 
 const lualibContent = fs.readFileSync(