initial commit of actions

github/codeql-action-v1/node_modules/tsconfig-paths/test/config-loader-tests.ts

@@ -0,0 +1,90 @@
+import { assert } from "chai";
+import {
+  configLoader,
+  loadConfig,
+  ConfigLoaderFailResult,
+  ConfigLoaderSuccessResult
+} from "../src/config-loader";
+import { join } from "path";
+
+describe("config-loader", (): void => {
+  it("should use explicitParams when set", () => {
+    const result = configLoader({
+      explicitParams: {
+        baseUrl: "/foo/bar",
+        paths: {
+          asd: ["asd"]
+        }
+      },
+      cwd: "/baz"
+    });
+
+    const successResult = result as ConfigLoaderSuccessResult;
+    assert.equal(successResult.resultType, "success");
+    assert.equal(successResult.absoluteBaseUrl, "/foo/bar");
+    assert.equal(successResult.paths["asd"][0], "asd");
+  });
+
+  it("should use explicitParams when set and add cwd when path is relative", () => {
+    const result = configLoader({
+      explicitParams: {
+        baseUrl: "bar/",
+        paths: {
+          asd: ["asd"]
+        }
+      },
+      cwd: "/baz"
+    });
+
+    const successResult = result as ConfigLoaderSuccessResult;
+    assert.equal(successResult.resultType, "success");
+    assert.equal(successResult.absoluteBaseUrl, join("/baz", "bar/"));
+  });
+
+  it("should fallback to tsConfigLoader when explicitParams is not set", () => {
+    const result = configLoader({
+      explicitParams: undefined,
+      cwd: "/baz",
+      // tslint:disable-next-line:no-any
+      tsConfigLoader: (_: any) => ({
+        tsConfigPath: "/baz/tsconfig.json",
+        baseUrl: "./src",
+        paths: {}
+      })
+    });
+
+    const successResult = result as ConfigLoaderSuccessResult;
+    assert.equal(successResult.resultType, "success");
+    assert.equal(successResult.absoluteBaseUrl, join("/baz", "src"));
+  });
+
+  it("should show an error message when baseUrl is missing", () => {
+    const result = configLoader({
+      explicitParams: undefined,
+      cwd: "/baz",
+      // tslint:disable-next-line:no-any
+      tsConfigLoader: (_: any) => ({
+        tsConfigPath: "/baz/tsconfig.json",
+        baseUrl: undefined,
+        paths: {}
+      })
+    });
+
+    const failResult = result as ConfigLoaderFailResult;
+    assert.equal(failResult.resultType, "failed");
+    assert.isTrue(failResult.message.indexOf("baseUrl") > -1);
+  });
+
+  it("should presume cwd to be a tsconfig file when loadConfig is called with absolute path to tsconfig.json", () => {
+    // using tsconfig-named.json to ensure that future changes to fix
+    // https://github.com/dividab/tsconfig-paths/issues/31
+    // do not pass this test case just because of a directory walk looking
+    // for tsconfig.json
+    const configFile = join(__dirname, "tsconfig-named.json");
+    const result = loadConfig(configFile);
+
+    const successResult = result as ConfigLoaderSuccessResult;
+    assert.equal(successResult.resultType, "success");
+    assert.equal(successResult.configFileAbsolutePath, configFile);
+  });
+});

github/codeql-action-v1/node_modules/tsconfig-paths/test/data/match-path-data.ts

