claude-autopm 2.12.2 → 3.0.0

package/packages/plugin-devops/node_modules/jest-util/build/clearLine.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = clearLine;
+/**
+ * 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.
+ */
+
+function clearLine(stream) {
+  if (stream.isTTY) {
+    stream.write('\x1b[999D\x1b[K');
+  }
+}

package/packages/plugin-devops/node_modules/jest-util/build/convertDescriptorToString.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = convertDescriptorToString;
+/**
+ * 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.
+ */
+
+function convertDescriptorToString(descriptor) {
+  switch (typeof descriptor) {
+    case 'function':
+      if (descriptor.name) {
+        return descriptor.name;
+      }
+      break;
+    case 'number':
+    case 'undefined':
+      return `${descriptor}`;
+    case 'string':
+      return descriptor;
+  }
+  throw new Error(
+    `Invalid first argument, ${descriptor}. It must be a named class, named function, number, or string.`
+  );
+}

package/packages/plugin-devops/node_modules/jest-util/build/createDirectory.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = createDirectory;
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+  fs = function () {
+    return data;
+  };
+  return data;
+}
+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.
+ */
+
+function createDirectory(path) {
+  try {
+    fs().mkdirSync(path, {
+      recursive: true
+    });
+  } catch (e) {
+    if (e.code !== 'EEXIST') {
+      throw e;
+    }
+  }
+}

package/packages/plugin-devops/node_modules/jest-util/build/createProcessObject.js

@@ -0,0 +1,109 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = createProcessObject;
+var _deepCyclicCopy = _interopRequireDefault(require('./deepCyclicCopy'));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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 BLACKLIST = new Set(['env', 'mainModule', '_events']);
+const isWin32 = process.platform === 'win32';
+const proto = Object.getPrototypeOf(process.env);
+
+// The "process.env" object has a bunch of particularities: first, it does not
+// directly extend from Object; second, it converts any assigned value to a
+// string; and third, it is case-insensitive in Windows. We use a proxy here to
+// mimic it (see https://nodejs.org/api/process.html#process_process_env).
+
+function createProcessEnv() {
+  const real = Object.create(proto);
+  const lookup = {};
+  function deletePropertyWin32(_target, key) {
+    for (const name in real) {
+      if (Object.prototype.hasOwnProperty.call(real, name)) {
+        if (typeof key === 'string') {
+          if (name.toLowerCase() === key.toLowerCase()) {
+            delete real[name];
+            delete lookup[name.toLowerCase()];
+          }
+        } else {
+          if (key === name) {
+            delete real[name];
+            delete lookup[name];
+          }
+        }
+      }
+    }
+    return true;
+  }
+  function deleteProperty(_target, key) {
+    delete real[key];
+    delete lookup[key];
+    return true;
+  }
+  function getProperty(_target, key) {
+    return real[key];
+  }
+  function getPropertyWin32(_target, key) {
+    if (typeof key === 'string') {
+      return lookup[key in proto ? key : key.toLowerCase()];
+    } else {
+      return real[key];
+    }
+  }
+  const proxy = new Proxy(real, {
+    deleteProperty: isWin32 ? deletePropertyWin32 : deleteProperty,
+    get: isWin32 ? getPropertyWin32 : getProperty,
+    set(_target, key, value) {
+      const strValue = `${value}`;
+      if (typeof key === 'string') {
+        lookup[key.toLowerCase()] = strValue;
+      }
+      real[key] = strValue;
+      return true;
+    }
+  });
+  return Object.assign(proxy, process.env);
+}
+function createProcessObject() {
+  const process = require('process');
+  const newProcess = (0, _deepCyclicCopy.default)(process, {
+    blacklist: BLACKLIST,
+    keepPrototype: true
+  });
+  try {
+    // This fails on Node 12, but it's already set to 'process'
+    newProcess[Symbol.toStringTag] = 'process';
+  } catch (e) {
+    // Make sure it's actually set instead of potentially ignoring errors
+    if (newProcess[Symbol.toStringTag] !== 'process') {
+      e.message = `Unable to set toStringTag on process. Please open up an issue at https://github.com/jestjs/jest\n\n${e.message}`;
+      throw e;
+    }
+  }
+
+  // Sequentially execute all constructors over the object.
+  let proto = process;
+  while ((proto = Object.getPrototypeOf(proto))) {
+    if (typeof proto.constructor === 'function') {
+      proto.constructor.call(newProcess);
+    }
+  }
+  newProcess.env = createProcessEnv();
+  newProcess.send = () => true;
+  Object.defineProperty(newProcess, 'domain', {
+    get() {
+      return process.domain;
+    }
+  });
+  return newProcess;
+}

