Change endpoint from persons to people

backend/apis/nodejs/node_modules/jest-runtime/build/helpers.js

@@ -0,0 +1,134 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.findSiblingsWithFileExtension =
+  exports.decodePossibleOutsideJestVmPath =
+  exports.createOutsideJestVmPath =
+    void 0;
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+  path = function () {
+    return data;
+  };
+  return data;
+}
+function _glob() {
+  const data = _interopRequireDefault(require('glob'));
+  _glob = function () {
+    return data;
+  };
+  return data;
+}
+function _slash() {
+  const data = _interopRequireDefault(require('slash'));
+  _slash = function () {
+    return data;
+  };
+  return data;
+}
+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;
+}
+/**
+ * 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.
+ */
+
+const OUTSIDE_JEST_VM_PROTOCOL = 'jest-main:';
+// String manipulation is easier here, fileURLToPath is only in newer Nodes,
+// plus setting non-standard protocols on URL objects is difficult.
+const createOutsideJestVmPath = path =>
+  `${OUTSIDE_JEST_VM_PROTOCOL}//${encodeURIComponent(path)}`;
+exports.createOutsideJestVmPath = createOutsideJestVmPath;
+const decodePossibleOutsideJestVmPath = outsideJestVmPath => {
+  if (outsideJestVmPath.startsWith(OUTSIDE_JEST_VM_PROTOCOL)) {
+    return decodeURIComponent(
+      outsideJestVmPath.replace(
+        new RegExp(`^${OUTSIDE_JEST_VM_PROTOCOL}//`),
+        ''
+      )
+    );
+  }
+  return undefined;
+};
+exports.decodePossibleOutsideJestVmPath = decodePossibleOutsideJestVmPath;
+const findSiblingsWithFileExtension = (
+  moduleFileExtensions,
+  from,
+  moduleName
+) => {
+  if (!path().isAbsolute(moduleName) && path().extname(moduleName) === '') {
+    const dirname = path().dirname(from);
+    const pathToModule = path().resolve(dirname, moduleName);
+    try {
+      const slashedDirname = (0, _slash().default)(dirname);
+      const matches = _glob()
+        .default.sync(`${pathToModule}.*`)
+        .map(match => (0, _slash().default)(match))
+        .map(match => {
+          const relativePath = path().posix.relative(slashedDirname, match);
+          return path().posix.dirname(match) === slashedDirname
+            ? `./${relativePath}`
+            : relativePath;
+        })
+        .map(match => `\t'${match}'`)
+        .join('\n');
+      if (matches) {
+        const foundMessage = `\n\nHowever, Jest was able to find:\n${matches}`;
+        const mappedModuleFileExtensions = moduleFileExtensions
+          .map(ext => `'${ext}'`)
+          .join(', ');
+        return (
+          `${foundMessage}\n\nYou might want to include a file extension in your import, or update your 'moduleFileExtensions', which is currently ` +
+          `[${mappedModuleFileExtensions}].\n\nSee https://jestjs.io/docs/configuration#modulefileextensions-arraystring`
+        );
+      }
+    } catch {}
+  }
+  return '';
+};
+exports.findSiblingsWithFileExtension = findSiblingsWithFileExtension;

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