@@ -0,0 +1,212 @@
+import { join, dirname } from "path";
+import { removeExtension } from "../../src/filesystem";
+
+export interface OneTest {
+  readonly name: string;
+  readonly only?: boolean;
+  readonly skip?: boolean;
+  readonly absoluteBaseUrl: string;
+  readonly paths: { [key: string]: Array<string> };
+  readonly mainFields?: string[];
+  readonly addMatchAll?: boolean;
+  readonly existingFiles: ReadonlyArray<string>;
+  readonly requestedModule: string;
+  readonly extensions?: ReadonlyArray<string>;
+  readonly packageJson?: {};
+  readonly expectedPath: string | undefined;
+}
+
+export const tests: ReadonlyArray<OneTest> = [
+  {
+    name: "should locate path that matches with star and exists",
+    absoluteBaseUrl: "/root/",
+    paths: {
+      "lib/*": ["location/*"]
+    },
+    existingFiles: [join("/root", "location", "mylib", "index.ts")],
+    requestedModule: "lib/mylib",
+    expectedPath: dirname(join("/root", "location", "mylib", "index.ts"))
+  },
+  {
+    name: "should resolve to correct path when many are specified",
+    absoluteBaseUrl: "/root/",
+    paths: {
+      "lib/*": ["foo1/*", "foo2/*", "location/*", "foo3/*"]
+    },
+    existingFiles: [join("/root", "location", "mylib", "index.ts")],
+    requestedModule: "lib/mylib",
+    extensions: [".ts"],
+    expectedPath: dirname(join("/root", "location", "mylib", "index.ts"))
+  },
+  {
+    name:
+      "should locate path that matches with star and prioritize pattern with longest prefix",
+    absoluteBaseUrl: "/root/",
+    paths: {
+      "*": ["location/*"],
+      "lib/*": ["location/*"]
+    },
+    existingFiles: [
+      join("/root", "location", "lib", "mylib", "index.ts"),
+      join("/root", "location", "mylib", "index.ts")
+    ],
+    requestedModule: "lib/mylib",
+    expectedPath: dirname(join("/root", "location", "mylib", "index.ts"))
+  },
+  {
+    name: "should locate path that matches with star and exists with extension",
+    absoluteBaseUrl: "/root/",
+    paths: { "lib/*": ["location/*"] },
+    existingFiles: [join("/root", "location", "mylib.myext")],
+    requestedModule: "lib/mylib",
+    extensions: [".js", ".myext"],
+    expectedPath: removeExtension(join("/root", "location", "mylib.myext"))
+  },
+  {
+    name: "should resolve request with extension specified",
+    absoluteBaseUrl: "/root/",
+    paths: { "lib/*": ["location/*"] },
+    existingFiles: [join("/root", "location", "test.jpg")],
+    requestedModule: "lib/test.jpg",
+    expectedPath: join("/root", "location", "test.jpg")
+  },
+  {
+    name: "should locate path that matches without star and exists",
+    absoluteBaseUrl: "/root/",
+    paths: {
+      "lib/foo": ["location/foo"]
+    },
+    existingFiles: [join("/root", "location", "foo.ts")],
+    requestedModule: "lib/foo",
+    expectedPath: removeExtension(join("/root", "location", "foo.ts"))
+  },
+  {
+    name: "should resolve to parent folder when filename is in subfolder",
+    absoluteBaseUrl: "/root/",
+    paths: { "lib/*": ["location/*"] },
+    existingFiles: [join("/root", "location", "mylib", "index.ts")],
+    requestedModule: "lib/mylib",
+    expectedPath: dirname(join("/root", "location", "mylib", "index.ts"))
+  },
+  {
+    name: "should resolve from main field in package.json",
+    absoluteBaseUrl: "/root/",
+    paths: { "lib/*": ["location/*"] },
+    existingFiles: [join("/root", "location", "mylib", "kalle.ts")],
+    packageJson: { main: "./kalle.ts" },
+    requestedModule: "lib/mylib",
+    expectedPath: removeExtension(
+      join("/root", "location", "mylib", "kalle.ts")
+    )
+  },
+  {
+    name: "should resolve from main field in package.json (js)",
+    absoluteBaseUrl: "/root",
+    paths: { "lib/*": ["location/*"] },
+    existingFiles: [join("/root", "location", "mylib.js", "kalle.js")],
+    packageJson: { main: "./kalle.js" },
+    requestedModule: "lib/mylib.js",
+    extensions: [".ts", ".js"],
+    expectedPath: removeExtension(
+      join("/root", "location", "mylib.js", "kalle.js")
+    )
+  },
+  {
+    name:
+      "should resolve from main field in package.json and correctly remove file extension",
+    absoluteBaseUrl: "/root/",
+    paths: { "lib/*": ["location/*"] },
+    existingFiles: [join("/root", "location", "mylibjs", "kalle.js")],
+    packageJson: { main: "./kalle.js" },
+    extensions: [".ts", ".js"],
+    requestedModule: "lib/mylibjs",
+    expectedPath: removeExtension(
+      join("/root", "location", "mylibjs", "kalle.js")
+    )
+  },
+  {
+    name: "should resolve from list of fields by priority in package.json",
+    absoluteBaseUrl: "/root/",
+    paths: { "lib/*": ["location/*"] },
+    mainFields: ["missing", "browser", "main"],
+    packageJson: { main: "./main.js", browser: "./browser.js" },
+    existingFiles: [
+      join("/root", "location", "mylibjs", "main.js"), // mainFilePath
+      join("/root", "location", "mylibjs", "browser.js") // browserFilePath
+    ],
+    extensions: [".ts", ".js"],
+    requestedModule: "lib/mylibjs",
+    expectedPath: removeExtension(
+      join("/root", "location", "mylibjs", "browser.js")
+    )
+  },
+  {
+    name: "should ignore field mappings to missing files in package.json",
+    absoluteBaseUrl: "/root/",
+    paths: { "lib/*": ["location/*"] },
+    mainFields: ["browser", "main"],
+    existingFiles: [join("/root", "location", "mylibjs", "kalle.js")],
+    requestedModule: "lib/mylibjs",
+    packageJson: {
+      main: "./kalle.js",
+      browser: "./nope.js"
+    },
+    extensions: [".ts", ".js"],
+    expectedPath: removeExtension(
+      join("/root", "location", "mylibjs", "kalle.js")
+    )
+  },
+  {
+    name: "should ignore advanced field mappings in package.json",
+    absoluteBaseUrl: "/root/",
+    paths: { "lib/*": ["location/*"] },
+    existingFiles: [
+      join("/root", "location", "mylibjs", "kalle.js"),
+      join("/root", "location", "mylibjs", "browser.js")
+    ],
+    requestedModule: "lib/mylibjs",
+    packageJson: {
+      main: "./kalle.js",
+      browser: { mylibjs: "./browser.js", "./kalle.js": "./browser.js" }
+    },
+    extensions: [".ts", ".js"],
+    expectedPath: removeExtension(
+      join("/root", "location", "mylibjs", "kalle.js")
+    )
+  },
+  {
+    name: "should resolve to with the help of baseUrl when not explicitly set",
+    absoluteBaseUrl: "/root/",
+    paths: {},
+    existingFiles: [join("/root", "mylib", "index.ts")],
+    requestedModule: "mylib",
+    expectedPath: dirname(join("/root", "mylib", "index.ts"))
+  },
+  {
+    name: "should not resolve with the help of baseUrl when asked not to",
+    absoluteBaseUrl: "/root/",
+    paths: {},
+    addMatchAll: false,
+    existingFiles: [join("/root", "mylib", "index.ts")],
+    requestedModule: "mylib",
+    expectedPath: undefined
+  },
+  {
+    name: "should not locate path that does not match",
+    absoluteBaseUrl: "/root/",
+    paths: { "lib/*": ["location/*"] },
+    existingFiles: [join("root", "location", "mylib")],
+    requestedModule: "mylib",
+    expectedPath: undefined
+  },
+  {
+    name: "should not resolve typings file (index.d.ts)",
+    absoluteBaseUrl: "/root/",
+    paths: {
+      "lib/*": ["location/*"]
+    },
+    existingFiles: [join("/root", "location", "mylib", "index.d.ts")],
+    requestedModule: "lib/mylib",
+    expectedPath: undefined
+  }
+];

