import * as path from "path";

import * as tstl from "../../src";

import * as util from "../util";

import * as ts from "typescript";

import { BuildMode } from "../../src";

import { normalizeSlashes } from "../../src/utils";

import { pathsWithoutBaseUrl } from "../../src/transpilation/diagnostics";

describe("basic module resolution", () => {

const projectPath = path.resolve(__dirname, "module-resolution", "project-with-node-modules");

const projectWithNodeModules = util

.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "main.ts"));

test("can resolve global dependencies with declarations", () => {

// Declarations in the node_modules directory

expect(projectWithNodeModules.getLuaExecutionResult().globalWithDeclarationsResults).toEqual({

foo: "foo from lua global with decls",

bar: "bar from lua global with decls: global with declarations!",

baz: "baz from lua global with decls",

});

});

test("can resolve global dependencies with hand-written declarations", () => {

// No declarations in the node_modules directory, but written by hand in project dir

expect(projectWithNodeModules.getLuaExecutionResult().globalWithoutDeclarationsResults).toEqual({

foo: "foo from lua global without decls",

bar: "bar from lua global without decls: global without declarations!",

baz: "baz from lua global without decls",

});

});

test("can resolve module dependencies with declarations", () => {

// Declarations in the node_modules directory

expect(projectWithNodeModules.getLuaExecutionResult().moduleWithDeclarationsResults).toEqual({

foo: "foo from lua module with decls",

bar: "bar from lua module with decls: module with declarations!",

baz: "baz from lua module with decls",

});

});

test("can resolve module dependencies with hand-written declarations", () => {

// Declarations in the node_modules directory

expect(projectWithNodeModules.getLuaExecutionResult().moduleWithoutDeclarationsResults).toEqual({

foo: "foo from lua module without decls",

bar: "bar from lua module without decls: module without declarations!",

baz: "baz from lua module without decls",

});

});

test("can resolve package depencency with a dependency on another package", () => {

// Declarations in the node_modules directory

expect(projectWithNodeModules.getLuaExecutionResult().moduleWithDependencyResult).toBe(

"Calling dependency: foo from lua module with decls"

);

});

test("resolved package dependency included in bundle", () => {

const mainFile = path.join(projectPath, "main.ts");

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(mainFile)

.setOptions({ luaBundle: "bundle.lua", luaBundleEntry: mainFile })

.expectToEqual({

globalWithDeclarationsResults: {

foo: "foo from lua global with decls",

bar: "bar from lua global with decls: global with declarations!",

baz: "baz from lua global with decls",

},

globalWithoutDeclarationsResults: {

foo: "foo from lua global without decls",

bar: "bar from lua global without decls: global without declarations!",

baz: "baz from lua global without decls",

},

moduleWithDeclarationsResults: {

foo: "foo from lua module with decls",

bar: "bar from lua module with decls: module with declarations!",

baz: "baz from lua module with decls",

},

moduleWithDependencyResult: "Calling dependency: foo from lua module with decls",

moduleWithoutDeclarationsResults: {

foo: "foo from lua module without decls",

bar: "bar from lua module without decls: module without declarations!",

baz: "baz from lua module without decls",

},

});

});

});

describe("module resolution with chained dependencies", () => {

const projectPath = path.resolve(__dirname, "module-resolution", "project-with-dependency-chain");

const expectedResult = { result: "dependency3", result2: "someFunc from otherfile.lua" };

test("can resolve dependencies in chain", () => {

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "main.ts"))

.expectToEqual(expectedResult);

});

test("resolved package dependency included in bundle", () => {

const mainFile = path.join(projectPath, "main.ts");

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(mainFile)

.setOptions({ luaBundle: "bundle.lua", luaBundleEntry: mainFile })

.expectToEqual(expectedResult);

});

test("works with different module setting", () => {

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "main.ts"))

.setOptions({ module: ts.ModuleKind.ESNext })

.expectToEqual(expectedResult);

});

});

