Add comprehensive development roadmap via GitHub Issues

Created 10 detailed GitHub issues covering:
- Project activation and management UI (#1-2)
- Worker node coordination and visualization (#3-4)
- Automated GitHub repository scanning (#5)
- Intelligent model-to-issue matching (#6)
- Multi-model task execution system (#7)
- N8N workflow integration (#8)
- Hive-Bzzz P2P bridge (#9)
- Peer assistance protocol (#10)

Each issue includes detailed specifications, acceptance criteria,
technical implementation notes, and dependency mapping.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

frontend/node_modules/tsconfig-paths/src/__tests__/config-loader.test.ts

@@ -0,0 +1,101 @@
+import {
+  configLoader,
+  loadConfig,
+  ConfigLoaderFailResult,
+  ConfigLoaderSuccessResult,
+} from "../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;
+    expect(successResult.resultType).toBe("success");
+    expect(successResult.absoluteBaseUrl).toBe("/foo/bar");
+    expect(successResult.paths["asd"][0]).toBe("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;
+    expect(successResult.resultType).toBe("success");
+    expect(successResult.absoluteBaseUrl).toBe(join("/baz", "bar/"));
+  });
+
+  it("should fallback to tsConfigLoader when explicitParams is not set", () => {
+    const result = configLoader({
+      explicitParams: undefined,
+      cwd: "/baz",
+      tsConfigLoader: () => ({
+        tsConfigPath: "/baz/tsconfig.json",
+        baseUrl: "./src",
+        paths: {},
+      }),
+    });
+
+    const successResult = result as ConfigLoaderSuccessResult;
+    expect(successResult.resultType).toBe("success");
+    expect(successResult.absoluteBaseUrl).toBe(join("/baz", "src"));
+  });
+
+  it("should tolerate a missing baseUrl", () => {
+    const result = configLoader({
+      explicitParams: undefined,
+      cwd: "/baz",
+      tsConfigLoader: () => ({
+        tsConfigPath: "/baz/tsconfig.json",
+        baseUrl: undefined,
+        paths: {},
+      }),
+    });
+
+    const failResult = result as ConfigLoaderFailResult;
+    expect(failResult.resultType).toBe("success");
+  });
+
+  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;
+    expect(successResult.resultType).toBe("success");
+    expect(successResult.configFileAbsolutePath).toBe(configFile);
+  });
+
+  it("should allow an absolute baseUrl in tsconfig.json", () => {
+    const result = configLoader({
+      explicitParams: undefined,
+      cwd: "/baz",
+      tsConfigLoader: () => ({
+        tsConfigPath: "/baz/tsconfig.json",
+        baseUrl: "/baz",
+        paths: {},
+      }),
+    });
+
+    const successResult = result as ConfigLoaderSuccessResult;
+    expect(successResult.absoluteBaseUrl).toEqual("/baz");
+  });
+});

frontend/node_modules/tsconfig-paths/src/__tests__/data/match-path-data.ts

@@ -0,0 +1,230 @@
+import { join, dirname } from "path";
+import { removeExtension } from "../../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 | string[])[];
+  readonly addMatchAll?: boolean;
+  readonly existingFiles: ReadonlyArray<string>;
+  readonly requestedModule: string;
+  readonly extensions: ReadonlyArray<string>;
+  readonly packageJson?: {};
+  readonly expectedPath: string | undefined;
+}
+
+const defaultExtensionsWhenRunningInTsNode = [
+  ".js",
+  ".json",
+  ".node",
+  ".ts",
+  ".tsx",
+];
+
+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")),
+    extensions: defaultExtensionsWhenRunningInTsNode,
+  },
+  {
+    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")),
+    extensions: defaultExtensionsWhenRunningInTsNode,
+  },
+  {
+    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"),
+    extensions: defaultExtensionsWhenRunningInTsNode,
+  },
+  {
+    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")),
+    extensions: defaultExtensionsWhenRunningInTsNode,
+  },
+  {
+    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")),
+    extensions: defaultExtensionsWhenRunningInTsNode,
+  },
+  {
+    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: join("/root", "location", "mylib", "kalle.ts"),
+    extensions: defaultExtensionsWhenRunningInTsNode,
+  },
+  {
+    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: join("/root", "location", "mylib.js", "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: 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: join("/root", "location", "mylibjs", "kalle.js"),
+  },
+  {
+    name: "should resolve nested main fields",
+    absoluteBaseUrl: "/root/",
+    paths: { "lib/*": ["location/*"] },
+    mainFields: [["esnext", "main"]],
+    packageJson: { esnext: { main: "./main.js" } },
+    existingFiles: [join("/root", "location", "mylibjs", "main.js")],
+    extensions: [".ts", ".js"],
+    requestedModule: "lib/mylibjs",
+    expectedPath: join("/root", "location", "mylibjs", "main.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: 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")),
+    extensions: defaultExtensionsWhenRunningInTsNode,
+  },
+  {
+    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,
+    extensions: defaultExtensionsWhenRunningInTsNode,
+  },
+  {
+    name: "should not locate path that does not match",
+    absoluteBaseUrl: "/root/",
+    paths: { "lib/*": ["location/*"] },
+    existingFiles: [join("root", "location", "mylib")],
+    requestedModule: "mylib",
+    expectedPath: undefined,
+    extensions: defaultExtensionsWhenRunningInTsNode,
+  },
+  {
+    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,
+    extensions: defaultExtensionsWhenRunningInTsNode,
+  },
+  {
+    name: "should resolve main file with cjs file extension",
+    absoluteBaseUrl: "/root/",
+    paths: {},
+    existingFiles: [join("/root", "mylib", "index.cjs")],
+    packageJson: {
+      main: "./index.cjs",
+    },
+    requestedModule: "mylib",
+    expectedPath: join("/root", "mylib", "index.cjs"),
+    extensions: defaultExtensionsWhenRunningInTsNode,
+  },
+];

frontend/node_modules/tsconfig-paths/src/__tests__/filesystem.test.ts

@@ -0,0 +1,57 @@
+import * as Filesystem from "../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);
+    expect(result).toBe(true);
+  });
+
+  it("should not find file that not exists, sync", () => {
+    const result = Filesystem.fileExistsSync(fileThatNotExists);
+    expect(result).toBe(false);
+  });
+
+  it("should find file that exists, async", (done) => {
+    Filesystem.fileExistsAsync(fileThatExists, (_err, result) => {
+      try {
+        expect(result).toBe(true);
+        done();
+      } catch (error) {
+        done(error);
+      }
+    });
+  });
+
+  it("should not find file that not exists, async", (done) => {
+    Filesystem.fileExistsAsync(fileThatNotExists, (_err, result) => {
+      try {
+        expect(result).toBe(false);
+        done();
+      } catch (error) {
+        done(error);
+      }
+    });
+  });
+
+  it("should load json, sync", () => {
+    const result = Filesystem.readJsonFromDiskSync(fileThatExists);
+    expect(result);
+    expect(result.main).toBe("lib/index.js");
+  });
+
+  it("should load json, async", (done) => {
+    Filesystem.readJsonFromDiskAsync(fileThatExists, (_err, result) => {
+      try {
+        expect(result).toBeTruthy();
+        expect(result.main).toBe("lib/index.js");
+        done();
+      } catch (error) {
+        done(error);
+      }
+    });
+  });
+});