github/codeql-action-v1/node_modules/tsconfig-paths/test/filesystem-tests.ts

@@ -0,0 +1,46 @@
+import { assert } from "chai";
+import * as Filesystem from "../src/filesystem";
+import * as path from "path";
+
+describe("filesystem", () => {
+  const fileThatExists = path.join(__dirname, "../package.json");
+  const fileThatNotExists = path.join(__dirname, "../package2.json");
+
+  it("should find file that exists, sync", () => {
+    const result = Filesystem.fileExistsSync(fileThatExists);
+    assert.equal(result, true);
+  });
+
+  it("should not find file that not exists, sync", () => {
+    const result = Filesystem.fileExistsSync(fileThatNotExists);
+    assert.equal(result, false);
+  });
+
+  it("should find file that exists, async", done => {
+    Filesystem.fileExistsAsync(fileThatExists, (_err, result) => {
+      assert.equal(result, true);
+      done();
+    });
+  });
+
+  it("should not find file that not exists, async", done => {
+    Filesystem.fileExistsAsync(fileThatNotExists, (_err, result) => {
+      assert.equal(result, false);
+      done();
+    });
+  });
+
+  it("should load json, sync", () => {
+    const result = Filesystem.readJsonFromDiskSync(fileThatExists);
+    assert.isOk(result);
+    assert.equal(result.main, "lib/index.js");
+  });
+
+  it("should load json, async", done => {
+    Filesystem.readJsonFromDiskAsync(fileThatExists, (_err, result) => {
+      assert.isOk(result);
+      assert.equal(result.main, "lib/index.js");
+      done();
+    });
+  });
+});