package/packages/plugin-devops/node_modules/jest-util/build/deepCyclicCopy.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = deepCyclicCopy;
+/**
+ * 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 EMPTY = new Set();
+function deepCyclicCopy(
+  value,
+  options = {
+    blacklist: EMPTY,
+    keepPrototype: false
+  },
+  cycles = new WeakMap()
+) {
+  if (typeof value !== 'object' || value === null || Buffer.isBuffer(value)) {
+    return value;
+  } else if (cycles.has(value)) {
+    return cycles.get(value);
+  } else if (Array.isArray(value)) {
+    return deepCyclicCopyArray(value, options, cycles);
+  } else {
+    return deepCyclicCopyObject(value, options, cycles);
+  }
+}
+function deepCyclicCopyObject(object, options, cycles) {
+  const newObject = options.keepPrototype
+    ? Object.create(Object.getPrototypeOf(object))
+    : {};
+  const descriptors = Object.getOwnPropertyDescriptors(object);
+  cycles.set(object, newObject);
+  Object.keys(descriptors).forEach(key => {
+    if (options.blacklist && options.blacklist.has(key)) {
+      delete descriptors[key];
+      return;
+    }
+    const descriptor = descriptors[key];
+    if (typeof descriptor.value !== 'undefined') {
+      descriptor.value = deepCyclicCopy(
+        descriptor.value,
+        {
+          blacklist: EMPTY,
+          keepPrototype: options.keepPrototype
+        },
+        cycles
+      );
+    }
+    descriptor.configurable = true;
+  });
+  return Object.defineProperties(newObject, descriptors);
+}
+function deepCyclicCopyArray(array, options, cycles) {
+  const newArray = options.keepPrototype
+    ? new (Object.getPrototypeOf(array).constructor)(array.length)
+    : [];
+  const length = array.length;
+  cycles.set(array, newArray);
+  for (let i = 0; i < length; i++) {
+    newArray[i] = deepCyclicCopy(
+      array[i],
+      {
+        blacklist: EMPTY,
+        keepPrototype: options.keepPrototype
+      },
+      cycles
+    );
+  }
+  return newArray;
+}

package/packages/plugin-devops/node_modules/jest-util/build/formatTime.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = formatTime;
+/**
+ * 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.
+ */
+
+function formatTime(time, prefixPower = -3, padLeftLength = 0) {
+  const prefixes = ['n', 'μ', 'm', ''];
+  const prefixIndex = Math.max(
+    0,
+    Math.min(
+      Math.trunc(prefixPower / 3) + prefixes.length - 1,
+      prefixes.length - 1
+    )
+  );
+  return `${String(time).padStart(padLeftLength)} ${prefixes[prefixIndex]}s`;
+}

package/packages/plugin-devops/node_modules/jest-util/build/globsToMatcher.js

@@ -0,0 +1,98 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = globsToMatcher;
+function _picomatch() {
+  const data = _interopRequireDefault(require('picomatch'));
+  _picomatch = function () {
+    return data;
+  };
+  return data;
+}
+var _replacePathSepForGlob = _interopRequireDefault(
+  require('./replacePathSepForGlob')
+);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+/**
+ * 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 globsToMatchersMap = new Map();
+const picomatchOptions = {
+  dot: true
+};
+
+/**
+ * Converts a list of globs into a function that matches a path against the
+ * globs.
+ *
+ * Every time picomatch is called, it will parse the glob strings and turn
+ * them into regexp instances. Instead of calling picomatch repeatedly with
+ * the same globs, we can use this function which will build the picomatch
+ * matchers ahead of time and then have an optimized path for determining
+ * whether an individual path matches.
+ *
+ * This function is intended to match the behavior of `micromatch()`.
+ *
+ * @example
+ * const isMatch = globsToMatcher(['*.js', '!*.test.js']);
+ * isMatch('pizza.js'); // true
+ * isMatch('pizza.test.js'); // false
+ */
+function globsToMatcher(globs) {
+  if (globs.length === 0) {
+    // Since there were no globs given, we can simply have a fast path here and
+    // return with a very simple function.
+    return () => false;
+  }
+  const matchers = globs.map(glob => {
+    if (!globsToMatchersMap.has(glob)) {
+      const isMatch = (0, _picomatch().default)(glob, picomatchOptions, true);
+      const matcher = {
+        isMatch,
+        // Matchers that are negated have different behavior than matchers that
+        // are not negated, so we need to store this information ahead of time.
+        negated: isMatch.state.negated || !!isMatch.state.negatedExtglob
+      };
+      globsToMatchersMap.set(glob, matcher);
+    }
+    return globsToMatchersMap.get(glob);
+  });
+  return path => {
+    const replacedPath = (0, _replacePathSepForGlob.default)(path);
+    let kept = undefined;
+    let negatives = 0;
+    for (let i = 0; i < matchers.length; i++) {
+      const {isMatch, negated} = matchers[i];
+      if (negated) {
+        negatives++;
+      }
+      const matched = isMatch(replacedPath);
+      if (!matched && negated) {
+        // The path was not matched, and the matcher is a negated matcher, so we
+        // want to omit the path. This means that the negative matcher is
+        // filtering the path out.
+        kept = false;
+      } else if (matched && !negated) {
+        // The path was matched, and the matcher is not a negated matcher, so we
+        // want to keep the path.
+        kept = true;
+      }
+    }
+
+    // If all of the globs were negative globs, then we want to include the path
+    // as long as it was not explicitly not kept. Otherwise only include
+    // the path if it was kept. This allows sets of globs that are all negated
+    // to allow some paths to be matched, while sets of globs that are mixed
+    // negated and non-negated to cause the negated matchers to only omit paths
+    // and not keep them.
+    return negatives === matchers.length ? kept !== false : !!kept;
+  };
+}

