claude-autopm 2.12.3 → 3.0.1

package/packages/plugin-cloud/node_modules/jest-runtime/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "jest-runtime",
+  "version": "29.7.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jestjs/jest.git",
+    "directory": "packages/jest-runtime"
+  },
+  "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": {
+    "@jest/environment": "^29.7.0",
+    "@jest/fake-timers": "^29.7.0",
+    "@jest/globals": "^29.7.0",
+    "@jest/source-map": "^29.6.3",
+    "@jest/test-result": "^29.7.0",
+    "@jest/transform": "^29.7.0",
+    "@jest/types": "^29.6.3",
+    "@types/node": "*",
+    "chalk": "^4.0.0",
+    "cjs-module-lexer": "^1.0.0",
+    "collect-v8-coverage": "^1.0.0",
+    "glob": "^7.1.3",
+    "graceful-fs": "^4.2.9",
+    "jest-haste-map": "^29.7.0",
+    "jest-message-util": "^29.7.0",
+    "jest-mock": "^29.7.0",
+    "jest-regex-util": "^29.6.3",
+    "jest-resolve": "^29.7.0",
+    "jest-snapshot": "^29.7.0",
+    "jest-util": "^29.7.0",
+    "slash": "^3.0.0",
+    "strip-bom": "^4.0.0"
+  },
+  "devDependencies": {
+    "@jest/test-utils": "^29.7.0",
+    "@types/glob": "^7.1.1",
+    "@types/graceful-fs": "^4.1.3",
+    "jest-environment-node": "^29.7.0"
+  },
+  "engines": {
+    "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630"
+}

package/packages/plugin-cloud/node_modules/jest-snapshot/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.

package/packages/plugin-cloud/node_modules/jest-snapshot/build/InlineSnapshots.js