frontend/node_modules/tsconfig-paths/src/__tests__/mapping-entry.test.ts

@@ -0,0 +1,43 @@
+import { getAbsoluteMappingEntries } from "../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
+    );
+    expect(result).toEqual([
+      {
+        pattern: "longest/pre/fix/*",
+        paths: [join("/absolute", "base", "url", "foo2", "bar")],
+      },
+      {
+        pattern: "pre/fix/*",
+        paths: [join("/foo3")],
+      },
+      {
+        pattern: "*",
+        paths: [join("/foo1"), join("/absolute", "base", "url", "foo2")],
+      },
+    ]);
+  });
+
+  it("should should add a match-all pattern when requested", () => {
+    let result = getAbsoluteMappingEntries("/absolute/base/url", {}, true);
+    expect(result).toEqual([
+      {
+        pattern: "*",
+        paths: [join("/absolute", "base", "url", "*")],
+      },
+    ]);
+
+    result = getAbsoluteMappingEntries("/absolute/base/url", {}, false);
+    expect(result).toEqual([]);
+  });
+});

frontend/node_modules/tsconfig-paths/src/__tests__/match-path-async.test.ts

@@ -0,0 +1,26 @@
+import { createMatchPathAsync } from "../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) => {
+          expect(result).toBe(t.expectedPath);
+          done();
+        }
+      );
+    })
+  );
+});

frontend/node_modules/tsconfig-paths/src/__tests__/match-path-sync.test.ts

@@ -0,0 +1,22 @@
+import { createMatchPath } from "../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,
+        t.extensions
+      );
+      expect(result).toBe(t.expectedPath);
+    })
+  );
+});

frontend/node_modules/tsconfig-paths/src/__tests__/try-path.test.ts

@@ -0,0 +1,141 @@
+import { getPathsToTry } from "../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")] },
+  ];
+  const abosolutePathMappingsStarstWithSlash = [
+    {
+      pattern: "/opt/*",
+      paths: [join("/absolute", "src", "aws-layer")],
+    },
+    {
+      pattern: "*",
+      paths: [join("/absolute", "src")],
+    },
+  ];
+  it("should return no paths for relative requested module", () => {
+    const result = getPathsToTry(
+      [".ts", "tsx"],
+      abosolutePathMappings,
+      "./requested-module"
+    );
+    expect(result).toBeUndefined();
+  });
+
+  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"
+    );
+    expect(result).toBeUndefined();
+  });
+
+  it("should get all paths that matches requested module", () => {
+    const result = getPathsToTry(
+      [".ts", ".tsx"],
+      abosolutePathMappings,
+      "longest/pre/fix/requested-module"
+    );
+    expect(result).toEqual([
+      // "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"),
+      },
+    ]);
+  });
+
+  it("should resolve paths starting with a slash", () => {
+    const result = getPathsToTry(
+      [".ts"],
+      abosolutePathMappingsStarstWithSlash,
+      "/opt/utils"
+    );
+    expect(result).toEqual([
+      // "opt/*"
+      {
+        path: join("/absolute", "src", "aws-layer"),
+        type: "file",
+      },
+      {
+        path: join("/absolute", "src", "aws-layer.ts"),
+        type: "extension",
+      },
+      {
+        path: join("/absolute", "src", "aws-layer", "package.json"),
+        type: "package",
+      },
+      {
+        path: join("/absolute", "src", "aws-layer", "index.ts"),
+        type: "index",
+      },
+      // "*"
+      {
+        path: join("/absolute", "src"),
+        type: "file",
+      },
+      {
+        path: join("/absolute", "src.ts"),
+        type: "extension",
+      },
+      {
+        path: join("/absolute", "src", "package.json"),
+        type: "package",
+      },
+      {
+        path: join("/absolute", "src", "index.ts"),
+        type: "index",
+      },
+    ]);
+  });
+});

frontend/node_modules/tsconfig-paths/src/__tests__/tsconfig-loader.test.ts