package/packages/plugin-devops/node_modules/jest-util/build/index.d.ts

@@ -0,0 +1,136 @@
+/**
+ * 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.
+ */
+/// <reference types="node" />
+
+import type {Config} from '@jest/types';
+import type {Global} from '@jest/types';
+
+declare const ARROW = ' \u203A ';
+
+declare const CLEAR: string;
+
+export declare function clearLine(stream: NodeJS.WriteStream): void;
+
+export declare function convertDescriptorToString(
+  descriptor: Global.BlockNameLike | undefined,
+): string;
+
+export declare function createDirectory(path: string): void;
+
+export declare function deepCyclicCopy<T>(
+  value: T,
+  options?: DeepCyclicCopyOptions,
+  cycles?: WeakMap<any, any>,
+): T;
+
+declare type DeepCyclicCopyOptions = {
+  blacklist?: Set<string>;
+  keepPrototype?: boolean;
+};
+
+export declare class ErrorWithStack extends Error {
+  constructor(
+    message: string | undefined,
+    callsite: (...args: Array<any>) => unknown,
+    stackLimit?: number,
+  );
+}
+
+export declare function formatTime(
+  time: number,
+  prefixPower?: number,
+  padLeftLength?: number,
+): string;
+
+/**
+ * Converts a list of globs into a function that matches a path against the
+ * globs.
+ *
+ * Every time picomatch is called, it will parse the glob strings and turn
+ * them into regexp instances. Instead of calling picomatch repeatedly with
+ * the same globs, we can use this function which will build the picomatch
+ * matchers ahead of time and then have an optimized path for determining
+ * whether an individual path matches.
+ *
+ * This function is intended to match the behavior of `micromatch()`.
+ *
+ * @example
+ * const isMatch = globsToMatcher(['*.js', '!*.test.js']);
+ * isMatch('pizza.js'); // true
+ * isMatch('pizza.test.js'); // false
+ */
+export declare function globsToMatcher(globs: Array<string>): Matcher;
+
+declare const ICONS: {
+  failed: string;
+  pending: string;
+  success: string;
+  todo: string;
+};
+
+export declare function installCommonGlobals(
+  globalObject: typeof globalThis,
+  globals: Config.ConfigGlobals,
+): typeof globalThis & Config.ConfigGlobals;
+
+export declare function interopRequireDefault(obj: any): any;
+
+export declare function invariant(
+  condition: unknown,
+  message?: string,
+): asserts condition;
+
+export declare const isInteractive: boolean;
+
+export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
+
+export declare function isPromise<T = unknown>(
+  candidate: unknown,
+): candidate is PromiseLike<T>;
+
+declare type Matcher = (str: string) => boolean;
+
+export declare function pluralize(
+  word: string,
+  count: number,
+  ending?: string,
+): string;
+
+declare namespace preRunMessage {
+  export {print_2 as print, remove};
+}
+export {preRunMessage};
+
+declare function print_2(stream: NodeJS.WriteStream): void;
+
+declare function remove(stream: NodeJS.WriteStream): void;
+
+export declare function replacePathSepForGlob(path: string): string;
+
+export declare function requireOrImportModule<T>(
+  filePath: string,
+  applyInteropRequireDefault?: boolean,
+): Promise<T>;
+
+export declare function setGlobal(
+  globalToMutate: typeof globalThis | Global.Global,
+  key: string,
+  value: unknown,
+): void;
+
+declare namespace specialChars {
+  export {ARROW, ICONS, CLEAR};
+}
+export {specialChars};
+
+export declare function testPathPatternToRegExp(
+  testPathPattern: Config.GlobalConfig['testPathPattern'],
+): RegExp;
+
+export declare function tryRealpath(path: string): string;
+
+export {};