describe("module resolution with outDir", () => {

const projectPath = path.resolve(__dirname, "module-resolution", "project-with-dependency-chain");

const expectedResult = { result: "dependency3", result2: "someFunc from otherfile.lua" };

test("emits files in outDir", () => {

const builder = util

.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "main.ts"))

.setOptions({ outDir: "tstl-out" })

.expectToEqual(expectedResult);

// Get the output paths relative to the project path

const outPaths = builder.getLuaResult().transpiledFiles.map(f => path.relative(projectPath, f.outPath));

expect(outPaths).toHaveLength(5);

expect(outPaths).toContain(path.join("tstl-out", "main.lua"));

// Note: outputs to lua_modules

expect(outPaths).toContain(path.join("tstl-out", "lua_modules", "dependency1", "index.lua"));

expect(outPaths).toContain(path.join("tstl-out", "lua_modules", "dependency1", "otherfile.lua"));

expect(outPaths).toContain(path.join("tstl-out", "lua_modules", "dependency2", "index.lua"));

expect(outPaths).toContain(path.join("tstl-out", "lua_modules", "dependency3", "index.lua"));

});

test("emits bundle in outDir", () => {

const mainFile = path.join(projectPath, "main.ts");

const builder = util

.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(mainFile)

.setOptions({ outDir: "tstl-out", luaBundle: "bundle.lua", luaBundleEntry: mainFile })

.expectToEqual(expectedResult);

// Get the output paths relative to the project path

const outPaths = builder.getLuaResult().transpiledFiles.map(f => path.relative(projectPath, f.outPath));

expect(outPaths).toHaveLength(1);

expect(outPaths).toContain(path.join("tstl-out", "bundle.lua"));

});

});

describe("module resolution with sourceDir", () => {

const projectPath = path.resolve(__dirname, "module-resolution", "project-with-sourceDir");

const expectedResult = {

result: "dependency3",

functionInSubDir: "non-node_modules import",

functionReExportedFromSubDir: "nested func result",

nestedFunctionInSubDirOfSubDir: "nested func result",

nestedFunctionUsingFunctionFromParentDir: "nested func: non-node_modules import 2",

};

test("can resolve dependencies with sourceDir", () => {

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "src", "main.ts"))

.setOptions({ outDir: "tstl-out" })

.expectToEqual(expectedResult);

});

test("can resolve dependencies and bundle files with sourceDir", () => {

const mainFile = path.join(projectPath, "src", "main.ts");

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(mainFile)

.setOptions({ luaBundle: "bundle.lua", luaBundleEntry: mainFile })

.expectToEqual(expectedResult);

});

// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1394

test("can resolve files with non-standard extension (#1394)", () => {

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "src", "main.ts"))

.setOptions({ outDir: "tstl-out", extension: ".script" })

.expectToEqual(expectedResult);

});

// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1394

test("can resolve files with non-standard extension without separator (#1394)", () => {

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "src", "main.ts"))

.setOptions({ outDir: "tstl-out", extension: "script" })

.expectToEqual(expectedResult);

});

});

describe("module resolution project with lua sources", () => {

const projectPath = path.resolve(__dirname, "module-resolution", "project-with-lua-sources");

const expectedResult = {

funcFromLuaFile: "lua file in subdir",

funcFromSubDirLuaFile: "lua file in subdir",

};

test("can resolve lua dependencies", () => {

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "main.ts"))

.setOptions({ outDir: "tstl-out" })

.expectToEqual(expectedResult);

});

test("can resolve dependencies and bundle files with sourceDir", () => {

const mainFile = path.join(projectPath, "main.ts");

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(mainFile)

.setOptions({ luaBundle: "bundle.lua", luaBundleEntry: mainFile })

.expectToEqual(expectedResult);

});

});