@@ -0,0 +1,428 @@
+import {
+  loadTsconfig,
+  tsConfigLoader,
+  walkForTsConfig,
+} from "../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: {},
+        };
+      },
+    });
+
+    expect(result.tsConfigPath).toBe("/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: {},
+        };
+      },
+    });
+
+    expect(result.tsConfigPath).toBeUndefined();
+  });
+
+  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: {},
+        };
+      },
+    });
+
+    expect(result.tsConfigPath).toBe("/foo/baz/tsconfig.json");
+  });
+
+  it("should use TS_NODE_BASEURL env if exists", () => {
+    const result = tsConfigLoader({
+      cwd: "/foo/bar",
+      getEnv: (key: string) =>
+        key === "TS_NODE_BASEURL" ? "SOME_BASEURL" : undefined,
+      loadSync: (_0: string, _1: string, baseUrl: string) => {
+        return {
+          tsConfigPath: undefined,
+          baseUrl,
+          paths: {},
+        };
+      },
+    });
+
+    expect(result.baseUrl).toBe("SOME_BASEURL");
+  });
+
+  it("should not use TS_NODE_BASEURL env if it does not exist", () => {
+    const result = tsConfigLoader({
+      cwd: "/foo/bar",
+      getEnv: (_: string) => {
+        return undefined;
+      },
+      loadSync: (_0: string, _1: string, baseUrl: string) => {
+        return {
+          tsConfigPath: undefined,
+          baseUrl,
+          paths: {},
+        };
+      },
+    });
+
+    expect(result.baseUrl).toBeUndefined();
+  });
+});
+
+describe("walkForTsConfig", () => {
+  it("should find tsconfig in starting directory", () => {
+    const pathToTsconfig = join("/root", "dir1", "tsconfig.json");
+    const mockFiles: Record<string, string[]> = {
+      "/root/dir1": ["tsconfig.json"],
+    };
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      (path) => mockFiles[path] || []
+    );
+    expect(res).toBe(pathToTsconfig);
+  });
+
+  it("should find jsconfig in starting directory", () => {
+    const pathToJsconfig = join("/root", "dir1", "jsconfig.json");
+    const mockFiles: Record<string, string[]> = {
+      "/root/dir1": ["jsconfig.json"],
+    };
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      (path) => mockFiles[path] || []
+    );
+    expect(res).toBe(pathToJsconfig);
+  });
+
+  // see https://github.com/Microsoft/TypeScript/issues/15869#issuecomment-301845650
+  it("tsconfig.json take precedence over jsconfig.json when both exist", () => {
+    const pathToTsconfig = join("/root/dir1", "tsconfig.json");
+    const mockFiles: Record<string, string[]> = {
+      "/root/dir1": ["jsconfig.json", "tsconfig.json"],
+    };
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      (path) => mockFiles[path] || []
+    );
+    expect(res).toBe(pathToTsconfig);
+  });
+
+  it("should find tsconfig in parent directory", () => {
+    const pathToTsconfig = join("/root", "tsconfig.json");
+    const mockFiles: Record<string, string[]> = {
+      "/root": ["tsconfig.json"],
+    };
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      (path) => mockFiles[path] || []
+    );
+    expect(res).toBe(pathToTsconfig);
+  });
+
+  it("should find jsconfig in parent directory", () => {
+    const pathToTsconfig = join("/root", "jsconfig.json");
+    const mockFiles: Record<string, string[]> = {
+      "/root": ["jsconfig.json"],
+    };
+    const res = walkForTsConfig(
+      join("/root", "dir1"),
+      (path) => mockFiles[path] || []
+    );
+    expect(res).toBe(pathToTsconfig);
+  });
+
+  it("should return undefined when reaching the top", () => {
+    const res = walkForTsConfig(join("/root", "dir1", "kalle"), () => []);
+    expect(res).toBeUndefined();
+  });
+});
+
+describe("loadConfig", () => {
+  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)
+    );
+    expect(res).toStrictEqual(config);
+  });
+
+  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"
+          }
+        }`
+    );
+    expect(res).toStrictEqual(config);
+  });
+
+  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",
+          },
+        }`
+    );
+    expect(res).toStrictEqual(config);
+  });
+
+  it("should throw an error including the file path when encountering invalid JSON5", () => {
+    expect(() =>
+      loadTsconfig(
+        "/root/dir1/tsconfig.json",
+        (path) => path === "/root/dir1/tsconfig.json",
+        (_) => `{
+            "compilerOptions": {
+          }`
+      )
+    ).toThrowError(
+      "/root/dir1/tsconfig.json is malformed JSON5: invalid end of input at 3:12"
+    );
+  });
+
+  it("should load a config with string 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 "";
+      }
+    );
+
+    expect(res).toEqual({
+      extends: "../base-config.json",
+      compilerOptions: {
+        baseUrl: "kalle",
+        paths: { foo: ["bar2"] },
+        strict: true,
+      },
+    });
+  });
+
+  it("should load a config with string extends from node_modules and overwrite all options", () => {
+    const firstConfig = {
+      extends: "my-package/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",
+      "dir1",
+      "node_modules",
+      "my-package",
+      "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 "";
+      }
+    );
+
+    expect(res).toEqual({
+      extends: "my-package/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 "";
+      }
+    );
+
+    expect(res).toEqual({
+      extends: "../second-config.json",
+      compilerOptions: { baseUrl: join("..", "..") },
+    });
+  });
+
+  it("should load a config with array extends and overwrite all options", () => {
+    const baseConfig1 = {
+      compilerOptions: { baseUrl: ".", paths: { foo: ["bar"] } },
+    };
+    const baseConfig1Path = join("/root", "base-config-1.json");
+    const baseConfig2 = { compilerOptions: { baseUrl: "." } };
+    const baseConfig2Path = join("/root", "dir1", "base-config-2.json");
+    const baseConfig3 = {
+      compilerOptions: { baseUrl: ".", paths: { foo: ["bar2"] } },
+    };
+    const baseConfig3Path = join("/root", "dir1", "dir2", "base-config-3.json");
+    const actualConfig = {
+      extends: [
+        "./base-config-1.json",
+        "./dir1/base-config-2.json",
+        "./dir1/dir2/base-config-3.json",
+      ],
+    };
+    const actualConfigPath = join("/root", "tsconfig.json");
+
+    const res = loadTsconfig(
+      join("/root", "tsconfig.json"),
+      (path) =>
+        [
+          baseConfig1Path,
+          baseConfig2Path,
+          baseConfig3Path,
+          actualConfigPath,
+        ].indexOf(path) >= 0,
+      (path) => {
+        if (path === baseConfig1Path) {
+          return JSON.stringify(baseConfig1);
+        }
+        if (path === baseConfig2Path) {
+          return JSON.stringify(baseConfig2);
+        }
+        if (path === baseConfig3Path) {
+          return JSON.stringify(baseConfig3);
+        }
+        if (path === actualConfigPath) {
+          return JSON.stringify(actualConfig);
+        }
+        return "";
+      }
+    );
+
+    expect(res).toEqual({
+      extends: [
+        "./base-config-1.json",
+        "./dir1/base-config-2.json",
+        "./dir1/dir2/base-config-3.json",
+      ],
+      compilerOptions: {
+        baseUrl: join("dir1", "dir2"),
+        paths: { foo: ["bar2"] },
+      },
+    });
+  });
+
+  it("should load a config with array extends without .json extension", () => {
+    const baseConfig = {
+      compilerOptions: { baseUrl: ".", paths: { foo: ["bar"] } },
+    };
+    const baseConfigPath = join("/root", "base-config-1.json");
+    const actualConfig = { extends: ["./base-config-1"] };
+    const actualConfigPath = join("/root", "tsconfig.json");
+
+    const res = loadTsconfig(
+      join("/root", "tsconfig.json"),
+      (path) => [baseConfigPath, actualConfigPath].indexOf(path) >= 0,
+      (path) => {
+        if (path === baseConfigPath) {
+          return JSON.stringify(baseConfig);
+        }
+        if (path === actualConfigPath) {
+          return JSON.stringify(actualConfig);
+        }
+        return "";
+      }
+    );
+
+    expect(res).toEqual({
+      extends: ["./base-config-1"],
+      compilerOptions: {
+        baseUrl: ".",
+        paths: { foo: ["bar"] },
+      },
+    });
+  });
+});

frontend/node_modules/tsconfig-paths/src/__tests__/tsconfig-named.json

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

frontend/node_modules/tsconfig-paths/src/config-loader.ts