@@ -0,0 +1,193 @@
+/**
+ * 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 {CallerTransformOptions} from '@jest/transform';
+import type {Config} from '@jest/types';
+import type {expect} from '@jest/globals';
+import type {Global} from '@jest/types';
+import {IHasteMap} from 'jest-haste-map';
+import {IModuleMap} from 'jest-haste-map';
+import type {JestEnvironment} from '@jest/environment';
+import Resolver from 'jest-resolve';
+import {ScriptTransformer} from '@jest/transform';
+import {shouldInstrument} from '@jest/transform';
+import {ShouldInstrumentOptions} from '@jest/transform';
+import type {SourceMapRegistry} from '@jest/source-map';
+import type {TestContext} from '@jest/test-result';
+import type {V8CoverageResult} from '@jest/test-result';
+
+declare type HasteMapOptions = {
+  console?: Console;
+  maxWorkers: number;
+  resetCache: boolean;
+  watch?: boolean;
+  watchman: boolean;
+  workerThreads?: boolean;
+};
+
+declare interface InternalModuleOptions
+  extends Required<CallerTransformOptions> {
+  isInternalModule: boolean;
+}
+
+declare interface JestGlobals extends Global.TestFrameworkGlobals {
+  expect: typeof expect;
+}
+
+declare class Runtime {
+  private readonly _cacheFS;
+  private readonly _cacheFSBuffer;
+  private readonly _config;
+  private readonly _globalConfig?;
+  private readonly _coverageOptions;
+  private _currentlyExecutingModulePath;
+  private readonly _environment;
+  private readonly _explicitShouldMock;
+  private readonly _explicitShouldMockModule;
+  private _fakeTimersImplementation;
+  private readonly _internalModuleRegistry;
+  private _isCurrentlyExecutingManualMock;
+  private _mainModule;
+  private readonly _mockFactories;
+  private readonly _mockMetaDataCache;
+  private _mockRegistry;
+  private _isolatedMockRegistry;
+  private readonly _moduleMockRegistry;
+  private readonly _moduleMockFactories;
+  private readonly _moduleMocker;
+  private _isolatedModuleRegistry;
+  private _moduleRegistry;
+  private readonly _esmoduleRegistry;
+  private readonly _cjsNamedExports;
+  private readonly _esmModuleLinkingMap;
+  private readonly _testPath;
+  private readonly _resolver;
+  private _shouldAutoMock;
+  private readonly _shouldMockModuleCache;
+  private readonly _shouldUnmockTransitiveDependenciesCache;
+  private readonly _sourceMapRegistry;
+  private readonly _scriptTransformer;
+  private readonly _fileTransforms;
+  private readonly _fileTransformsMutex;
+  private _v8CoverageInstrumenter;
+  private _v8CoverageResult;
+  private _v8CoverageSources;
+  private readonly _transitiveShouldMock;
+  private _unmockList;
+  private readonly _virtualMocks;
+  private readonly _virtualModuleMocks;
+  private _moduleImplementation?;
+  private readonly jestObjectCaches;
+  private jestGlobals?;
+  private readonly esmConditions;
+  private readonly cjsConditions;
+  private isTornDown;
+  constructor(
+    config: Config.ProjectConfig,
+    environment: JestEnvironment,
+    resolver: Resolver,
+    transformer: ScriptTransformer,
+    cacheFS: Map<string, string>,
+    coverageOptions: ShouldInstrumentOptions,
+    testPath: string,
+    globalConfig?: Config.GlobalConfig,
+  );
+  static shouldInstrument: typeof shouldInstrument;
+  static createContext(
+    config: Config.ProjectConfig,
+    options: {
+      console?: Console;
+      maxWorkers: number;
+      watch?: boolean;
+      watchman: boolean;
+    },
+  ): Promise<TestContext>;
+  static createHasteMap(
+    config: Config.ProjectConfig,
+    options?: HasteMapOptions,
+  ): Promise<IHasteMap>;
+  static createResolver(
+    config: Config.ProjectConfig,
+    moduleMap: IModuleMap,
+  ): Resolver;
+  static runCLI(): Promise<never>;
+  static getCLIOptions(): never;
+  unstable_shouldLoadAsEsm(modulePath: string): boolean;
+  private loadEsmModule;
+  private resolveModule;
+  private linkAndEvaluateModule;
+  unstable_importModule(
+    from: string,
+    moduleName?: string,
+  ): Promise<unknown | void>;
+  private loadCjsAsEsm;
+  private importMock;
+  private getExportsOfCjs;
+  requireModule<T = unknown>(
+    from: string,
+    moduleName?: string,
+    options?: InternalModuleOptions,
+    isRequireActual?: boolean,
+  ): T;
+  requireInternalModule<T = unknown>(from: string, to?: string): T;
+  requireActual<T = unknown>(from: string, moduleName: string): T;
+  requireMock<T = unknown>(from: string, moduleName: string): T;
+  private _loadModule;
+  private _getFullTransformationOptions;
+  requireModuleOrMock<T = unknown>(from: string, moduleName: string): T;
+  isolateModules(fn: () => void): void;
+  isolateModulesAsync(fn: () => Promise<void>): Promise<void>;
+  resetModules(): void;
+  collectV8Coverage(): Promise<void>;
+  stopCollectingV8Coverage(): Promise<void>;
+  getAllCoverageInfoCopy(): JestEnvironment['global']['__coverage__'];
+  getAllV8CoverageInfoCopy(): V8CoverageResult;
+  getSourceMaps(): SourceMapRegistry;
+  setMock(
+    from: string,
+    moduleName: string,
+    mockFactory: () => unknown,
+    options?: {
+      virtual?: boolean;
+    },
+  ): void;
+  private setModuleMock;
+  restoreAllMocks(): void;
+  resetAllMocks(): void;
+  clearAllMocks(): void;
+  teardown(): void;
+  private _resolveCjsModule;
+  private _resolveModule;
+  private _requireResolve;
+  private _requireResolvePaths;
+  private _execModule;
+  private transformFile;
+  private transformFileAsync;
+  private createScriptFromCode;
+  private _requireCoreModule;
+  private _importCoreModule;
+  private _importWasmModule;
+  private _getMockedNativeModule;
+  private _generateMock;
+  private _shouldMockCjs;
+  private _shouldMockModule;
+  private _createRequireImplementation;
+  private _createJestObjectFor;
+  private _logFormattedReferenceError;
+  private wrapCodeInModuleWrapper;
+  private constructModuleWrapperStart;
+  private constructInjectedModuleParameters;
+  private handleExecutionError;
+  private getGlobalsForCjs;
+  private getGlobalsForEsm;
+  private getGlobalsFromEnvironment;
+  private readFileBuffer;
+  private readFile;
+  setGlobalsForRuntime(globals: JestGlobals): void;
+}
+export default Runtime;
+
+export {};