@@ -0,0 +1,421 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.saveInlineSnapshots = saveInlineSnapshots;
+var path = _interopRequireWildcard(require('path'));
+var _util = require('util');
+var fs = _interopRequireWildcard(require('graceful-fs'));
+var _semver = _interopRequireDefault(require('semver'));
+var _utils = require('./utils');
+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 jestWriteFile =
+  globalThis[Symbol.for('jest-native-write-file')] || fs.writeFileSync;
+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.
+ */
+// prettier-ignore
+const generate = // @ts-expect-error requireOutside Babel transform
+require(require.resolve('@babel/generator', {
+  [(globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol).for('jest-resolve-outside-vm-option')]: true
+})).default;
+const {
+  isAwaitExpression,
+  templateElement,
+  templateLiteral,
+  traverse,
+  traverseFast
+} = require(require.resolve('@babel/types', { // @ts-expect-error requireOutside Babel transform
+  [(globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol).for(
+    'jest-resolve-outside-vm-option'
+  )]: true
+}));
+// @ts-expect-error requireOutside Babel transform
+const {parseSync} = require(require.resolve('@babel/core', {
+  [(globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol).for(
+    'jest-resolve-outside-vm-option'
+  )]: true
+}));
+function saveInlineSnapshots(snapshots, rootDir, prettierPath) {
+  let prettier = null;
+  if (prettierPath) {
+    try {
+      // @ts-expect-error requireOutside Babel transform
+      prettier = require(require.resolve(prettierPath, {
+        [(globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol).for(
+          'jest-resolve-outside-vm-option'
+        )]: true
+      }));
+      if (_semver.default.gte(prettier.version, '3.0.0')) {
+        throw new Error(
+          'Jest: Inline Snapshots are not supported when using Prettier 3.0.0 or above.\nSee https://jestjs.io/docs/configuration/#prettierpath-string for alternatives.'
+        );
+      }
+    } catch (error) {
+      if (!_util.types.isNativeError(error)) {
+        throw error;
+      }
+      if (error.code !== 'MODULE_NOT_FOUND') {
+        throw error;
+      }
+    }
+  }
+  const snapshotsByFile = groupSnapshotsByFile(snapshots);
+  for (const sourceFilePath of Object.keys(snapshotsByFile)) {
+    saveSnapshotsForFile(
+      snapshotsByFile[sourceFilePath],
+      sourceFilePath,
+      rootDir,
+      prettier && _semver.default.gte(prettier.version, '1.5.0')
+        ? prettier
+        : undefined
+    );
+  }
+}
+const saveSnapshotsForFile = (snapshots, sourceFilePath, rootDir, prettier) => {
+  const sourceFile = jestReadFile(sourceFilePath, 'utf8');
+
+  // TypeScript projects may not have a babel config; make sure they can be parsed anyway.
+  const presets = [require.resolve('babel-preset-current-node-syntax')];
+  const plugins = [];
+  if (/\.([cm]?ts|tsx)$/.test(sourceFilePath)) {
+    plugins.push([
+      require.resolve('@babel/plugin-syntax-typescript'),
+      {
+        isTSX: sourceFilePath.endsWith('x')
+      },
+      // unique name to make sure Babel does not complain about a possible duplicate plugin.
+      'TypeScript syntax plugin added by Jest snapshot'
+    ]);
+  }
+
+  // Record the matcher names seen during traversal and pass them down one
+  // by one to formatting parser.
+  const snapshotMatcherNames = [];
+  let ast = null;
+  try {
+    ast = parseSync(sourceFile, {
+      filename: sourceFilePath,
+      plugins,
+      presets,
+      root: rootDir
+    });
+  } catch (error) {
+    // attempt to recover from missing jsx plugin
+    if (error.message.includes('@babel/plugin-syntax-jsx')) {
+      try {
+        const jsxSyntaxPlugin = [
+          require.resolve('@babel/plugin-syntax-jsx'),
+          {},
+          // unique name to make sure Babel does not complain about a possible duplicate plugin.
+          'JSX syntax plugin added by Jest snapshot'
+        ];
+        ast = parseSync(sourceFile, {
+          filename: sourceFilePath,
+          plugins: [...plugins, jsxSyntaxPlugin],
+          presets,
+          root: rootDir
+        });
+      } catch {
+        throw error;
+      }
+    } else {
+      throw error;
+    }
+  }
+  if (!ast) {
+    throw new Error(`jest-snapshot: Failed to parse ${sourceFilePath}`);
+  }
+  traverseAst(snapshots, ast, snapshotMatcherNames);
+
+  // substitute in the snapshots in reverse order, so slice calculations aren't thrown off.
+  const sourceFileWithSnapshots = snapshots.reduceRight(
+    (sourceSoFar, nextSnapshot) => {
+      const {node} = nextSnapshot;
+      if (
+        !node ||
+        typeof node.start !== 'number' ||
+        typeof node.end !== 'number'
+      ) {
+        throw new Error('Jest: no snapshot insert location found');
+      }
+
+      // A hack to prevent unexpected line breaks in the generated code
+      node.loc.end.line = node.loc.start.line;
+      return (
+        sourceSoFar.slice(0, node.start) +
+        generate(node, {
+          retainLines: true
+        }).code.trim() +
+        sourceSoFar.slice(node.end)
+      );
+    },
+    sourceFile
+  );
+  const newSourceFile = prettier
+    ? runPrettier(
+        prettier,
+        sourceFilePath,
+        sourceFileWithSnapshots,
+        snapshotMatcherNames
+      )
+    : sourceFileWithSnapshots;
+  if (newSourceFile !== sourceFile) {
+    jestWriteFile(sourceFilePath, newSourceFile);
+  }
+};
+const groupSnapshotsBy = createKey => snapshots =>
+  snapshots.reduce((object, inlineSnapshot) => {
+    const key = createKey(inlineSnapshot);
+    return {
+      ...object,
+      [key]: (object[key] || []).concat(inlineSnapshot)
+    };
+  }, {});
+const groupSnapshotsByFrame = groupSnapshotsBy(({frame: {line, column}}) =>
+  typeof line === 'number' && typeof column === 'number'
+    ? `${line}:${column - 1}`
+    : ''
+);
+const groupSnapshotsByFile = groupSnapshotsBy(({frame: {file}}) => file);
+const indent = (snapshot, numIndents, indentation) => {
+  const lines = snapshot.split('\n');
+  // Prevent re-indentation of inline snapshots.
+  if (
+    lines.length >= 2 &&
+    lines[1].startsWith(indentation.repeat(numIndents + 1))
+  ) {
+    return snapshot;
+  }
+  return lines
+    .map((line, index) => {
+      if (index === 0) {
+        // First line is either a 1-line snapshot or a blank line.
+        return line;
+      } else if (index !== lines.length - 1) {
+        // Do not indent empty lines.
+        if (line === '') {
+          return line;
+        }
+
+        // Not last line, indent one level deeper than expect call.
+        return indentation.repeat(numIndents + 1) + line;
+      } else {
+        // The last line should be placed on the same level as the expect call.
+        return indentation.repeat(numIndents) + line;
+      }
+    })
+    .join('\n');
+};
+const traverseAst = (snapshots, ast, snapshotMatcherNames) => {
+  const groupedSnapshots = groupSnapshotsByFrame(snapshots);
+  const remainingSnapshots = new Set(snapshots.map(({snapshot}) => snapshot));
+  traverseFast(ast, node => {
+    if (node.type !== 'CallExpression') return;
+    const {arguments: args, callee} = node;
+    if (
+      callee.type !== 'MemberExpression' ||
+      callee.property.type !== 'Identifier' ||
+      callee.property.loc == null
+    ) {
+      return;
+    }
+    const {line, column} = callee.property.loc.start;
+    const snapshotsForFrame = groupedSnapshots[`${line}:${column}`];
+    if (!snapshotsForFrame) {
+      return;
+    }
+    if (snapshotsForFrame.length > 1) {
+      throw new Error(
+        'Jest: Multiple inline snapshots for the same call are not supported.'
+      );
+    }
+    const inlineSnapshot = snapshotsForFrame[0];
+    inlineSnapshot.node = node;
+    snapshotMatcherNames.push(callee.property.name);
+    const snapshotIndex = args.findIndex(
+      ({type}) => type === 'TemplateLiteral' || type === 'StringLiteral'
+    );
+    const {snapshot} = inlineSnapshot;
+    remainingSnapshots.delete(snapshot);
+    const replacementNode = templateLiteral(
+      [
+        templateElement({
+          raw: (0, _utils.escapeBacktickString)(snapshot)
+        })
+      ],
+      []
+    );
+    if (snapshotIndex > -1) {
+      args[snapshotIndex] = replacementNode;
+    } else {
+      args.push(replacementNode);
+    }
+  });
+  if (remainingSnapshots.size) {
+    throw new Error("Jest: Couldn't locate all inline snapshots.");
+  }
+};
+const runPrettier = (
+  prettier,
+  sourceFilePath,
+  sourceFileWithSnapshots,
+  snapshotMatcherNames
+) => {
+  // Resolve project configuration.
+  // For older versions of Prettier, do not load configuration.
+  const config = prettier.resolveConfig
+    ? prettier.resolveConfig.sync(sourceFilePath, {
+        editorconfig: true
+      })
+    : null;
+
+  // Prioritize parser found in the project config.
+  // If not found detect the parser for the test file.
+  // For older versions of Prettier, fallback to a simple parser detection.
+  // @ts-expect-error - `inferredParser` is `string`
+  const inferredParser =
+    (config && typeof config.parser === 'string' && config.parser) ||
+    (prettier.getFileInfo
+      ? prettier.getFileInfo.sync(sourceFilePath).inferredParser
+      : simpleDetectParser(sourceFilePath));
+  if (!inferredParser) {
+    throw new Error(
+      `Could not infer Prettier parser for file ${sourceFilePath}`
+    );
+  }
+
+  // Snapshots have now been inserted. Run prettier to make sure that the code is
+  // formatted, except snapshot indentation. Snapshots cannot be formatted until
+  // after the initial format because we don't know where the call expression
+  // will be placed (specifically its indentation), so we have to do two
+  // prettier.format calls back-to-back.
+  return prettier.format(
+    prettier.format(sourceFileWithSnapshots, {
+      ...config,
+      filepath: sourceFilePath
+    }),
+    {
+      ...config,
+      filepath: sourceFilePath,
+      parser: createFormattingParser(snapshotMatcherNames, inferredParser)
+    }
+  );
+};
+
+// This parser formats snapshots to the correct indentation.
+const createFormattingParser =
+  (snapshotMatcherNames, inferredParser) => (text, parsers, options) => {
+    // Workaround for https://github.com/prettier/prettier/issues/3150
+    options.parser = inferredParser;
+    const ast = parsers[inferredParser](text, options);
+    traverse(ast, (node, ancestors) => {
+      if (node.type !== 'CallExpression') return;
+      const {arguments: args, callee} = node;
+      if (
+        callee.type !== 'MemberExpression' ||
+        callee.property.type !== 'Identifier' ||
+        !snapshotMatcherNames.includes(callee.property.name) ||
+        !callee.loc ||
+        callee.computed
+      ) {
+        return;
+      }
+      let snapshotIndex;
+      let snapshot;
+      for (let i = 0; i < args.length; i++) {
+        const node = args[i];
+        if (node.type === 'TemplateLiteral') {
+          snapshotIndex = i;
+          snapshot = node.quasis[0].value.raw;
+        }
+      }
+      if (snapshot === undefined) {
+        return;
+      }
+      const parent = ancestors[ancestors.length - 1].node;
+      const startColumn =
+        isAwaitExpression(parent) && parent.loc
+          ? parent.loc.start.column
+          : callee.loc.start.column;
+      const useSpaces = !options.useTabs;
+      snapshot = indent(
+        snapshot,
+        Math.ceil(
+          useSpaces
+            ? startColumn / (options.tabWidth ?? 1)
+            : // Each tab is 2 characters.
+              startColumn / 2
+        ),
+        useSpaces ? ' '.repeat(options.tabWidth ?? 1) : '\t'
+      );
+      const replacementNode = templateLiteral(
+        [
+          templateElement({
+            raw: snapshot
+          })
+        ],
+        []
+      );
+      args[snapshotIndex] = replacementNode;
+    });
+    return ast;
+  };
+const simpleDetectParser = filePath => {
+  const extname = path.extname(filePath);
+  if (/\.tsx?$/.test(extname)) {
+    return 'typescript';
+  }
+  return 'babel';
+};

