@quantiya/codevibe-claude-plugin 1.0.0 → 1.0.2

package/node_modules/graphql/language/printer.mjs

@@ -0,0 +1,368 @@
+import { printBlockString } from './blockString.mjs';
+import { printString } from './printString.mjs';
+import { visit } from './visitor.mjs';
+/**
+ * Converts an AST into a string, using one set of reasonable
+ * formatting rules.
+ */
+
+export function print(ast) {
+  return visit(ast, printDocASTReducer);
+}
+const MAX_LINE_LENGTH = 80;
+const printDocASTReducer = {
+  Name: {
+    leave: (node) => node.value,
+  },
+  Variable: {
+    leave: (node) => '$' + node.name,
+  },
+  // Document
+  Document: {
+    leave: (node) => join(node.definitions, '\n\n'),
+  },
+  OperationDefinition: {
+    leave(node) {
+      const varDefs = hasMultilineItems(node.variableDefinitions)
+        ? wrap('(\n', join(node.variableDefinitions, '\n'), '\n)')
+        : wrap('(', join(node.variableDefinitions, ', '), ')');
+      const prefix =
+        wrap('', node.description, '\n') +
+        join(
+          [
+            node.operation,
+            join([node.name, varDefs]),
+            join(node.directives, ' '),
+          ],
+          ' ',
+        ); // Anonymous queries with no directives or variable definitions can use
+      // the query short form.
+
+      return (prefix === 'query' ? '' : prefix + ' ') + node.selectionSet;
+    },
+  },
+  VariableDefinition: {
+    leave: ({ variable, type, defaultValue, directives, description }) =>
+      wrap('', description, '\n') +
+      variable +
+      ': ' +
+      type +
+      wrap(' = ', defaultValue) +
+      wrap(' ', join(directives, ' ')),
+  },
+  SelectionSet: {
+    leave: ({ selections }) => block(selections),
+  },
+  Field: {
+    leave({ alias, name, arguments: args, directives, selectionSet }) {
+      const prefix = wrap('', alias, ': ') + name;
+      let argsLine = prefix + wrap('(', join(args, ', '), ')');
+
+      if (argsLine.length > MAX_LINE_LENGTH) {
+        argsLine = prefix + wrap('(\n', indent(join(args, '\n')), '\n)');
+      }
+
+      return join([argsLine, join(directives, ' '), selectionSet], ' ');
+    },
+  },
+  Argument: {
+    leave: ({ name, value }) => name + ': ' + value,
+  },
+  // Fragments
+  FragmentSpread: {
+    leave: ({ name, directives }) =>
+      '...' + name + wrap(' ', join(directives, ' ')),
+  },
+  InlineFragment: {
+    leave: ({ typeCondition, directives, selectionSet }) =>
+      join(
+        [
+          '...',
+          wrap('on ', typeCondition),
+          join(directives, ' '),
+          selectionSet,
+        ],
+        ' ',
+      ),
+  },
+  FragmentDefinition: {
+    leave: ({
+      name,
+      typeCondition,
+      variableDefinitions,
+      directives,
+      selectionSet,
+      description,
+    }) =>
+      wrap('', description, '\n') + // Note: fragment variable definitions are experimental and may be changed
+      // or removed in the future.
+      `fragment ${name}${wrap('(', join(variableDefinitions, ', '), ')')} ` +
+      `on ${typeCondition} ${wrap('', join(directives, ' '), ' ')}` +
+      selectionSet,
+  },
+  // Value
+  IntValue: {
+    leave: ({ value }) => value,
+  },
+  FloatValue: {
+    leave: ({ value }) => value,
+  },
+  StringValue: {
+    leave: ({ value, block: isBlockString }) =>
+      isBlockString ? printBlockString(value) : printString(value),
+  },
+  BooleanValue: {
+    leave: ({ value }) => (value ? 'true' : 'false'),
+  },
+  NullValue: {
+    leave: () => 'null',
+  },
+  EnumValue: {
+    leave: ({ value }) => value,
+  },
+  ListValue: {
+    leave: ({ values }) => '[' + join(values, ', ') + ']',
+  },
+  ObjectValue: {
+    leave: ({ fields }) => '{' + join(fields, ', ') + '}',
+  },
+  ObjectField: {
+    leave: ({ name, value }) => name + ': ' + value,
+  },
+  // Directive
+  Directive: {
+    leave: ({ name, arguments: args }) =>
+      '@' + name + wrap('(', join(args, ', '), ')'),
+  },
+  // Type
+  NamedType: {
+    leave: ({ name }) => name,
+  },
+  ListType: {
+    leave: ({ type }) => '[' + type + ']',
+  },
+  NonNullType: {
+    leave: ({ type }) => type + '!',
+  },
+  // Type System Definitions
+  SchemaDefinition: {
+    leave: ({ description, directives, operationTypes }) =>
+      wrap('', description, '\n') +
+      join(['schema', join(directives, ' '), block(operationTypes)], ' '),
+  },
+  OperationTypeDefinition: {
+    leave: ({ operation, type }) => operation + ': ' + type,
+  },
+  ScalarTypeDefinition: {
+    leave: ({ description, name, directives }) =>
+      wrap('', description, '\n') +
+      join(['scalar', name, join(directives, ' ')], ' '),
+  },
+  ObjectTypeDefinition: {
+    leave: ({ description, name, interfaces, directives, fields }) =>
+      wrap('', description, '\n') +
+      join(
+        [
+          'type',
+          name,
+          wrap('implements ', join(interfaces, ' & ')),
+          join(directives, ' '),
+          block(fields),
+        ],
+        ' ',
+      ),
+  },
+  FieldDefinition: {
+    leave: ({ description, name, arguments: args, type, directives }) =>
+      wrap('', description, '\n') +
+      name +
+      (hasMultilineItems(args)
+        ? wrap('(\n', indent(join(args, '\n')), '\n)')
+        : wrap('(', join(args, ', '), ')')) +
+      ': ' +
+      type +
+      wrap(' ', join(directives, ' ')),
+  },
+  InputValueDefinition: {
+    leave: ({ description, name, type, defaultValue, directives }) =>
+      wrap('', description, '\n') +
+      join(
+        [name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')],
+        ' ',
+      ),
+  },
+  InterfaceTypeDefinition: {
+    leave: ({ description, name, interfaces, directives, fields }) =>
+      wrap('', description, '\n') +
+      join(
+        [
+          'interface',
+          name,
+          wrap('implements ', join(interfaces, ' & ')),
+          join(directives, ' '),
+          block(fields),
+        ],
+        ' ',
+      ),
+  },
+  UnionTypeDefinition: {
+    leave: ({ description, name, directives, types }) =>
+      wrap('', description, '\n') +
+      join(
+        ['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))],
+        ' ',
+      ),
+  },
+  EnumTypeDefinition: {
+    leave: ({ description, name, directives, values }) =>
+      wrap('', description, '\n') +
+      join(['enum', name, join(directives, ' '), block(values)], ' '),
+  },
+  EnumValueDefinition: {
+    leave: ({ description, name, directives }) =>
+      wrap('', description, '\n') + join([name, join(directives, ' ')], ' '),
+  },
+  InputObjectTypeDefinition: {
+    leave: ({ description, name, directives, fields }) =>
+      wrap('', description, '\n') +
+      join(['input', name, join(directives, ' '), block(fields)], ' '),
+  },
+  DirectiveDefinition: {
+    leave: ({ description, name, arguments: args, repeatable, locations }) =>
+      wrap('', description, '\n') +
+      'directive @' +
+      name +
+      (hasMultilineItems(args)
+        ? wrap('(\n', indent(join(args, '\n')), '\n)')
+        : wrap('(', join(args, ', '), ')')) +
+      (repeatable ? ' repeatable' : '') +
+      ' on ' +
+      join(locations, ' | '),
+  },
+  SchemaExtension: {
+    leave: ({ directives, operationTypes }) =>
+      join(
+        ['extend schema', join(directives, ' '), block(operationTypes)],
+        ' ',
+      ),
+  },
+  ScalarTypeExtension: {
+    leave: ({ name, directives }) =>
+      join(['extend scalar', name, join(directives, ' ')], ' '),
+  },
+  ObjectTypeExtension: {
+    leave: ({ name, interfaces, directives, fields }) =>
+      join(
+        [
+          'extend type',
+          name,
+          wrap('implements ', join(interfaces, ' & ')),
+          join(directives, ' '),
+          block(fields),
+        ],
+        ' ',
+      ),
+  },
+  InterfaceTypeExtension: {
+    leave: ({ name, interfaces, directives, fields }) =>
+      join(
+        [
+          'extend interface',
+          name,
+          wrap('implements ', join(interfaces, ' & ')),
+          join(directives, ' '),
+          block(fields),
+        ],
+        ' ',
+      ),
+  },
+  UnionTypeExtension: {
+    leave: ({ name, directives, types }) =>
+      join(
+        [
+          'extend union',
+          name,
+          join(directives, ' '),
+          wrap('= ', join(types, ' | ')),
+        ],
+        ' ',
+      ),
+  },
+  EnumTypeExtension: {
+    leave: ({ name, directives, values }) =>
+      join(['extend enum', name, join(directives, ' '), block(values)], ' '),
+  },
+  InputObjectTypeExtension: {
+    leave: ({ name, directives, fields }) =>
+      join(['extend input', name, join(directives, ' '), block(fields)], ' '),
+  },
+  // Schema Coordinates
+  TypeCoordinate: {
+    leave: ({ name }) => name,
+  },
+  MemberCoordinate: {
+    leave: ({ name, memberName }) => join([name, wrap('.', memberName)]),
+  },
+  ArgumentCoordinate: {
+    leave: ({ name, fieldName, argumentName }) =>
+      join([name, wrap('.', fieldName), wrap('(', argumentName, ':)')]),
+  },
+  DirectiveCoordinate: {
+    leave: ({ name }) => join(['@', name]),
+  },
+  DirectiveArgumentCoordinate: {
+    leave: ({ name, argumentName }) =>
+      join(['@', name, wrap('(', argumentName, ':)')]),
+  },
+};
+/**
+ * Given maybeArray, print an empty string if it is null or empty, otherwise
+ * print all items together separated by separator if provided
+ */
+
+function join(maybeArray, separator = '') {
+  var _maybeArray$filter$jo;
+
+  return (_maybeArray$filter$jo =
+    maybeArray === null || maybeArray === void 0
+      ? void 0
+      : maybeArray.filter((x) => x).join(separator)) !== null &&
+    _maybeArray$filter$jo !== void 0
+    ? _maybeArray$filter$jo
+    : '';
+}
+/**
+ * Given array, print each item on its own line, wrapped in an indented `{ }` block.
+ */
+
+function block(array) {
+  return wrap('{\n', indent(join(array, '\n')), '\n}');
+}
+/**
+ * If maybeString is not null or empty, then wrap with start and end, otherwise print an empty string.
+ */
+
+function wrap(start, maybeString, end = '') {
+  return maybeString != null && maybeString !== ''
+    ? start + maybeString + end
+    : '';
+}
+
+function indent(str) {
+  return wrap('  ', str.replace(/\n/g, '\n  '));
+}
+
+function hasMultilineItems(maybeArray) {
+  var _maybeArray$some;
+
+  // FIXME: https://github.com/graphql/graphql-js/issues/2203
+
+  /* c8 ignore next */
+  return (_maybeArray$some =
+    maybeArray === null || maybeArray === void 0
+      ? void 0
+      : maybeArray.some((str) => str.includes('\n'))) !== null &&
+    _maybeArray$some !== void 0
+    ? _maybeArray$some
+    : false;
+}

package/node_modules/graphql/language/schemaCoordinateLexer.d.ts

@@ -0,0 +1,43 @@
+import { Token } from './ast';
+import type { LexerInterface } from './lexer';
+import type { Source } from './source';
+/**
+ * Given a Source schema coordinate, creates a Lexer for that source.
+ * A SchemaCoordinateLexer is a stateful stream generator in that every time
+ * it is advanced, it returns the next token in the Source. Assuming the
+ * source lexes, the final Token emitted by the lexer will be of kind
+ * EOF, after which the lexer will repeatedly return the same EOF token
+ * whenever called.
+ */
+export declare class SchemaCoordinateLexer implements LexerInterface {
+  source: Source;
+  /**
+   * The previously focused non-ignored token.
+   */
+  lastToken: Token;
+  /**
+   * The currently focused non-ignored token.
+   */
+  token: Token;
+  /**
+   * The (1-indexed) line containing the current token.
+   * Since a schema coordinate may not contain newline, this value is always 1.
+   */
+  line: 1;
+  /**
+   * The character offset at which the current line begins.
+   * Since a schema coordinate may not contain newline, this value is always 0.
+   */
+  lineStart: 0;
+  constructor(source: Source);
+  get [Symbol.toStringTag](): string;
+  /**
+   * Advances the token stream to the next non-ignored token.
+   */
+  advance(): Token;
+  /**
+   * Looks ahead and returns the next non-ignored token, but does not change
+   * the current Lexer token.
+   */
+  lookahead(): Token;
+}

package/node_modules/graphql/language/schemaCoordinateLexer.js

@@ -0,0 +1,171 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.SchemaCoordinateLexer = void 0;
+
+var _syntaxError = require('../error/syntaxError.js');
+
+var _ast = require('./ast.js');
+
+var _characterClasses = require('./characterClasses.js');
+
+var _lexer = require('./lexer.js');
+
+var _tokenKind = require('./tokenKind.js');
+
+/**
+ * Given a Source schema coordinate, creates a Lexer for that source.
+ * A SchemaCoordinateLexer is a stateful stream generator in that every time
+ * it is advanced, it returns the next token in the Source. Assuming the
+ * source lexes, the final Token emitted by the lexer will be of kind
+ * EOF, after which the lexer will repeatedly return the same EOF token
+ * whenever called.
+ */
+class SchemaCoordinateLexer {
+  /**
+   * The previously focused non-ignored token.
+   */
+
+  /**
+   * The currently focused non-ignored token.
+   */
+
+  /**
+   * The (1-indexed) line containing the current token.
+   * Since a schema coordinate may not contain newline, this value is always 1.
+   */
+  line = 1;
+  /**
+   * The character offset at which the current line begins.
+   * Since a schema coordinate may not contain newline, this value is always 0.
+   */
+
+  lineStart = 0;
+
+  constructor(source) {
+    const startOfFileToken = new _ast.Token(
+      _tokenKind.TokenKind.SOF,
+      0,
+      0,
+      0,
+      0,
+    );
+    this.source = source;
+    this.lastToken = startOfFileToken;
+    this.token = startOfFileToken;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'SchemaCoordinateLexer';
+  }
+  /**
+   * Advances the token stream to the next non-ignored token.
+   */
+
+  advance() {
+    this.lastToken = this.token;
+    const token = (this.token = this.lookahead());
+    return token;
+  }
+  /**
+   * Looks ahead and returns the next non-ignored token, but does not change
+   * the current Lexer token.
+   */
+
+  lookahead() {
+    let token = this.token;
+
+    if (token.kind !== _tokenKind.TokenKind.EOF) {
+      // Read the next token and form a link in the token linked-list.
+      const nextToken = readNextToken(this, token.end); // @ts-expect-error next is only mutable during parsing.
+
+      token.next = nextToken; // @ts-expect-error prev is only mutable during parsing.
+
+      nextToken.prev = token;
+      token = nextToken;
+    }
+
+    return token;
+  }
+}
+/**
+ * Gets the next token from the source starting at the given position.
+ */
+
+exports.SchemaCoordinateLexer = SchemaCoordinateLexer;
+
+function readNextToken(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  const position = start;
+
+  if (position < bodyLength) {
+    const code = body.charCodeAt(position);
+
+    switch (code) {
+      case 0x002e:
+        // .
+        return (0, _lexer.createToken)(
+          lexer,
+          _tokenKind.TokenKind.DOT,
+          position,
+          position + 1,
+        );
+
+      case 0x0028:
+        // (
+        return (0, _lexer.createToken)(
+          lexer,
+          _tokenKind.TokenKind.PAREN_L,
+          position,
+          position + 1,
+        );
+
+      case 0x0029:
+        // )
+        return (0, _lexer.createToken)(
+          lexer,
+          _tokenKind.TokenKind.PAREN_R,
+          position,
+          position + 1,
+        );
+
+      case 0x003a:
+        // :
+        return (0, _lexer.createToken)(
+          lexer,
+          _tokenKind.TokenKind.COLON,
+          position,
+          position + 1,
+        );
+
+      case 0x0040:
+        // @
+        return (0, _lexer.createToken)(
+          lexer,
+          _tokenKind.TokenKind.AT,
+          position,
+          position + 1,
+        );
+    } // Name
+
+    if ((0, _characterClasses.isNameStart)(code)) {
+      return (0, _lexer.readName)(lexer, position);
+    }
+
+    throw (0, _syntaxError.syntaxError)(
+      lexer.source,
+      position,
+      `Invalid character: ${(0, _lexer.printCodePointAt)(lexer, position)}.`,
+    );
+  }
+
+  return (0, _lexer.createToken)(
+    lexer,
+    _tokenKind.TokenKind.EOF,
+    bodyLength,
+    bodyLength,
+  );
+}

package/node_modules/graphql/language/schemaCoordinateLexer.mjs

@@ -0,0 +1,122 @@
+import { syntaxError } from '../error/syntaxError.mjs';
+import { Token } from './ast.mjs';
+import { isNameStart } from './characterClasses.mjs';
+import { createToken, printCodePointAt, readName } from './lexer.mjs';
+import { TokenKind } from './tokenKind.mjs';
+/**
+ * Given a Source schema coordinate, creates a Lexer for that source.
+ * A SchemaCoordinateLexer is a stateful stream generator in that every time
+ * it is advanced, it returns the next token in the Source. Assuming the
+ * source lexes, the final Token emitted by the lexer will be of kind
+ * EOF, after which the lexer will repeatedly return the same EOF token
+ * whenever called.
+ */
+
+export class SchemaCoordinateLexer {
+  /**
+   * The previously focused non-ignored token.
+   */
+
+  /**
+   * The currently focused non-ignored token.
+   */
+
+  /**
+   * The (1-indexed) line containing the current token.
+   * Since a schema coordinate may not contain newline, this value is always 1.
+   */
+  line = 1;
+  /**
+   * The character offset at which the current line begins.
+   * Since a schema coordinate may not contain newline, this value is always 0.
+   */
+
+  lineStart = 0;
+
+  constructor(source) {
+    const startOfFileToken = new Token(TokenKind.SOF, 0, 0, 0, 0);
+    this.source = source;
+    this.lastToken = startOfFileToken;
+    this.token = startOfFileToken;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'SchemaCoordinateLexer';
+  }
+  /**
+   * Advances the token stream to the next non-ignored token.
+   */
+
+  advance() {
+    this.lastToken = this.token;
+    const token = (this.token = this.lookahead());
+    return token;
+  }
+  /**
+   * Looks ahead and returns the next non-ignored token, but does not change
+   * the current Lexer token.
+   */
+
+  lookahead() {
+    let token = this.token;
+
+    if (token.kind !== TokenKind.EOF) {
+      // Read the next token and form a link in the token linked-list.
+      const nextToken = readNextToken(this, token.end); // @ts-expect-error next is only mutable during parsing.
+
+      token.next = nextToken; // @ts-expect-error prev is only mutable during parsing.
+
+      nextToken.prev = token;
+      token = nextToken;
+    }
+
+    return token;
+  }
+}
+/**
+ * Gets the next token from the source starting at the given position.
+ */
+
+function readNextToken(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  const position = start;
+
+  if (position < bodyLength) {
+    const code = body.charCodeAt(position);
+
+    switch (code) {
+      case 0x002e:
+        // .
+        return createToken(lexer, TokenKind.DOT, position, position + 1);
+
+      case 0x0028:
+        // (
+        return createToken(lexer, TokenKind.PAREN_L, position, position + 1);
+
+      case 0x0029:
+        // )
+        return createToken(lexer, TokenKind.PAREN_R, position, position + 1);
+
+      case 0x003a:
+        // :
+        return createToken(lexer, TokenKind.COLON, position, position + 1);
+
+      case 0x0040:
+        // @
+        return createToken(lexer, TokenKind.AT, position, position + 1);
+    } // Name
+
+    if (isNameStart(code)) {
+      return readName(lexer, position);
+    }
+
+    throw syntaxError(
+      lexer.source,
+      position,
+      `Invalid character: ${printCodePointAt(lexer, position)}.`,
+    );
+  }
+
+  return createToken(lexer, TokenKind.EOF, bodyLength, bodyLength);
+}