Change endpoint from persons to people

backend/apis/nodejs/node_modules/jest-message-util/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

backend/apis/nodejs/node_modules/jest-message-util/build/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type {Config} from '@jest/types';
+import type {StackData} from 'stack-utils';
+import type {TestResult} from '@jest/types';
+
+export declare const formatExecError: (
+  error: Error | TestResult.SerializableError | string | number | undefined,
+  config: StackTraceConfig,
+  options: StackTraceOptions,
+  testPath?: string,
+  reuseMessage?: boolean,
+  noTitle?: boolean,
+) => string;
+
+export declare const formatPath: (
+  line: string,
+  config: StackTraceConfig,
+  relativeTestPath?: string | null,
+) => string;
+
+export declare const formatResultsErrors: (
+  testResults: Array<TestResult.AssertionResult>,
+  config: StackTraceConfig,
+  options: StackTraceOptions,
+  testPath?: string,
+) => string | null;
+
+export declare const formatStackTrace: (
+  stack: string,
+  config: StackTraceConfig,
+  options: StackTraceOptions,
+  testPath?: string,
+) => string;
+
+export declare interface Frame extends StackData {
+  file: string;
+}
+
+export declare const getStackTraceLines: (
+  stack: string,
+  options?: StackTraceOptions,
+) => Array<string>;
+
+export declare const getTopFrame: (lines: Array<string>) => Frame | null;
+
+export declare const indentAllLines: (lines: string) => string;
+
+export declare const separateMessageFromStack: (content: string) => {
+  message: string;
+  stack: string;
+};
+
+export declare type StackTraceConfig = Pick<
+  Config.ProjectConfig,
+  'rootDir' | 'testMatch'
+>;
+
+export declare type StackTraceOptions = {
+  noStackTrace: boolean;
+  noCodeFrame?: boolean;
+};
+
+export {};

backend/apis/nodejs/node_modules/jest-message-util/build/index.js

