repoburg 1.0.58 → 1.0.60

package/backend/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);
+  }
+}

package/backend/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;
+}

package/backend/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;
+  };
+}

package/backend/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);
+}