@@ -0,0 +1,89 @@
+import * as TsConfigLoader2 from "./tsconfig-loader";
+import * as path from "path";
+
+export interface ExplicitParams {
+  baseUrl: string;
+  paths: { [key: string]: Array<string> };
+  mainFields?: (string | string[])[];
+  addMatchAll?: boolean;
+}
+
+export type TsConfigLoader = (
+  params: TsConfigLoader2.TsConfigLoaderParams
+) => TsConfigLoader2.TsConfigLoaderResult;
+
+export interface ConfigLoaderParams {
+  cwd: string;
+  explicitParams?: ExplicitParams;
+  tsConfigLoader?: TsConfigLoader;
+}
+
+export interface ConfigLoaderSuccessResult {
+  resultType: "success";
+  configFileAbsolutePath: string;
+  baseUrl?: string;
+  absoluteBaseUrl: string;
+  paths: { [key: string]: Array<string> };
+  mainFields?: (string | string[])[];
+  addMatchAll?: boolean;
+}
+
+export interface ConfigLoaderFailResult {
+  resultType: "failed";
+  message: string;
+}
+
+export type ConfigLoaderResult =
+  | ConfigLoaderSuccessResult
+  | ConfigLoaderFailResult;
+
+export function loadConfig(cwd: string = process.cwd()): ConfigLoaderResult {
+  return configLoader({ cwd });
+}
+
+export function configLoader({
+  cwd,
+  explicitParams,
+  tsConfigLoader = TsConfigLoader2.tsConfigLoader,
+}: ConfigLoaderParams): ConfigLoaderResult {
+  if (explicitParams) {
+    const absoluteBaseUrl = path.isAbsolute(explicitParams.baseUrl)
+      ? explicitParams.baseUrl
+      : path.join(cwd, explicitParams.baseUrl);
+
+    return {
+      resultType: "success",
+      configFileAbsolutePath: "",
+      baseUrl: explicitParams.baseUrl,
+      absoluteBaseUrl,
+      paths: explicitParams.paths,
+      mainFields: explicitParams.mainFields,
+      addMatchAll: explicitParams.addMatchAll,
+    };
+  }
+
+  // Load tsconfig and create path matching function
+  const loadResult = tsConfigLoader({
+    cwd,
+    getEnv: (key: string) => process.env[key],
+  });
+
+  if (!loadResult.tsConfigPath) {
+    return {
+      resultType: "failed",
+      message: "Couldn't find tsconfig.json",
+    };
+  }
+
+  return {
+    resultType: "success",
+    configFileAbsolutePath: loadResult.tsConfigPath,
+    baseUrl: loadResult.baseUrl,
+    absoluteBaseUrl: path.resolve(
+      path.dirname(loadResult.tsConfigPath),
+      loadResult.baseUrl || ""
+    ),
+    paths: loadResult.paths || {},
+    addMatchAll: loadResult.baseUrl !== undefined,
+  };
+}

frontend/node_modules/tsconfig-paths/src/filesystem.ts

@@ -0,0 +1,93 @@
+import * as fs from "fs";
+
+/**
+ * Typing for the fields of package.json we care about
+ */
+export interface PackageJson {
+  [key: string]: string | PackageJson;
+}
+
+/**
+ * A function that json from a file
+ */
+export interface ReadJsonSync {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (packageJsonPath: string): any | undefined;
+}
+
+export interface FileExistsSync {
+  (name: string): boolean;
+}
+
+export interface FileExistsAsync {
+  (path: string, callback: (err?: Error, exists?: boolean) => void): void;
+}
+
+export interface ReadJsonAsyncCallback {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (err?: Error, content?: any): void;
+}
+
+export interface ReadJsonAsync {
+  (path: string, callback: ReadJsonAsyncCallback): void;
+}
+
+export function fileExistsSync(path: string): boolean {
+  // If the file doesn't exist, avoid throwing an exception over the native barrier for every miss
+  if (!fs.existsSync(path)) {
+    return false;
+  }
+  try {
+    const stats = fs.statSync(path);
+    return stats.isFile();
+  } catch (err) {
+    // If error, assume file did not exist
+    return false;
+  }
+}
+
+/**
+ * Reads package.json from disk
+ *
+ * @param file Path to package.json
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function readJsonFromDiskSync(packageJsonPath: string): any | undefined {
+  if (!fs.existsSync(packageJsonPath)) {
+    return undefined;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  return require(packageJsonPath);
+}
+
+export function readJsonFromDiskAsync(
+  path: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  callback: (err?: Error, content?: any) => void
+): void {
+  fs.readFile(path, "utf8", (err, result) => {
+    // If error, assume file did not exist
+    if (err || !result) {
+      return callback();
+    }
+    const json = JSON.parse(result);
+    return callback(undefined, json);
+  });
+}
+
+export function fileExistsAsync(
+  path2: string,
+  callback2: (err?: Error, exists?: boolean) => void
+): void {
+  fs.stat(path2, (err: Error, stats: fs.Stats) => {
+    if (err) {
+      // If error assume file does not exist
+      return callback2(undefined, false);
+    }
+    callback2(undefined, stats ? stats.isFile() : false);
+  });
+}
+
+export function removeExtension(path: string): string {
+  return path.substring(0, path.lastIndexOf(".")) || path;
+}

frontend/node_modules/tsconfig-paths/src/index.ts

@@ -0,0 +1,24 @@
+// register is used from register.js in root dir
+export {
+  createMatchPath,
+  matchFromAbsolutePaths,
+  MatchPath,
+} from "./match-path-sync";
+export {
+  createMatchPathAsync,
+  matchFromAbsolutePathsAsync,
+  MatchPathAsync,
+} from "./match-path-async";
+export { register } from "./register";
+export {
+  loadConfig,
+  ConfigLoaderResult,
+  ConfigLoaderSuccessResult,
+  ConfigLoaderFailResult,
+} from "./config-loader";
+export {
+  ReadJsonSync,
+  ReadJsonAsync,
+  FileExistsSync,
+  FileExistsAsync,
+} from "./filesystem";

frontend/node_modules/tsconfig-paths/src/mapping-entry.ts

@@ -0,0 +1,65 @@
+import * as path from "path";
+
+export interface MappingEntry {
+  readonly pattern: string;
+  readonly paths: ReadonlyArray<string>;
+}
+
+export interface Paths {
+  readonly [key: string]: ReadonlyArray<string>;
+}
+
+/**
+ * Converts an absolute baseUrl and paths to an array of absolute mapping entries.
+ * The array is sorted by longest prefix.
+ * Having an array with entries allows us to keep a sorting order rather than
+ * sort by keys each time we use the mappings.
+ *
+ * @param absoluteBaseUrl
+ * @param paths
+ * @param addMatchAll
+ */
+export function getAbsoluteMappingEntries(
+  absoluteBaseUrl: string,
+  paths: Paths,
+  addMatchAll: boolean
+): ReadonlyArray<MappingEntry> {
+  // Resolve all paths to absolute form once here, and sort them by
+  // longest prefix once here, this saves time on each request later.
+  // We need to put them in an array to preserve the sorting order.
+  const sortedKeys = sortByLongestPrefix(Object.keys(paths));
+  const absolutePaths: Array<MappingEntry> = [];
+  for (const key of sortedKeys) {
+    absolutePaths.push({
+      pattern: key,
+      paths: paths[key].map((pathToResolve) =>
+        path.resolve(absoluteBaseUrl, pathToResolve)
+      ),
+    });
+  }
+  // If there is no match-all path specified in the paths section of tsconfig, then try to match
+  // all paths relative to baseUrl, this is how typescript works.
+  if (!paths["*"] && addMatchAll) {
+    absolutePaths.push({
+      pattern: "*",
+      paths: [`${absoluteBaseUrl.replace(/\/$/, "")}/*`],
+    });
+  }
+
+  return absolutePaths;
+}
+
+/**
+ * Sort path patterns.
+ * If a module name can be matched with multiple patterns then pattern with the longest prefix will be picked.
+ */
+function sortByLongestPrefix(arr: Array<string>): Array<string> {
+  return arr
+    .concat()
+    .sort((a: string, b: string) => getPrefixLength(b) - getPrefixLength(a));
+}
+
+function getPrefixLength(pattern: string): number {
+  const prefixLength = pattern.indexOf("*");
+  return pattern.substr(0, prefixLength).length;
+}