github/codeql-action-v1/node_modules/tsconfig-paths/test/mapping-entry-test.ts

@@ -0,0 +1,47 @@
+import { assert } from "chai";
+import { getAbsoluteMappingEntries } from "../src/mapping-entry";
+import { join } from "path";
+
+describe("mapping-entry", () => {
+  it("should change to absolute paths and sort in longest prefix order", () => {
+    const result = getAbsoluteMappingEntries(
+      "/absolute/base/url",
+      {
+        "*": ["/foo1", "/foo2"],
+        "longest/pre/fix/*": ["/foo2/bar"],
+        "pre/fix/*": ["/foo3"]
+      },
+      true
+    );
+    assert.deepEqual(result, [
+      {
+        pattern: "longest/pre/fix/*",
+        paths: [join("/absolute", "base", "url", "foo2", "bar")]
+      },
+      {
+        pattern: "pre/fix/*",
+        paths: [join("/absolute", "base", "url", "foo3")]
+      },
+      {
+        pattern: "*",
+        paths: [
+          join("/absolute", "base", "url", "foo1"),
+          join("/absolute", "base", "url", "foo2")
+        ]
+      }
+    ]);
+  });
+
+  it("should should add a match-all pattern when requested", () => {
+    let result = getAbsoluteMappingEntries("/absolute/base/url", {}, true);
+    assert.deepEqual(result, [
+      {
+        pattern: "*",
+        paths: [join("/absolute", "base", "url", "*")]
+      }
+    ]);
+
+    result = getAbsoluteMappingEntries("/absolute/base/url", {}, false);
+    assert.deepEqual(result, []);
+  });
+});

github/codeql-action-v1/node_modules/tsconfig-paths/test/match-path-async-tests.ts

@@ -0,0 +1,27 @@
+import { assert } from "chai";
+import { createMatchPathAsync } from "../src/match-path-async";
+import * as Tests from "./data/match-path-data";
+
+describe("match-path-async", () => {
+  Tests.tests.forEach(t =>
+    it(t.name, done => {
+      const matchPath = createMatchPathAsync(
+        t.absoluteBaseUrl,
+        t.paths,
+        t.mainFields,
+        t.addMatchAll
+      );
+      matchPath(
+        t.requestedModule,
+        (_path, callback) => callback(undefined, t.packageJson),
+        (path, callback) =>
+          callback(undefined, t.existingFiles.indexOf(path) !== -1),
+        t.extensions,
+        (_err, result) => {
+          assert.equal(result, t.expectedPath);
+          done();
+        }
+      );
+    })
+  );
+});