describe("module resolution in library mode", () => {

test("result does not contain resolved paths", () => {

const projectPath = path.resolve(__dirname, "module-resolution", "project-with-dependency-chain");

const { transpiledFiles } = util

.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "main.ts"))

.setOptions({ buildMode: tstl.BuildMode.Library })

.expectToHaveNoDiagnostics()

.getLuaResult();

for (const file of transpiledFiles) {

expect(file.lua).not.toContain('require("lua_modules');

}

});

test("project works in library mode because no external dependencies", () => {

const projectPath = path.resolve(__dirname, "module-resolution", "project-with-lua-sources");

const { transpiledFiles } = util

.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "main.ts"))

.setOptions({ outDir: "tstl-out", buildMode: tstl.BuildMode.Library })

.expectToEqual({

funcFromLuaFile: "lua file in subdir",

funcFromSubDirLuaFile: "lua file in subdir",

})

.getLuaResult();

for (const file of transpiledFiles) {

expect(file.lua).not.toContain('require("lua_modules');

}

});

});

describe("module resolution project with dependencies built by tstl library mode", () => {

const projectPath = path.resolve(__dirname, "module-resolution", "project-with-tstl-library-modules");

// First compile dependencies into node_modules. NOTE: Actually writing to disk, very slow

tstl.transpileProject(path.join(projectPath, "dependency1-ts", "tsconfig.json"));

tstl.transpileProject(path.join(projectPath, "dependency2-ts", "tsconfig.json"));

const expectedResult = {

dependency1IndexResult: "function in dependency 1 index: dependency1OtherFileFunc in dependency1/d1otherfile",

dependency1OtherFileFuncResult: "dependency1OtherFileFunc in dependency1/d1otherfile",

dependency2MainResult: "dependency 2 main",

dependency2OtherFileResult: "Dependency 2 func: my string argument",

};

test("can resolve lua dependencies", () => {

const transpileResult = util

.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "main.ts"))

.setOptions({ outDir: "tstl-out" })

.expectToEqual(expectedResult)

.getLuaResult();

// Assert node_modules file requires the correct lualib_bundle

const requiringLuaFile = path.join("lua_modules", "dependency1", "index.lua");

const lualibRequiringFile = transpileResult.transpiledFiles.find(f => f.outPath.endsWith(requiringLuaFile));

expect(lualibRequiringFile).toBeDefined();

expect(lualibRequiringFile?.lua).toContain('require("lualib_bundle")');

});

test("can resolve dependencies and bundle", () => {

const mainFile = path.join(projectPath, "main.ts");

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(mainFile)

.setOptions({ luaBundle: "bundle.lua", luaBundleEntry: mainFile })

.expectToEqual(expectedResult);

});

});

describe("module resolution project with dependencies built by tstl library mode and has exports field", () => {

const projectPath = path.resolve(__dirname, "module-resolution", "project-with-tstl-library-has-exports-field");

// First compile dependencies into node_modules. NOTE: Actually writing to disk, very slow

const dependency1Path = path.join(projectPath, "node_modules", "dependency1");

tstl.transpileProject(path.join(dependency1Path, "tsconfig.json"));

const expectedResult = {

dependency1IndexResult: "function in dependency 1 index: dependency1OtherFileFunc in dependency1/d1otherfile",

dependency1OtherFileFuncResult: "dependency1OtherFileFunc in dependency1/d1otherfile",

};

test("can resolve lua dependencies", () => {

const transpileResult = util

.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "main.ts"))

.setOptions({

outDir: "tstl-out",

moduleResolution: ts.ModuleResolutionKind.Node16,

module: ts.ModuleKind.Node16,

})

.expectToEqual(expectedResult)

.getLuaResult();

// Assert node_modules file requires the correct lualib_bundle

const requiringLuaFile = path.join("lua_modules", "dependency1", "dist", "index.lua");

const lualibRequiringFile = transpileResult.transpiledFiles.find(f => f.outPath.endsWith(requiringLuaFile));

expect(lualibRequiringFile).toBeDefined();

expect(lualibRequiringFile?.lua).toContain('require("lualib_bundle")');

});