frontend/node_modules/tsconfig-paths/src/match-path-async.ts

@@ -0,0 +1,223 @@
+import * as path from "path";
+import * as TryPath from "./try-path";
+import * as MappingEntry from "./mapping-entry";
+import * as Filesystem from "./filesystem";
+
+/**
+ * Function that can match a path async
+ */
+export interface MatchPathAsync {
+  (
+    requestedModule: string,
+    readJson: Filesystem.ReadJsonAsync | undefined,
+    fileExists: Filesystem.FileExistsAsync | undefined,
+    extensions: ReadonlyArray<string> | undefined,
+    callback: MatchPathAsyncCallback
+  ): void;
+}
+
+export interface MatchPathAsyncCallback {
+  // eslint-disable-next-line no-shadow
+  (err?: Error, path?: string): void;
+}
+
+/**
+ * See the sync version for docs.
+ */
+export function createMatchPathAsync(
+  absoluteBaseUrl: string,
+  paths: { [key: string]: Array<string> },
+  mainFields: (string | string[])[] = ["main"],
+  addMatchAll: boolean = true
+): MatchPathAsync {
+  const absolutePaths = MappingEntry.getAbsoluteMappingEntries(
+    absoluteBaseUrl,
+    paths,
+    addMatchAll
+  );
+
+  return (
+    requestedModule: string,
+    readJson: Filesystem.ReadJsonAsync | undefined,
+    fileExists: Filesystem.FileExistsAsync | undefined,
+    extensions: ReadonlyArray<string> | undefined,
+    callback: MatchPathAsyncCallback
+  ) =>
+    matchFromAbsolutePathsAsync(
+      absolutePaths,
+      requestedModule,
+      readJson,
+      fileExists,
+      extensions,
+      callback,
+      mainFields
+    );
+}
+
+/**
+ * See the sync version for docs.
+ */
+export function matchFromAbsolutePathsAsync(
+  absolutePathMappings: ReadonlyArray<MappingEntry.MappingEntry>,
+  requestedModule: string,
+  readJson: Filesystem.ReadJsonAsync = Filesystem.readJsonFromDiskAsync,
+  fileExists: Filesystem.FileExistsAsync = Filesystem.fileExistsAsync,
+  extensions: ReadonlyArray<string> = Object.keys(require.extensions),
+  callback: MatchPathAsyncCallback,
+  mainFields: (string | string[])[] = ["main"]
+): void {
+  const tryPaths = TryPath.getPathsToTry(
+    extensions,
+    absolutePathMappings,
+    requestedModule
+  );
+
+  if (!tryPaths) {
+    return callback();
+  }
+
+  findFirstExistingPath(
+    tryPaths,
+    readJson,
+    fileExists,
+    callback,
+    0,
+    mainFields
+  );
+}
+
+function findFirstExistingMainFieldMappedFile(
+  packageJson: Filesystem.PackageJson,
+  mainFields: (string | string[])[],
+  packageJsonPath: string,
+  fileExistsAsync: Filesystem.FileExistsAsync,
+  doneCallback: (err?: Error, filepath?: string) => void,
+  index: number = 0
+): void {
+  if (index >= mainFields.length) {
+    return doneCallback(undefined, undefined);
+  }
+
+  const tryNext = (): void =>
+    findFirstExistingMainFieldMappedFile(
+      packageJson,
+      mainFields,
+      packageJsonPath,
+      fileExistsAsync,
+      doneCallback,
+      index + 1
+    );
+
+  const mainFieldSelector = mainFields[index];
+  const mainFieldMapping =
+    typeof mainFieldSelector === "string"
+      ? packageJson[mainFieldSelector]
+      : mainFieldSelector.reduce((obj, key) => obj[key], packageJson);
+  if (typeof mainFieldMapping !== "string") {
+    // Skip mappings that are not pointers to replacement files
+    return tryNext();
+  }
+
+  const mappedFilePath = path.join(
+    path.dirname(packageJsonPath),
+    mainFieldMapping
+  );
+  fileExistsAsync(mappedFilePath, (err?: Error, exists?: boolean) => {
+    if (err) {
+      return doneCallback(err);
+    }
+    if (exists) {
+      return doneCallback(undefined, mappedFilePath);
+    }
+    return tryNext();
+  });
+}
+
+// Recursive loop to probe for physical files
+function findFirstExistingPath(
+  tryPaths: ReadonlyArray<TryPath.TryPath>,
+  readJson: Filesystem.ReadJsonAsync,
+  fileExists: Filesystem.FileExistsAsync,
+  doneCallback: MatchPathAsyncCallback,
+  index: number = 0,
+  mainFields: (string | string[])[] = ["main"]
+): void {
+  const tryPath = tryPaths[index];
+  if (
+    tryPath.type === "file" ||
+    tryPath.type === "extension" ||
+    tryPath.type === "index"
+  ) {
+    fileExists(tryPath.path, (err: Error, exists: boolean) => {
+      if (err) {
+        return doneCallback(err);
+      }
+      if (exists) {
+        return doneCallback(undefined, TryPath.getStrippedPath(tryPath));
+      }
+      if (index === tryPaths.length - 1) {
+        return doneCallback();
+      }
+      // Continue with the next path
+      return findFirstExistingPath(
+        tryPaths,
+        readJson,
+        fileExists,
+        doneCallback,
+        index + 1,
+        mainFields
+      );
+    });
+  } else if (tryPath.type === "package") {
+    readJson(tryPath.path, (err, packageJson) => {
+      if (err) {
+        return doneCallback(err);
+      }
+      if (packageJson) {
+        return findFirstExistingMainFieldMappedFile(
+          packageJson,
+          mainFields,
+          tryPath.path,
+          fileExists,
+          (mainFieldErr?: Error, mainFieldMappedFile?: string) => {
+            if (mainFieldErr) {
+              return doneCallback(mainFieldErr);
+            }
+            if (mainFieldMappedFile) {
+              return doneCallback(undefined, mainFieldMappedFile);
+            }
+
+            // No field in package json was a valid option. Continue with the next path.
+            return findFirstExistingPath(
+              tryPaths,
+              readJson,
+              fileExists,
+              doneCallback,
+              index + 1,
+              mainFields
+            );
+          }
+        );
+      }
+
+      // This is async code, we need to return unconditionally, otherwise the code still falls
+      // through and keeps recursing. While this might work in general, libraries that use neo-async
+      // like Webpack will actually not allow you to call the same callback twice.
+      //
+      // An example of where this caused issues:
+      // https://github.com/dividab/tsconfig-paths-webpack-plugin/issues/11
+      //
+      // Continue with the next path
+      return findFirstExistingPath(
+        tryPaths,
+        readJson,
+        fileExists,
+        doneCallback,
+        index + 1,
+        mainFields
+      );
+    });
+  } else {
+    TryPath.exhaustiveTypeException(tryPath.type);
+  }
+}