github/codeql-action-v1/node_modules/tsconfig-paths/test/match-path-sync-tests.ts

@@ -0,0 +1,23 @@
+import { assert } from "chai";
+import { createMatchPath } from "../src/match-path-sync";
+import * as Tests from "./data/match-path-data";
+
+describe("match-path-sync", () => {
+  Tests.tests.forEach(t =>
+    it(t.name, () => {
+      const matchPath = createMatchPath(
+        t.absoluteBaseUrl,
+        t.paths,
+        t.mainFields,
+        t.addMatchAll
+      );
+      const result = matchPath(
+        t.requestedModule,
+        (_: string) => t.packageJson,
+        (name: string) => t.existingFiles.indexOf(name) !== -1, // fileExists
+        t.extensions
+      );
+      assert.equal(result, t.expectedPath);
+    })
+  );
+});

github/codeql-action-v1/node_modules/tsconfig-paths/test/mocha.opts

@@ -0,0 +1,3 @@
+--require ts-node/register
+--recursive test/
+test/**/*.ts

github/codeql-action-v1/node_modules/tsconfig-paths/test/try-path-tests.ts

@@ -0,0 +1,99 @@
+import { assert } from "chai";
+import { getPathsToTry } from "../src/try-path";
+import { join } from "path";
+
+describe("mapping-entry", () => {
+  const abosolutePathMappings = [
+    {
+      pattern: "longest/pre/fix/*",
+      paths: [join("/absolute", "base", "url", "foo2", "bar")]
+    },
+    { pattern: "pre/fix/*", paths: [join("/absolute", "base", "url", "foo3")] },
+    { pattern: "*", paths: [join("/absolute", "base", "url", "foo1")] }
+  ];
+  it("should return no paths for relative requested module", () => {
+    const result = getPathsToTry(
+      [".ts", "tsx"],
+      abosolutePathMappings,
+      "./requested-module"
+    );
+    assert.deepEqual(result, undefined);
+  });
+
+  it("should return no paths if no pattern match the requested module", () => {
+    const result = getPathsToTry(
+      [".ts", "tsx"],
+      [
+        {
+          pattern: "longest/pre/fix/*",
+          paths: [join("/absolute", "base", "url", "foo2", "bar")]
+        },
+        {
+          pattern: "pre/fix/*",
+          paths: [join("/absolute", "base", "url", "foo3")]
+        }
+      ],
+      "requested-module"
+    );
+    assert.deepEqual(result, undefined);
+  });
+
+  it("should get all paths that matches requested module", () => {
+    const result = getPathsToTry(
+      [".ts", ".tsx"],
+      abosolutePathMappings,
+      "longest/pre/fix/requested-module"
+    );
+    assert.deepEqual(result, [
+      // "longest/pre/fix/*"
+      { type: "file", path: join("/absolute", "base", "url", "foo2", "bar") },
+      {
+        type: "extension",
+        path: join("/absolute", "base", "url", "foo2", "bar.ts")
+      },
+      {
+        type: "extension",
+        path: join("/absolute", "base", "url", "foo2", "bar.tsx")
+      },
+      {
+        type: "package",
+        path: join("/absolute", "base", "url", "foo2", "bar", "package.json")
+      },
+      {
+        type: "index",
+        path: join("/absolute", "base", "url", "foo2", "bar", "index.ts")
+      },
+      {
+        type: "index",
+        path: join("/absolute", "base", "url", "foo2", "bar", "index.tsx")
+      },
+      // "*"
+      { type: "file", path: join("/absolute", "base", "url", "foo1") },
+      { type: "extension", path: join("/absolute", "base", "url", "foo1.ts") },
+      { type: "extension", path: join("/absolute", "base", "url", "foo1.tsx") },
+      {
+        type: "package",
+        path: join("/absolute", "base", "url", "foo1", "package.json")
+      },
+      {
+        type: "index",
+        path: join("/absolute", "base", "url", "foo1", "index.ts")
+      },
+      {
+        type: "index",
+        path: join("/absolute", "base", "url", "foo1", "index.tsx")
+      }
+    ]);
+  });
+});
+
+// describe("match-star", () => {
+//   it("should match star in last position", () => {
+//     const result = matchStar("lib/*", "lib/mylib");
+//     assert.equal(result, "mylib");
+//   });
+//   it("should match star in first position", () => {
+//     const result = matchStar("*/lib", "mylib/lib");
+//     assert.equal(result, "mylib");
+//   });
+// });