test("can resolve dependencies and bundle", () => {

const mainFile = path.join(projectPath, "main.ts");

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(mainFile)

.setOptions({

luaBundle: "bundle.lua",

luaBundleEntry: mainFile,

moduleResolution: ts.ModuleResolutionKind.Node16,

module: ts.ModuleKind.Node16,

})

.expectToEqual(expectedResult);

});

});

// Test fix for https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1037

describe("module resolution with tsx", () => {

const projectPath = path.resolve(__dirname, "module-resolution", "project-with-tsx");

test("project with tsx files", () => {

util.testProject(path.join(projectPath, "tsconfig.json"))

.setMainFileName(path.join(projectPath, "main.tsx"))

.expectToEqual({

result: "hello from other.tsx",

indexResult: "hello from dir/index.tsx",

});

});

});

describe("dependency with complicated inner structure", () => {

const projectPath = path.resolve(__dirname, "module-resolution", "project-with-complicated-dependency");

const tsConfigPath = path.join(projectPath, "tsconfig.json");

const mainFilePath = path.join(projectPath, "main.ts");

const expectedResult = {

otherFileResult: "someFunc from otherfile.lua",

otherFileUtil: "util",

subsubresult: "result from subsub dir",

utilResult: "util",

subdirwithInitResult: "a",

};

// Test fix for https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1055

test("bundle should not contain duplicate files", () => {

const mainFile = path.join(projectPath, "main.ts");

const { transpiledFiles } = util

.testProject(tsConfigPath)

.setMainFileName(mainFilePath)

.setOptions({ luaBundle: "bundle.lua", luaBundleEntry: mainFile })

.expectToEqual(expectedResult)

.getLuaResult();

expect(transpiledFiles).toHaveLength(1);

const lua = transpiledFiles[0].lua!;

// util is used in 2 places, but should only occur once in the bundle

const utilModuleOccurrences = (lua.match(/\["lua_modules\.dependency1\.util"\]/g) ?? []).length;

expect(utilModuleOccurrences).toBe(1);

});

// Test fix for https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1054

test("should be able to resolve dependency files in subdirectories", () => {

util.testProject(tsConfigPath).setMainFileName(mainFilePath).expectToEqual(expectedResult);

});

});

test("module resolution should not try to resolve @noResolution annotation", () => {

util.testModule`

import * as json from "json";

const test = json.decode("{}");

`

.addExtraFile(

"json.d.ts",

`

/** @noResolution */

declare module "json" {

function encode(this: void, data: unknown): string;

function decode(this: void, data: string): unknown;

}

`

)

.expectToHaveNoDiagnostics();

});

// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1101

test("module resolution inline require of environment library workaround", () => {

util.testModule`

declare function require(this: void, module: string): any;

const test = require("@NoResolution:luasource");

test.foo();

`.expectToHaveNoDiagnostics();

});

// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1118