frontend/node_modules/tsconfig-paths/src/match-path-sync.ts

@@ -0,0 +1,146 @@
+import * as path from "path";
+import * as Filesystem from "./filesystem";
+import * as MappingEntry from "./mapping-entry";
+import * as TryPath from "./try-path";
+
+/**
+ * Function that can match a path
+ */
+export interface MatchPath {
+  (
+    requestedModule: string,
+    readJson?: Filesystem.ReadJsonSync,
+    fileExists?: (name: string) => boolean,
+    extensions?: ReadonlyArray<string>
+  ): string | undefined;
+}
+
+/**
+ * Creates a function that can resolve paths according to tsconfig paths property.
+ *
+ * @param absoluteBaseUrl Absolute version of baseUrl as specified in tsconfig.
+ * @param paths The paths as specified in tsconfig.
+ * @param mainFields A list of package.json field names to try when resolving module files. Select a nested field using an array of field names.
+ * @param addMatchAll Add a match-all "*" rule if none is present
+ * @returns a function that can resolve paths.
+ */
+export function createMatchPath(
+  absoluteBaseUrl: string,
+  paths: { [key: string]: Array<string> },
+  mainFields: (string | string[])[] = ["main"],
+  addMatchAll: boolean = true
+): MatchPath {
+  const absolutePaths = MappingEntry.getAbsoluteMappingEntries(
+    absoluteBaseUrl,
+    paths,
+    addMatchAll
+  );
+
+  return (
+    requestedModule: string,
+    readJson?: Filesystem.ReadJsonSync,
+    fileExists?: Filesystem.FileExistsSync,
+    extensions?: Array<string>
+  ) =>
+    matchFromAbsolutePaths(
+      absolutePaths,
+      requestedModule,
+      readJson,
+      fileExists,
+      extensions,
+      mainFields
+    );
+}
+
+/**
+ * Finds a path from tsconfig that matches a module load request.
+ *
+ * @param absolutePathMappings The paths to try as specified in tsconfig but resolved to absolute form.
+ * @param requestedModule The required module name.
+ * @param readJson Function that can read json from a path (useful for testing).
+ * @param fileExists Function that checks for existence of a file at a path (useful for testing).
+ * @param extensions File extensions to probe for (useful for testing).
+ * @param mainFields A list of package.json field names to try when resolving module files. Select a nested field using an array of field names.
+ * @returns the found path, or undefined if no path was found.
+ */
+export function matchFromAbsolutePaths(
+  absolutePathMappings: ReadonlyArray<MappingEntry.MappingEntry>,
+  requestedModule: string,
+  readJson: Filesystem.ReadJsonSync = Filesystem.readJsonFromDiskSync,
+  fileExists: Filesystem.FileExistsSync = Filesystem.fileExistsSync,
+  extensions: Array<string> = Object.keys(require.extensions),
+  mainFields: (string | string[])[] = ["main"]
+): string | undefined {
+  const tryPaths = TryPath.getPathsToTry(
+    extensions,
+    absolutePathMappings,
+    requestedModule
+  );
+
+  if (!tryPaths) {
+    return undefined;
+  }
+
+  return findFirstExistingPath(tryPaths, readJson, fileExists, mainFields);
+}
+
+function findFirstExistingMainFieldMappedFile(
+  packageJson: Filesystem.PackageJson,
+  mainFields: (string | string[])[],
+  packageJsonPath: string,
+  fileExists: Filesystem.FileExistsSync
+): string | undefined {
+  for (let index = 0; index < mainFields.length; index++) {
+    const mainFieldSelector = mainFields[index];
+    const candidateMapping =
+      typeof mainFieldSelector === "string"
+        ? packageJson[mainFieldSelector]
+        : mainFieldSelector.reduce((obj, key) => obj[key], packageJson);
+    if (candidateMapping && typeof candidateMapping === "string") {
+      const candidateFilePath = path.join(
+        path.dirname(packageJsonPath),
+        candidateMapping
+      );
+      if (fileExists(candidateFilePath)) {
+        return candidateFilePath;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function findFirstExistingPath(
+  tryPaths: ReadonlyArray<TryPath.TryPath>,
+  readJson: Filesystem.ReadJsonSync = Filesystem.readJsonFromDiskSync,
+  fileExists: Filesystem.FileExistsSync,
+  mainFields: (string | string[])[] = ["main"]
+): string | undefined {
+  for (const tryPath of tryPaths) {
+    if (
+      tryPath.type === "file" ||
+      tryPath.type === "extension" ||
+      tryPath.type === "index"
+    ) {
+      if (fileExists(tryPath.path)) {
+        return TryPath.getStrippedPath(tryPath);
+      }
+    } else if (tryPath.type === "package") {
+      const packageJson: Filesystem.PackageJson = readJson(tryPath.path);
+      if (packageJson) {
+        const mainFieldMappedFile = findFirstExistingMainFieldMappedFile(
+          packageJson,
+          mainFields,
+          tryPath.path,
+          fileExists
+        );
+        if (mainFieldMappedFile) {
+          return mainFieldMappedFile;
+        }
+      }
+    } else {
+      TryPath.exhaustiveTypeException(tryPath.type);
+    }
+  }
+  return undefined;
+}

frontend/node_modules/tsconfig-paths/src/register.ts

@@ -0,0 +1,123 @@
+import { createMatchPath } from "./match-path-sync";
+import { configLoader, ExplicitParams } from "./config-loader";
+
+const noOp = (): void => void 0;
+
+function getCoreModules(
+  builtinModules: string[] | undefined
+): { [key: string]: boolean } {
+  builtinModules = builtinModules || [
+    "assert",
+    "buffer",
+    "child_process",
+    "cluster",
+    "crypto",
+    "dgram",
+    "dns",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "https",
+    "net",
+    "os",
+    "path",
+    "punycode",
+    "querystring",
+    "readline",
+    "stream",
+    "string_decoder",
+    "tls",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "zlib",
+  ];
+
+  const coreModules: { [key: string]: boolean } = {};
+  for (let module of builtinModules) {
+    coreModules[module] = true;
+  }
+
+  return coreModules;
+}
+
+export interface RegisterParams extends ExplicitParams {
+  /**
+   * Defaults to `--project` CLI flag or `process.cwd()`
+   */
+  cwd?: string;
+}
+
+/**
+ * Installs a custom module load function that can adhere to paths in tsconfig.
+ * Returns a function to undo paths registration.
+ */
+export function register(params?: RegisterParams): () => void {
+  let cwd: string | undefined;
+  let explicitParams: ExplicitParams | undefined;
+  if (params) {
+    cwd = params.cwd;
+    if (params.baseUrl || params.paths) {
+      explicitParams = params;
+    }
+  } else {
+    // eslint-disable-next-line
+    const minimist = require("minimist");
+    const argv = minimist(process.argv.slice(2), {
+      // eslint-disable-next-line id-denylist
+      string: ["project"],
+      alias: {
+        project: ["P"],
+      },
+    });
+    cwd = argv.project;
+  }
+
+  const configLoaderResult = configLoader({
+    cwd: cwd ?? process.cwd(),
+    explicitParams,
+  });
+
+  if (configLoaderResult.resultType === "failed") {
+    console.warn(
+      `${configLoaderResult.message}. tsconfig-paths will be skipped`
+    );
+
+    return noOp;
+  }
+
+  const matchPath = createMatchPath(
+    configLoaderResult.absoluteBaseUrl,
+    configLoaderResult.paths,
+    configLoaderResult.mainFields,
+    configLoaderResult.addMatchAll
+  );
+
+  // Patch node's module loading
+  // eslint-disable-next-line @typescript-eslint/no-require-imports,@typescript-eslint/no-var-requires
+  const Module = require("module");
+  // eslint-disable-next-line no-underscore-dangle
+  const originalResolveFilename = Module._resolveFilename;
+  const coreModules = getCoreModules(Module.builtinModules);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any,no-underscore-dangle
+  Module._resolveFilename = function (request: string, _parent: any): string {
+    const isCoreModule = coreModules.hasOwnProperty(request);
+    if (!isCoreModule) {
+      const found = matchPath(request);
+      if (found) {
+        const modifiedArguments = [found, ...[].slice.call(arguments, 1)]; // Passes all arguments. Even those that is not specified above.
+        return originalResolveFilename.apply(this, modifiedArguments);
+      }
+    }
+    return originalResolveFilename.apply(this, arguments);
+  };
+
+  return () => {
+    // Return node's module loading to original state.
+    // eslint-disable-next-line no-underscore-dangle
+    Module._resolveFilename = originalResolveFilename;
+  };
+}

frontend/node_modules/tsconfig-paths/src/try-path.ts

@@ -0,0 +1,103 @@
+import * as path from "path";
+import { MappingEntry } from "./mapping-entry";
+import { dirname } from "path";
+import { removeExtension } from "./filesystem";
+
+export interface TryPath {
+  readonly type: "file" | "extension" | "index" | "package";
+  readonly path: string;
+}
+
+/**
+ * Builds a list of all physical paths to try by:
+ * 1. Check for file named exactly as request.
+ * 2. Check for files named as request ending in any of the extensions.
+ * 3. Check for file specified in package.json's main property.
+ * 4. Check for files named as request ending in "index" with any of the extensions.
+ */
+export function getPathsToTry(
+  extensions: ReadonlyArray<string>,
+  absolutePathMappings: ReadonlyArray<MappingEntry>,
+  requestedModule: string
+): ReadonlyArray<TryPath> | undefined {
+  if (!absolutePathMappings || !requestedModule || requestedModule[0] === ".") {
+    return undefined;
+  }
+
+  const pathsToTry: Array<TryPath> = [];
+  for (const entry of absolutePathMappings) {
+    const starMatch =
+      entry.pattern === requestedModule
+        ? ""
+        : matchStar(entry.pattern, requestedModule);
+    if (starMatch !== undefined) {
+      for (const physicalPathPattern of entry.paths) {
+        const physicalPath = physicalPathPattern.replace("*", starMatch);
+        pathsToTry.push({ type: "file", path: physicalPath });
+        pathsToTry.push(
+          ...extensions.map(
+            (e) => ({ type: "extension", path: physicalPath + e } as TryPath)
+          )
+        );
+        pathsToTry.push({
+          type: "package",
+          path: path.join(physicalPath, "/package.json"),
+        });
+        const indexPath = path.join(physicalPath, "/index");
+        pathsToTry.push(
+          ...extensions.map(
+            (e) => ({ type: "index", path: indexPath + e } as TryPath)
+          )
+        );
+      }
+    }
+  }
+  return pathsToTry.length === 0 ? undefined : pathsToTry;
+}
+
+// Not sure why we don't just return the full found path?
+export function getStrippedPath(tryPath: TryPath): string {
+  return tryPath.type === "index"
+    ? dirname(tryPath.path)
+    : tryPath.type === "file"
+    ? tryPath.path
+    : tryPath.type === "extension"
+    ? removeExtension(tryPath.path)
+    : tryPath.type === "package"
+    ? tryPath.path
+    : exhaustiveTypeException(tryPath.type);
+}
+
+export function exhaustiveTypeException(check: never): never {
+  throw new Error(`Unknown type ${check}`);
+}
+
+/**
+ * Matches pattern with a single star against search.
+ * Star must match at least one character to be considered a match.
+ *
+ * @param patttern for example "foo*"
+ * @param search for example "fooawesomebar"
+ * @returns the part of search that * matches, or undefined if no match.
+ */
+function matchStar(pattern: string, search: string): string | undefined {
+  if (search.length < pattern.length) {
+    return undefined;
+  }
+  if (pattern === "*") {
+    return search;
+  }
+  const star = pattern.indexOf("*");
+  if (star === -1) {
+    return undefined;
+  }
+  const part1 = pattern.substring(0, star);
+  const part2 = pattern.substring(star + 1);
+  if (search.substr(0, star) !== part1) {
+    return undefined;
+  }
+  if (search.substr(search.length - part2.length) !== part2) {
+    return undefined;
+  }
+  return search.substr(star, search.length - part2.length);
+}

frontend/node_modules/tsconfig-paths/src/tsconfig-loader.ts

@@ -0,0 +1,229 @@
+import * as path from "path";
+import * as fs from "fs";
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+import JSON5 = require("json5");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+import StripBom = require("strip-bom");
+
+/**
+ * Typing for the parts of tsconfig that we care about
+ */
+export interface Tsconfig {
+  extends?: string | string[];
+  compilerOptions?: {
+    baseUrl?: string;
+    paths?: { [key: string]: Array<string> };
+    strict?: boolean;
+  };
+}
+
+export interface TsConfigLoaderResult {
+  tsConfigPath: string | undefined;
+  baseUrl: string | undefined;
+  paths: { [key: string]: Array<string> } | undefined;
+}
+
+export interface TsConfigLoaderParams {
+  getEnv: (key: string) => string | undefined;
+  cwd: string;
+  loadSync?(
+    cwd: string,
+    filename?: string,
+    baseUrl?: string
+  ): TsConfigLoaderResult;
+}
+
+export function tsConfigLoader({
+  getEnv,
+  cwd,
+  loadSync = loadSyncDefault,
+}: TsConfigLoaderParams): TsConfigLoaderResult {
+  const TS_NODE_PROJECT = getEnv("TS_NODE_PROJECT");
+  const TS_NODE_BASEURL = getEnv("TS_NODE_BASEURL");
+
+  // tsconfig.loadSync handles if TS_NODE_PROJECT is a file or directory
+  // and also overrides baseURL if TS_NODE_BASEURL is available.
+  const loadResult = loadSync(cwd, TS_NODE_PROJECT, TS_NODE_BASEURL);
+  return loadResult;
+}
+
+function loadSyncDefault(
+  cwd: string,
+  filename?: string,
+  baseUrl?: string
+): TsConfigLoaderResult {
+  // Tsconfig.loadSync uses path.resolve. This is why we can use an absolute path as filename
+
+  const configPath = resolveConfigPath(cwd, filename);
+
+  if (!configPath) {
+    return {
+      tsConfigPath: undefined,
+      baseUrl: undefined,
+      paths: undefined,
+    };
+  }
+  const config = loadTsconfig(configPath);
+
+  return {
+    tsConfigPath: configPath,
+    baseUrl:
+      baseUrl ||
+      (config && config.compilerOptions && config.compilerOptions.baseUrl),
+    paths: config && config.compilerOptions && config.compilerOptions.paths,
+  };
+}
+
+function resolveConfigPath(cwd: string, filename?: string): string | undefined {
+  if (filename) {
+    const absolutePath = fs.lstatSync(filename).isDirectory()
+      ? path.resolve(filename, "./tsconfig.json")
+      : path.resolve(cwd, filename);
+
+    return absolutePath;
+  }
+
+  if (fs.statSync(cwd).isFile()) {
+    return path.resolve(cwd);
+  }
+
+  const configAbsolutePath = walkForTsConfig(cwd);
+  return configAbsolutePath ? path.resolve(configAbsolutePath) : undefined;
+}
+export function walkForTsConfig(
+  directory: string,
+  readdirSync: (path: string) => string[] = fs.readdirSync
+): string | undefined {
+  const files = readdirSync(directory);
+  const filesToCheck = ["tsconfig.json", "jsconfig.json"];
+  for (const fileToCheck of filesToCheck) {
+    if (files.indexOf(fileToCheck) !== -1) {
+      return path.join(directory, fileToCheck);
+    }
+  }
+
+  const parentDirectory = path.dirname(directory);
+
+  // If we reached the top
+  if (directory === parentDirectory) {
+    return undefined;
+  }
+
+  return walkForTsConfig(parentDirectory, readdirSync);
+}
+
+export function loadTsconfig(
+  configFilePath: string,
+  // eslint-disable-next-line no-shadow
+  existsSync: (path: string) => boolean = fs.existsSync,
+  readFileSync: (filename: string) => string = (filename: string) =>
+    fs.readFileSync(filename, "utf8")
+): Tsconfig | undefined {
+  if (!existsSync(configFilePath)) {
+    return undefined;
+  }
+
+  const configString = readFileSync(configFilePath);
+  const cleanedJson = StripBom(configString);
+  let config: Tsconfig;
+  try {
+    config = JSON5.parse(cleanedJson);
+  } catch (e) {
+    throw new Error(`${configFilePath} is malformed ${e.message}`);
+  }
+
+  let extendedConfig = config.extends;
+  if (extendedConfig) {
+    let base: Tsconfig;
+
+    if (Array.isArray(extendedConfig)) {
+      base = extendedConfig.reduce(
+        (currBase, extendedConfigElement) =>
+          mergeTsconfigs(
+            currBase,
+            loadTsconfigFromExtends(
+              configFilePath,
+              extendedConfigElement,
+              existsSync,
+              readFileSync
+            )
+          ),
+        {}
+      );
+    } else {
+      base = loadTsconfigFromExtends(
+        configFilePath,
+        extendedConfig,
+        existsSync,
+        readFileSync
+      );
+    }
+
+    return mergeTsconfigs(base, config);
+  }
+  return config;
+}
+
+/**
+ * Intended to be called only from loadTsconfig.
+ * Parameters don't have defaults because they should use the same as loadTsconfig.
+ */
+function loadTsconfigFromExtends(
+  configFilePath: string,
+  extendedConfigValue: string,
+  // eslint-disable-next-line no-shadow
+  existsSync: (path: string) => boolean,
+  readFileSync: (filename: string) => string
+): Tsconfig {
+  if (
+    typeof extendedConfigValue === "string" &&
+    extendedConfigValue.indexOf(".json") === -1
+  ) {
+    extendedConfigValue += ".json";
+  }
+  const currentDir = path.dirname(configFilePath);
+  let extendedConfigPath = path.join(currentDir, extendedConfigValue);
+  if (
+    extendedConfigValue.indexOf("/") !== -1 &&
+    extendedConfigValue.indexOf(".") !== -1 &&
+    !existsSync(extendedConfigPath)
+  ) {
+    extendedConfigPath = path.join(
+      currentDir,
+      "node_modules",
+      extendedConfigValue
+    );
+  }
+
+  const config =
+    loadTsconfig(extendedConfigPath, existsSync, readFileSync) || {};
+
+  // baseUrl should be interpreted as relative to extendedConfigPath,
+  // but we need to update it so it is relative to the original tsconfig being loaded
+  if (config.compilerOptions?.baseUrl) {
+    const extendsDir = path.dirname(extendedConfigValue);
+    config.compilerOptions.baseUrl = path.join(
+      extendsDir,
+      config.compilerOptions.baseUrl
+    );
+  }
+
+  return config;
+}
+
+function mergeTsconfigs(
+  base: Tsconfig | undefined,
+  config: Tsconfig | undefined
+): Tsconfig {
+  base = base || {};
+  config = config || {};
+
+  return {
+    ...base,
+    ...config,
+    compilerOptions: {
+      ...base.compilerOptions,
+      ...config.compilerOptions,
+    },
+  };
+}