package/packages/plugin-cloud/node_modules/jest-snapshot/build/SnapshotResolver.js

@@ -0,0 +1,153 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.isSnapshotPath =
+  exports.buildSnapshotResolver =
+  exports.EXTENSION =
+  exports.DOT_EXTENSION =
+    void 0;
+var path = _interopRequireWildcard(require('path'));
+var _chalk = _interopRequireDefault(require('chalk'));
+var _transform = require('@jest/transform');
+var _jestUtil = require('jest-util');
+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 EXTENSION = 'snap';
+exports.EXTENSION = EXTENSION;
+const DOT_EXTENSION = `.${EXTENSION}`;
+exports.DOT_EXTENSION = DOT_EXTENSION;
+const isSnapshotPath = path => path.endsWith(DOT_EXTENSION);
+exports.isSnapshotPath = isSnapshotPath;
+const cache = new Map();
+const buildSnapshotResolver = async (
+  config,
+  localRequire = (0, _transform.createTranspilingRequire)(config)
+) => {
+  const key = config.rootDir;
+  const resolver =
+    cache.get(key) ??
+    (await createSnapshotResolver(await localRequire, config.snapshotResolver));
+  cache.set(key, resolver);
+  return resolver;
+};
+exports.buildSnapshotResolver = buildSnapshotResolver;
+async function createSnapshotResolver(localRequire, snapshotResolverPath) {
+  return typeof snapshotResolverPath === 'string'
+    ? createCustomSnapshotResolver(snapshotResolverPath, localRequire)
+    : createDefaultSnapshotResolver();
+}
+function createDefaultSnapshotResolver() {
+  return {
+    resolveSnapshotPath: testPath =>
+      path.join(
+        path.join(path.dirname(testPath), '__snapshots__'),
+        path.basename(testPath) + DOT_EXTENSION
+      ),
+    resolveTestPath: snapshotPath =>
+      path.resolve(
+        path.dirname(snapshotPath),
+        '..',
+        path.basename(snapshotPath, DOT_EXTENSION)
+      ),
+    testPathForConsistencyCheck: path.posix.join(
+      'consistency_check',
+      '__tests__',
+      'example.test.js'
+    )
+  };
+}
+async function createCustomSnapshotResolver(
+  snapshotResolverPath,
+  localRequire
+) {
+  const custom = (0, _jestUtil.interopRequireDefault)(
+    await localRequire(snapshotResolverPath)
+  ).default;
+  const keys = [
+    ['resolveSnapshotPath', 'function'],
+    ['resolveTestPath', 'function'],
+    ['testPathForConsistencyCheck', 'string']
+  ];
+  keys.forEach(([propName, requiredType]) => {
+    if (typeof custom[propName] !== requiredType) {
+      throw new TypeError(mustImplement(propName, requiredType));
+    }
+  });
+  const customResolver = {
+    resolveSnapshotPath: testPath =>
+      custom.resolveSnapshotPath(testPath, DOT_EXTENSION),
+    resolveTestPath: snapshotPath =>
+      custom.resolveTestPath(snapshotPath, DOT_EXTENSION),
+    testPathForConsistencyCheck: custom.testPathForConsistencyCheck
+  };
+  verifyConsistentTransformations(customResolver);
+  return customResolver;
+}
+function mustImplement(propName, requiredType) {
+  return `${_chalk.default.bold(
+    `Custom snapshot resolver must implement a \`${propName}\` as a ${requiredType}.`
+  )}\nDocumentation: https://jestjs.io/docs/configuration#snapshotresolver-string`;
+}
+function verifyConsistentTransformations(custom) {
+  const resolvedSnapshotPath = custom.resolveSnapshotPath(
+    custom.testPathForConsistencyCheck
+  );
+  const resolvedTestPath = custom.resolveTestPath(resolvedSnapshotPath);
+  if (resolvedTestPath !== custom.testPathForConsistencyCheck) {
+    throw new Error(
+      _chalk.default.bold(
+        `Custom snapshot resolver functions must transform paths consistently, i.e. expects resolveTestPath(resolveSnapshotPath('${custom.testPathForConsistencyCheck}')) === ${resolvedTestPath}`
+      )
+    );
+  }
+}