repoburg 1.0.67 → 1.0.68

package/backend/node_modules/tsconfig-paths/src/match-path-async.ts

@@ -1,223 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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);
-}