@@ -0,0 +1,518 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.separateMessageFromStack =
+  exports.indentAllLines =
+  exports.getTopFrame =
+  exports.getStackTraceLines =
+  exports.formatStackTrace =
+  exports.formatResultsErrors =
+  exports.formatPath =
+  exports.formatExecError =
+    void 0;
+var path = _interopRequireWildcard(require('path'));
+var _url = require('url');
+var _util = require('util');
+var _codeFrame = require('@babel/code-frame');
+var _chalk = _interopRequireDefault(require('chalk'));
+var fs = _interopRequireWildcard(require('graceful-fs'));
+var _micromatch = _interopRequireDefault(require('micromatch'));
+var _slash = _interopRequireDefault(require('slash'));
+var _stackUtils = _interopRequireDefault(require('stack-utils'));
+var _prettyFormat = require('pretty-format');
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+var Symbol = globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol;
+var Symbol = globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol;
+var jestReadFile =
+  globalThis[Symbol.for('jest-native-read-file')] || fs.readFileSync;
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// stack utils tries to create pretty stack by making paths relative.
+const stackUtils = new _stackUtils.default({
+  cwd: 'something which does not exist'
+});
+let nodeInternals = [];
+try {
+  nodeInternals = _stackUtils.default.nodeInternals();
+} catch {
+  // `StackUtils.nodeInternals()` fails in browsers. We don't need to remove
+  // node internals in the browser though, so no issue.
+}
+const PATH_NODE_MODULES = `${path.sep}node_modules${path.sep}`;
+const PATH_JEST_PACKAGES = `${path.sep}jest${path.sep}packages${path.sep}`;
+
+// filter for noisy stack trace lines
+const JASMINE_IGNORE =
+  /^\s+at(?:(?:.jasmine-)|\s+jasmine\.buildExpectationResult)/;
+const JEST_INTERNALS_IGNORE =
+  /^\s+at.*?jest(-.*?)?(\/|\\)(build|node_modules|packages)(\/|\\)/;
+const ANONYMOUS_FN_IGNORE = /^\s+at <anonymous>.*$/;
+const ANONYMOUS_PROMISE_IGNORE = /^\s+at (new )?Promise \(<anonymous>\).*$/;
+const ANONYMOUS_GENERATOR_IGNORE = /^\s+at Generator.next \(<anonymous>\).*$/;
+const NATIVE_NEXT_IGNORE = /^\s+at next \(native\).*$/;
+const TITLE_INDENT = '  ';
+const MESSAGE_INDENT = '    ';
+const STACK_INDENT = '      ';
+const ANCESTRY_SEPARATOR = ' \u203A ';
+const TITLE_BULLET = _chalk.default.bold('\u25cf ');
+const STACK_TRACE_COLOR = _chalk.default.dim;
+const STACK_PATH_REGEXP = /\s*at.*\(?(:\d*:\d*|native)\)?/;
+const EXEC_ERROR_MESSAGE = 'Test suite failed to run';
+const NOT_EMPTY_LINE_REGEXP = /^(?!$)/gm;
+const indentAllLines = lines =>
+  lines.replace(NOT_EMPTY_LINE_REGEXP, MESSAGE_INDENT);
+exports.indentAllLines = indentAllLines;
+const trim = string => (string || '').trim();
+
+// Some errors contain not only line numbers in stack traces
+// e.g. SyntaxErrors can contain snippets of code, and we don't
+// want to trim those, because they may have pointers to the column/character
+// which will get misaligned.
+const trimPaths = string =>
+  string.match(STACK_PATH_REGEXP) ? trim(string) : string;
+const getRenderedCallsite = (fileContent, line, column) => {
+  let renderedCallsite = (0, _codeFrame.codeFrameColumns)(
+    fileContent,
+    {
+      start: {
+        column,
+        line
+      }
+    },
+    {
+      highlightCode: true
+    }
+  );
+  renderedCallsite = indentAllLines(renderedCallsite);
+  renderedCallsite = `\n${renderedCallsite}\n`;
+  return renderedCallsite;
+};
+const blankStringRegexp = /^\s*$/;
+function checkForCommonEnvironmentErrors(error) {
+  if (
+    error.includes('ReferenceError: document is not defined') ||
+    error.includes('ReferenceError: window is not defined') ||
+    error.includes('ReferenceError: navigator is not defined')
+  ) {
+    return warnAboutWrongTestEnvironment(error, 'jsdom');
+  } else if (error.includes('.unref is not a function')) {
+    return warnAboutWrongTestEnvironment(error, 'node');
+  }
+  return error;
+}
+function warnAboutWrongTestEnvironment(error, env) {
+  return (
+    _chalk.default.bold.red(
+      `The error below may be caused by using the wrong test environment, see ${_chalk.default.dim.underline(
+        'https://jestjs.io/docs/configuration#testenvironment-string'
+      )}.\nConsider using the "${env}" test environment.\n\n`
+    ) + error
+  );
+}
+
+// ExecError is an error thrown outside of the test suite (not inside an `it` or
+// `before/after each` hooks). If it's thrown, none of the tests in the file
+// are executed.
+const formatExecError = (
+  error,
+  config,
+  options,
+  testPath,
+  reuseMessage,
+  noTitle
+) => {
+  if (!error || typeof error === 'number') {
+    error = new Error(`Expected an Error, but "${String(error)}" was thrown`);
+    error.stack = '';
+  }
+  let message, stack;
+  let cause = '';
+  const subErrors = [];
+  if (typeof error === 'string' || !error) {
+    error || (error = 'EMPTY ERROR');
+    message = '';
+    stack = error;
+  } else {
+    message = error.message;
+    stack =
+      typeof error.stack === 'string'
+        ? error.stack
+        : `thrown: ${(0, _prettyFormat.format)(error, {
+            maxDepth: 3
+          })}`;
+    if ('cause' in error) {
+      const prefix = '\n\nCause:\n';
+      if (typeof error.cause === 'string' || typeof error.cause === 'number') {
+        cause += `${prefix}${error.cause}`;
+      } else if (
+        _util.types.isNativeError(error.cause) ||
+        error.cause instanceof Error
+      ) {
+        /* `isNativeError` is used, because the error might come from another realm.
+         `instanceof Error` is used because `isNativeError` does return `false` for some
+         things that are `instanceof Error` like the errors provided in
+         [verror](https://www.npmjs.com/package/verror) or [axios](https://axios-http.com).
+        */
+        const formatted = formatExecError(
+          error.cause,
+          config,
+          options,
+          testPath,
+          reuseMessage,
+          true
+        );
+        cause += `${prefix}${formatted}`;
+      }
+    }
+    if ('errors' in error && Array.isArray(error.errors)) {
+      for (const subError of error.errors) {
+        subErrors.push(
+          formatExecError(
+            subError,
+            config,
+            options,
+            testPath,
+            reuseMessage,
+            true
+          )
+        );
+      }
+    }
+  }
+  if (cause !== '') {
+    cause = indentAllLines(cause);
+  }
+  const separated = separateMessageFromStack(stack || '');
+  stack = separated.stack;
+  if (separated.message.includes(trim(message))) {
+    // Often stack trace already contains the duplicate of the message
+    message = separated.message;
+  }
+  message = checkForCommonEnvironmentErrors(message);
+  message = indentAllLines(message);
+  stack =
+    stack && !options.noStackTrace
+      ? `\n${formatStackTrace(stack, config, options, testPath)}`
+      : '';
+  if (
+    typeof stack !== 'string' ||
+    (blankStringRegexp.test(message) && blankStringRegexp.test(stack))
+  ) {
+    // this can happen if an empty object is thrown.
+    message = `thrown: ${(0, _prettyFormat.format)(error, {
+      maxDepth: 3
+    })}`;
+  }
+  let messageToUse;
+  if (reuseMessage || noTitle) {
+    messageToUse = ` ${message.trim()}`;
+  } else {
+    messageToUse = `${EXEC_ERROR_MESSAGE}\n\n${message}`;
+  }
+  const title = noTitle ? '' : `${TITLE_INDENT + TITLE_BULLET}`;
+  const subErrorStr =
+    subErrors.length > 0
+      ? indentAllLines(
+          `\n\nErrors contained in AggregateError:\n${subErrors.join('\n')}`
+        )
+      : '';
+  return `${title + messageToUse + stack + cause + subErrorStr}\n`;
+};
+exports.formatExecError = formatExecError;
+const removeInternalStackEntries = (lines, options) => {
+  let pathCounter = 0;
+  return lines.filter(line => {
+    if (ANONYMOUS_FN_IGNORE.test(line)) {
+      return false;
+    }
+    if (ANONYMOUS_PROMISE_IGNORE.test(line)) {
+      return false;
+    }
+    if (ANONYMOUS_GENERATOR_IGNORE.test(line)) {
+      return false;
+    }
+    if (NATIVE_NEXT_IGNORE.test(line)) {
+      return false;
+    }
+    if (nodeInternals.some(internal => internal.test(line))) {
+      return false;
+    }
+    if (!STACK_PATH_REGEXP.test(line)) {
+      return true;
+    }
+    if (JASMINE_IGNORE.test(line)) {
+      return false;
+    }
+    if (++pathCounter === 1) {
+      return true; // always keep the first line even if it's from Jest
+    }
+
+    if (options.noStackTrace) {
+      return false;
+    }
+    if (JEST_INTERNALS_IGNORE.test(line)) {
+      return false;
+    }
+    return true;
+  });
+};
+const formatPath = (line, config, relativeTestPath = null) => {
+  // Extract the file path from the trace line.
+  const match = line.match(/(^\s*at .*?\(?)([^()]+)(:[0-9]+:[0-9]+\)?.*$)/);
+  if (!match) {
+    return line;
+  }
+  let filePath = (0, _slash.default)(path.relative(config.rootDir, match[2]));
+  // highlight paths from the current test file
+  if (
+    (config.testMatch &&
+      config.testMatch.length &&
+      (0, _micromatch.default)([filePath], config.testMatch).length > 0) ||
+    filePath === relativeTestPath
+  ) {
+    filePath = _chalk.default.reset.cyan(filePath);
+  }
+  return STACK_TRACE_COLOR(match[1]) + filePath + STACK_TRACE_COLOR(match[3]);
+};
+exports.formatPath = formatPath;
+const getStackTraceLines = (
+  stack,
+  options = {
+    noCodeFrame: false,
+    noStackTrace: false
+  }
+) => removeInternalStackEntries(stack.split(/\n/), options);
+exports.getStackTraceLines = getStackTraceLines;
+const getTopFrame = lines => {
+  for (const line of lines) {
+    if (line.includes(PATH_NODE_MODULES) || line.includes(PATH_JEST_PACKAGES)) {
+      continue;
+    }
+    const parsedFrame = stackUtils.parseLine(line.trim());
+    if (parsedFrame && parsedFrame.file) {
+      if (parsedFrame.file.startsWith('file://')) {
+        parsedFrame.file = (0, _slash.default)(
+          (0, _url.fileURLToPath)(parsedFrame.file)
+        );
+      }
+      return parsedFrame;
+    }
+  }
+  return null;
+};
+exports.getTopFrame = getTopFrame;
+const formatStackTrace = (stack, config, options, testPath) => {
+  const lines = getStackTraceLines(stack, options);
+  let renderedCallsite = '';
+  const relativeTestPath = testPath
+    ? (0, _slash.default)(path.relative(config.rootDir, testPath))
+    : null;
+  if (!options.noStackTrace && !options.noCodeFrame) {
+    const topFrame = getTopFrame(lines);
+    if (topFrame) {
+      const {column, file: filename, line} = topFrame;
+      if (line && filename && path.isAbsolute(filename)) {
+        let fileContent;
+        try {
+          // TODO: check & read HasteFS instead of reading the filesystem:
+          // see: https://github.com/jestjs/jest/pull/5405#discussion_r164281696
+          fileContent = jestReadFile(filename, 'utf8');
+          renderedCallsite = getRenderedCallsite(fileContent, line, column);
+        } catch {
+          // the file does not exist or is inaccessible, we ignore
+        }
+      }
+    }
+  }
+  const stacktrace = lines
+    .filter(Boolean)
+    .map(
+      line =>
+        STACK_INDENT + formatPath(trimPaths(line), config, relativeTestPath)
+    )
+    .join('\n');
+  return renderedCallsite
+    ? `${renderedCallsite}\n${stacktrace}`
+    : `\n${stacktrace}`;
+};
+exports.formatStackTrace = formatStackTrace;
+function isErrorOrStackWithCause(errorOrStack) {
+  return (
+    typeof errorOrStack !== 'string' &&
+    'cause' in errorOrStack &&
+    (typeof errorOrStack.cause === 'string' ||
+      _util.types.isNativeError(errorOrStack.cause) ||
+      errorOrStack.cause instanceof Error)
+  );
+}
+function formatErrorStack(errorOrStack, config, options, testPath) {
+  // The stack of new Error('message') contains both the message and the stack,
+  // thus we need to sanitize and clean it for proper display using separateMessageFromStack.
+  const sourceStack =
+    typeof errorOrStack === 'string' ? errorOrStack : errorOrStack.stack || '';
+  let {message, stack} = separateMessageFromStack(sourceStack);
+  stack = options.noStackTrace
+    ? ''
+    : `${STACK_TRACE_COLOR(
+        formatStackTrace(stack, config, options, testPath)
+      )}\n`;
+  message = checkForCommonEnvironmentErrors(message);
+  message = indentAllLines(message);
+  let cause = '';
+  if (isErrorOrStackWithCause(errorOrStack)) {
+    const nestedCause = formatErrorStack(
+      errorOrStack.cause,
+      config,
+      options,
+      testPath
+    );
+    cause = `\n${MESSAGE_INDENT}Cause:\n${nestedCause}`;
+  }
+  return `${message}\n${stack}${cause}`;
+}
+function failureDetailsToErrorOrStack(failureDetails, content) {
+  if (!failureDetails) {
+    return content;
+  }
+  if (
+    _util.types.isNativeError(failureDetails) ||
+    failureDetails instanceof Error
+  ) {
+    return failureDetails; // receiving raw errors for jest-circus
+  }
+
+  if (
+    typeof failureDetails === 'object' &&
+    'error' in failureDetails &&
+    (_util.types.isNativeError(failureDetails.error) ||
+      failureDetails.error instanceof Error)
+  ) {
+    return failureDetails.error; // receiving instances of FailedAssertion for jest-jasmine
+  }
+
+  return content;
+}
+const formatResultsErrors = (testResults, config, options, testPath) => {
+  const failedResults = testResults.reduce((errors, result) => {
+    result.failureMessages.forEach((item, index) => {
+      errors.push({
+        content: item,
+        failureDetails: result.failureDetails[index],
+        result
+      });
+    });
+    return errors;
+  }, []);
+  if (!failedResults.length) {
+    return null;
+  }
+  return failedResults
+    .map(({result, content, failureDetails}) => {
+      const rootErrorOrStack = failureDetailsToErrorOrStack(
+        failureDetails,
+        content
+      );
+      const title = `${_chalk.default.bold.red(
+        TITLE_INDENT +
+          TITLE_BULLET +
+          result.ancestorTitles.join(ANCESTRY_SEPARATOR) +
+          (result.ancestorTitles.length ? ANCESTRY_SEPARATOR : '') +
+          result.title
+      )}\n`;
+      return `${title}\n${formatErrorStack(
+        rootErrorOrStack,
+        config,
+        options,
+        testPath
+      )}`;
+    })
+    .join('\n');
+};
+exports.formatResultsErrors = formatResultsErrors;
+const errorRegexp = /^Error:?\s*$/;
+const removeBlankErrorLine = str =>
+  str
+    .split('\n')
+    // Lines saying just `Error:` are useless
+    .filter(line => !errorRegexp.test(line))
+    .join('\n')
+    .trimRight();
+
+// jasmine and worker farm sometimes don't give us access to the actual
+// Error object, so we have to regexp out the message from the stack string
+// to format it.
+const separateMessageFromStack = content => {
+  if (!content) {
+    return {
+      message: '',
+      stack: ''
+    };
+  }
+
+  // All lines up to what looks like a stack -- or if nothing looks like a stack
+  // (maybe it's a code frame instead), just the first non-empty line.
+  // If the error is a plain "Error:" instead of a SyntaxError or TypeError we
+  // remove the prefix from the message because it is generally not useful.
+  const messageMatch = content.match(
+    /^(?:Error: )?([\s\S]*?(?=\n\s*at\s.*:\d*:\d*)|\s*.*)([\s\S]*)$/
+  );
+  if (!messageMatch) {
+    // For typescript
+    throw new Error('If you hit this error, the regex above is buggy.');
+  }
+  const message = removeBlankErrorLine(messageMatch[1]);
+  const stack = removeBlankErrorLine(messageMatch[2]);
+  return {
+    message,
+    stack
+  };
+};
+exports.separateMessageFromStack = separateMessageFromStack;

backend/apis/nodejs/node_modules/jest-message-util/build/types.js

@@ -0,0 +1 @@
+'use strict';

backend/apis/nodejs/node_modules/jest-message-util/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "jest-message-util",
+  "version": "29.7.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jestjs/jest.git",
+    "directory": "packages/jest-message-util"
+  },
+  "engines": {
+    "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+  },
+  "license": "MIT",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@babel/code-frame": "^7.12.13",
+    "@jest/types": "^29.6.3",
+    "@types/stack-utils": "^2.0.0",
+    "chalk": "^4.0.0",
+    "graceful-fs": "^4.2.9",
+    "micromatch": "^4.0.4",
+    "pretty-format": "^29.7.0",
+    "slash": "^3.0.0",
+    "stack-utils": "^2.0.3"
+  },
+  "devDependencies": {
+    "@types/babel__code-frame": "^7.0.0",
+    "@types/graceful-fs": "^4.1.3",
+    "@types/micromatch": "^4.0.1",
+    "tempy": "^1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630"
+}