github/codeql-action-v1/node_modules/tsconfig-paths/test/tsconfig-loader-tests.ts

@@ -0,0 +1,203 @@
+import { assert } from "chai";
+import {
+  loadTsconfig,
+  tsConfigLoader,
+  walkForTsConfig
+} from "../src/tsconfig-loader";
+import { join } from "path";
+
+describe("tsconfig-loader", () => {
+  it("should find tsconfig in cwd", () => {
+    const result = tsConfigLoader({
+      cwd: "/foo/bar",
+      getEnv: (_: string) => undefined,
+      loadSync: (cwd: string) => {
+        return {
+          tsConfigPath: `${cwd}/tsconfig.json`,
+          baseUrl: "./",
+          paths: {}
+        };
+      }
+    });
+
+    assert.equal(result.tsConfigPath, "/foo/bar/tsconfig.json");
+  });
+
+  it("should return loaderResult.tsConfigPath as undefined when not found", () => {
+    const result = tsConfigLoader({
+      cwd: "/foo/bar",
+      getEnv: (_: string) => undefined,
+      loadSync: (_: string) => {
+        return {
+          tsConfigPath: undefined,
+          baseUrl: "./",
+          paths: {}
+        };
+      }
+    });
+
+    assert.isUndefined(result.tsConfigPath);
+  });
+
+  it("should use TS_NODE_PROJECT env if exists", () => {
+    const result = tsConfigLoader({
+      cwd: "/foo/bar",
+      getEnv: (key: string) =>
+        key === "TS_NODE_PROJECT" ? "/foo/baz" : undefined,
+      loadSync: (cwd: string, fileName: string) => {
+        if (cwd === "/foo/bar" && fileName === "/foo/baz") {
+          return {
+            tsConfigPath: "/foo/baz/tsconfig.json",
+            baseUrl: "./",
+            paths: {}
+          };
+        }
+
+        return {
+          tsConfigPath: undefined,
+          baseUrl: "./",
+          paths: {}
+        };
+      }
+    });
+
+    assert.equal(result.tsConfigPath, "/foo/baz/tsconfig.json");
+  });
+});
+
+describe("walkForTsConfig", () => {
+  it("should find tsconfig in starting directory", () => {
+    const pathToTsconfig = join("/root", "dir1", "tsconfig.json");
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      path => path === pathToTsconfig
+    );
+    assert.equal(res, pathToTsconfig);
+  });
+
+  it("should find tsconfig in parent directory", () => {
+    const pathToTsconfig = join("/root", "tsconfig.json");
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      path => path === pathToTsconfig
+    );
+    assert.equal(res, pathToTsconfig);
+  });
+
+  it("should return undefined when reaching the top", () => {
+    const res = walkForTsConfig(join("/root", "dir1", "kalle"), () => false);
+    assert.equal(res, undefined);
+  });
+});
+
+describe("loadConfig", () => {
+  it("It should load a config", () => {
+    const config = { compilerOptions: { baseUrl: "hej" } };
+    const res = loadTsconfig(
+      "/root/dir1/tsconfig.json",
+      path => path === "/root/dir1/tsconfig.json",
+      _ => JSON.stringify(config)
+    );
+    assert.deepEqual(res, config);
+  });
+
+  it("It should load a config with comments", () => {
+    const config = { compilerOptions: { baseUrl: "hej" } };
+    const res = loadTsconfig(
+      "/root/dir1/tsconfig.json",
+      path => path === "/root/dir1/tsconfig.json",
+      _ => `{
+          // my comment
+          "compilerOptions": { 
+            "baseUrl": "hej"
+          }
+        }`
+    );
+    assert.deepEqual(res, config);
+  });
+
+  it("It should load a config with trailing commas", () => {
+    const config = { compilerOptions: { baseUrl: "hej" } };
+    const res = loadTsconfig(
+      "/root/dir1/tsconfig.json",
+      path => path === "/root/dir1/tsconfig.json",
+      _ => `{
+          "compilerOptions": { 
+            "baseUrl": "hej",
+          },
+        }`
+    );
+    assert.deepEqual(res, config);
+  });
+
+  it("It should load a config with extends and overwrite all options", () => {
+    const firstConfig = {
+      extends: "../base-config.json",
+      compilerOptions: { baseUrl: "kalle", paths: { foo: ["bar2"] } }
+    };
+    const firstConfigPath = join("/root", "dir1", "tsconfig.json");
+    const baseConfig = {
+      compilerOptions: {
+        baseUrl: "olle",
+        paths: { foo: ["bar1"] },
+        strict: true
+      }
+    };
+    const baseConfigPath = join("/root", "base-config.json");
+    const res = loadTsconfig(
+      join("/root", "dir1", "tsconfig.json"),
+      path => path === firstConfigPath || path === baseConfigPath,
+      path => {
+        if (path === firstConfigPath) {
+          return JSON.stringify(firstConfig);
+        }
+        if (path === baseConfigPath) {
+          return JSON.stringify(baseConfig);
+        }
+        return "";
+      }
+    );
+
+    assert.deepEqual(res, {
+      extends: "../base-config.json",
+      compilerOptions: {
+        baseUrl: "kalle",
+        paths: { foo: ["bar2"] },
+        strict: true
+      }
+    });
+  });
+
+  it("Should use baseUrl relative to location of extended tsconfig", () => {
+    const firstConfig = { compilerOptions: { baseUrl: "." } };
+    const firstConfigPath = join("/root", "first-config.json");
+    const secondConfig = { extends: "../first-config.json" };
+    const secondConfigPath = join("/root", "dir1", "second-config.json");
+    const thirdConfig = { extends: "../second-config.json" };
+    const thirdConfigPath = join("/root", "dir1", "dir2", "third-config.json");
+    const res = loadTsconfig(
+      join("/root", "dir1", "dir2", "third-config.json"),
+      path =>
+        path === firstConfigPath ||
+        path === secondConfigPath ||
+        path === thirdConfigPath,
+      path => {
+        if (path === firstConfigPath) {
+          return JSON.stringify(firstConfig);
+        }
+        if (path === secondConfigPath) {
+          return JSON.stringify(secondConfig);
+        }
+        if (path === thirdConfigPath) {
+          return JSON.stringify(thirdConfig);
+        }
+        return "";
+      }
+    );
+
+    assert.deepEqual(res, {
+      extends: "../second-config.json",
+      compilerOptions: { baseUrl: join("..", "..") }
+    });
+  });
+});

github/codeql-action-v1/node_modules/tsconfig-paths/test/tsconfig-named.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../base-tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "module": "commonjs",
+    "target": "es6",
+    "sourceMap": true,
+    "outDir": "./js_out"
+  }
+}

github/codeql-action-v1/node_modules/tsconfig-paths/test/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../base-tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es6",
+    "sourceMap": true,
+    "outDir": "./js_out"
+  }
+}