describe("module resolution should not try to resolve modules in noResolvePaths", () => {

test("as used in direct import", () => {

util.testModule`

import * as lua from "directimport";

lua.foo();

`

.addExtraFile(

"directimport.d.ts",

`declare module "directimport" {

export function foo(): void;

}`

)

.setOptions({ noResolvePaths: ["directimport"] })

.expectToHaveNoDiagnostics();

});

test("as used in imported lua sources", () => {

util.testModule`

import * as lua from "./luasource";

lua.foo();

`

.addExtraFile("luasource.d.ts", "export function foo(): void;")

.addExtraFile(

"luasource.lua",

`

require("dontResolveThis")

require("a.b.c.foo")

return { foo = function() return "bar" end }

`

)

.setOptions({ noResolvePaths: ["a.b.c.foo", "somethingExtra", "dontResolveThis"] })

.expectToHaveNoDiagnostics();

});

test("can ignore specific files with glob pattern", () => {

util.testModule`

// Pre-Load as to not error out at runtime

import "preload";

import "ignoreme";

import * as b from "./actualfile";

export const result = b.foo();

`

.addExtraFile("preload.lua", 'package.preload["ignoreme"] = function() return nil end')

.addExtraFile(

"actualfile.ts",

`export function foo()

{

return 'foo';

}`

)

.addExtraFile(

"ignoreme.d.ts",

`declare module "ignoreme" {

export function foo(): void;

}`

)

.setOptions({ noResolvePaths: ["ignore*"] })

.expectToHaveNoDiagnostics()

.expectToEqual({ result: "foo" });

});

test("can ignore all files with glob pattern in require", () => {

util.testModule`

declare function require(this: void, module: string): any;

const a = require("a")

const b = require("b/b")

const c = require("c/c/c")

const d = require("!:?somefile")

`

.setOptions({ noResolvePaths: ["**"] })

.expectToHaveNoDiagnostics();

});

test("can ignore all files with glob pattern as used in imported lua sources", () => {

util.testModule`

import * as lua from "./luasource";

lua.foo();

`

.addExtraFile("luasource.d.ts", "export function foo(): void;")

.addExtraFile(

"luasource.lua",

`

require("ignoreme!")

require("i.g.n.o.r.e")

`

)

.setOptions({ noResolvePaths: ["**"] })

.expectToHaveNoDiagnostics();

});

});

// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1062

test("module resolution should not rewrite @NoResolution requires in library mode", () => {

const { transpiledFiles } = util.testModule`

import * as json from "json";

const test = json.decode("{}");

`

.addExtraFile(

"json.d.ts",

`

/** @noResolution */

declare module "json" {

function encode(this: void, data: unknown): string;

function decode(this: void, data: string): unknown;

}

`

)

.setOptions({ buildMode: BuildMode.Library })

.getLuaResult();

expect(transpiledFiles).toHaveLength(1);

expect(transpiledFiles[0].lua).toContain('require("@NoResolution:');

});

// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1050

test("module resolution should not try to resolve require-like functions", () => {

util.testModule`

function custom_require(this: void, value: string) {

return value;

}

namespace ns {

export function require(this: void, value: string) {

return value;

}

}

class MyClass {

require(value: string) {

return value;

}

}

const inst = new MyClass();

export const result = [

custom_require("value 1"),

ns.require("value 2"),

inst.require("value 3")

];

`

.expectToHaveNoDiagnostics()

.expectToEqual({

result: ["value 1", "value 2", "value 3"],

});

});

// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1050

test("module resolution uses baseURL to resolve imported files", () => {

util.testModule`

import { foo } from "dep1";

import { bar } from "dep2";

import { baz } from "luadep";

export const fooResult = foo();

export const barResult = bar();

export const bazResult = baz();

`

.addExtraFile(

"myproject/mydeps/dep1.ts",

`

export function foo() { return "foo"; }

`

)

.addExtraFile(

"myproject/mydeps/dep2.ts",

`

export function bar() { return "bar"; }

`

)

.addExtraFile(

"myproject/mydeps/luadep.d.ts",

`

export function baz(): string;

`

)

.addExtraFile(

"myproject/mydeps/luadep.lua",

`

return { baz = function() return "baz" end }

`

)

.setOptions({ baseUrl: "./myproject/mydeps" })

.expectToEqual({

fooResult: "foo",

barResult: "bar",

bazResult: "baz",

});

});

// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1071

test("includes lualib_bundle when external lua requests it", () => {

util.testModule`

export { foo } from "./lualibuser";

`

.addExtraFile(

"lualibuser.d.ts",

`

export const foo: string[];

`

)

.addExtraFile(

"lualibuser.lua",

`

local ____lualib = require("lualib_bundle")

local __TS__ArrayPush = ____lualib.__TS__ArrayPush

local result = {}

__TS__ArrayPush(result, "foo")

__TS__ArrayPush(result, "bar")

return { foo = result }

`

)

.expectToEqual({

foo: ["foo", "bar"],

});

});

// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1146

test("require matches correct pattern", () => {

util.testModule`

declare function require(this: void, module: string): any;

export const addResult = require("a").foo + require("b").foo;

export const callResult = require("c")("foo");

`

.addExtraFile("a.lua", "return { foo = 3 }")

.addExtraFile("b.lua", "return { foo = 5 }")

.addExtraFile("c.lua", "return function(self, a) return a end")

.expectToEqual({ addResult: 3 + 5, callResult: "foo" });

});

// https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1307

test("lualib_module with parent directory import (#1307)", () => {

const projectDir = path.join(__dirname, "module-resolution", "project-with-dependency-with-same-file-names");

const inputProject = path.join(projectDir, "tsconfig.json");

util.testProject(inputProject).setMainFileName(path.join(projectDir, "index.ts")).expectToEqual({

// eslint-disable-next-line @typescript-eslint/naming-convention

BASE_CONSTANT: 123,

// eslint-disable-next-line @typescript-eslint/naming-convention

FEATURE_CONSTANT: 456,

});

});

test("supports paths configuration", () => {

// Package root

const baseProjectPath = path.resolve(__dirname, "module-resolution", "paths-simple");

// myprogram package

const projectPath = path.join(baseProjectPath, "myprogram");

const projectTsConfig = path.join(projectPath, "tsconfig.json");

const mainFile = path.join(projectPath, "main.ts");

const luaResult = util

.testProject(projectTsConfig)

.setMainFileName(mainFile)

.expectToHaveNoDiagnostics()

.getLuaResult();

expect(snapshotPaths(luaResult.transpiledFiles)).toMatchSnapshot();

// Bundle to have all files required to execute and check result

util.testProject(projectTsConfig)

.setMainFileName(mainFile)

.setOptions({ luaBundle: "bundle.lua", luaBundleEntry: mainFile })

.expectToEqual({ foo: 314, bar: 271 });

});

test("supports complicated paths configuration", () => {

// Package root

const baseProjectPath = path.resolve(__dirname, "module-resolution", "paths-base-tsconfig");

// myprogram package

const projectPath = path.join(baseProjectPath, "packages", "myprogram");

const projectTsConfig = path.join(projectPath, "tsconfig.json");

const mainFile = path.join(projectPath, "src", "main.ts");

const luaResult = util

.testProject(projectTsConfig)

.setMainFileName(mainFile)

.expectToHaveNoDiagnostics()

.getLuaResult();

expect(snapshotPaths(luaResult.transpiledFiles)).toMatchSnapshot();

// Bundle to have all files required to execute

util.testProject(projectTsConfig)

.setMainFileName(mainFile)

.setOptions({ luaBundle: "bundle.lua", luaBundleEntry: mainFile })

.expectToEqual({ foo: 314, bar: 271 });

});

test("paths without baseUrl is error", () => {

util.testFunction``.setOptions({ paths: {} }).expectToHaveDiagnostics([pathsWithoutBaseUrl.code]);

});

test("module resolution using plugin", () => {

const baseProjectPath = path.resolve(__dirname, "module-resolution", "project-with-module-resolution-plugin");

const projectTsConfig = path.join(baseProjectPath, "tsconfig.json");

const mainFile = path.join(baseProjectPath, "main.ts");

const testBuilder = util

.testProject(projectTsConfig)

.setMainFileName(mainFile)

.setOptions({

luaPlugins: [

{

name: path.join(__dirname, "./plugins/moduleResolution.ts"),

},

],

})

.expectToHaveNoDiagnostics();

const luaResult = testBuilder.getLuaResult();

expect(luaResult.transpiledFiles).toHaveLength(3);

testBuilder.expectToEqual({ result: ["foo", "absolutefoo"] });

});

function snapshotPaths(files: tstl.TranspiledFile[]) {

return files.map(f => normalizeSlashes(f.outPath).split("module-resolution")[1]).sort();

}