{"version":3,"sources":["../src/storeUtils.ts","../src/directives.ts","../src/fragments.ts","../src/util/assign.ts","../src/getFromAST.ts","../src/util/filterInPlace.ts","../src/transform.ts","../src/util/canUse.ts","../src/util/cloneDeep.ts","../src/util/environment.ts","../src/util/errorHandling.ts","../src/util/maybeDeepFreeze.ts","../src/util/mergeDeep.ts","../src/util/warnOnce.ts","../src/util/stripSymbols.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DirectiveNode,\n  FieldNode,\n  IntValueNode,\n  FloatValueNode,\n  StringValueNode,\n  BooleanValueNode,\n  ObjectValueNode,\n  ListValueNode,\n  EnumValueNode,\n  NullValueNode,\n  VariableNode,\n  InlineFragmentNode,\n  ValueNode,\n  SelectionNode,\n  NameNode,\n} from 'graphql';\n\nimport stringify from 'fast-json-stable-stringify';\nimport { InvariantError } from 'ts-invariant';\n\nexport interface IdValue {\n  type: 'id';\n  id: string;\n  generated: boolean;\n  typename: string | undefined;\n}\n\nexport interface JsonValue {\n  type: 'json';\n  json: any;\n}\n\nexport type ListValue = Array<null | IdValue>;\n\nexport type StoreValue =\n  | number\n  | string\n  | string[]\n  | IdValue\n  | ListValue\n  | JsonValue\n  | null\n  | undefined\n  | void\n  | Object;\n\nexport type ScalarValue = StringValueNode | BooleanValueNode | EnumValueNode;\n\nexport function isScalarValue(value: ValueNode): value is ScalarValue {\n  return ['StringValue', 'BooleanValue', 'EnumValue'].indexOf(value.kind) > -1;\n}\n\nexport type NumberValue = IntValueNode | FloatValueNode;\n\nexport function isNumberValue(value: ValueNode): value is NumberValue {\n  return ['IntValue', 'FloatValue'].indexOf(value.kind) > -1;\n}\n\nfunction isStringValue(value: ValueNode): value is StringValueNode {\n  return value.kind === 'StringValue';\n}\n\nfunction isBooleanValue(value: ValueNode): value is BooleanValueNode {\n  return value.kind === 'BooleanValue';\n}\n\nfunction isIntValue(value: ValueNode): value is IntValueNode {\n  return value.kind === 'IntValue';\n}\n\nfunction isFloatValue(value: ValueNode): value is FloatValueNode {\n  return value.kind === 'FloatValue';\n}\n\nfunction isVariable(value: ValueNode): value is VariableNode {\n  return value.kind === 'Variable';\n}\n\nfunction isObjectValue(value: ValueNode): value is ObjectValueNode {\n  return value.kind === 'ObjectValue';\n}\n\nfunction isListValue(value: ValueNode): value is ListValueNode {\n  return value.kind === 'ListValue';\n}\n\nfunction isEnumValue(value: ValueNode): value is EnumValueNode {\n  return value.kind === 'EnumValue';\n}\n\nfunction isNullValue(value: ValueNode): value is NullValueNode {\n  return value.kind === 'NullValue';\n}\n\nexport function valueToObjectRepresentation(\n  argObj: any,\n  name: NameNode,\n  value: ValueNode,\n  variables?: Object,\n) {\n  if (isIntValue(value) || isFloatValue(value)) {\n    argObj[name.value] = Number(value.value);\n  } else if (isBooleanValue(value) || isStringValue(value)) {\n    argObj[name.value] = value.value;\n  } else if (isObjectValue(value)) {\n    const nestedArgObj = {};\n    value.fields.map(obj =>\n      valueToObjectRepresentation(nestedArgObj, obj.name, obj.value, variables),\n    );\n    argObj[name.value] = nestedArgObj;\n  } else if (isVariable(value)) {\n    const variableValue = (variables || ({} as any))[value.name.value];\n    argObj[name.value] = variableValue;\n  } else if (isListValue(value)) {\n    argObj[name.value] = value.values.map(listValue => {\n      const nestedArgArrayObj = {};\n      valueToObjectRepresentation(\n        nestedArgArrayObj,\n        name,\n        listValue,\n        variables,\n      );\n      return (nestedArgArrayObj as any)[name.value];\n    });\n  } else if (isEnumValue(value)) {\n    argObj[name.value] = (value as EnumValueNode).value;\n  } else if (isNullValue(value)) {\n    argObj[name.value] = null;\n  } else {\n    throw new InvariantError(\n      `The inline argument \"${name.value}\" of kind \"${(value as any).kind}\"` +\n        'is not supported. Use variables instead of inline arguments to ' +\n        'overcome this limitation.',\n    );\n  }\n}\n\nexport function storeKeyNameFromField(\n  field: FieldNode,\n  variables?: Object,\n): string {\n  let directivesObj: any = null;\n  if (field.directives) {\n    directivesObj = {};\n    field.directives.forEach(directive => {\n      directivesObj[directive.name.value] = {};\n\n      if (directive.arguments) {\n        directive.arguments.forEach(({ name, value }) =>\n          valueToObjectRepresentation(\n            directivesObj[directive.name.value],\n            name,\n            value,\n            variables,\n          ),\n        );\n      }\n    });\n  }\n\n  let argObj: any = null;\n  if (field.arguments && field.arguments.length) {\n    argObj = {};\n    field.arguments.forEach(({ name, value }) =>\n      valueToObjectRepresentation(argObj, name, value, variables),\n    );\n  }\n\n  return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\n\nexport type Directives = {\n  [directiveName: string]: {\n    [argName: string]: any;\n  };\n};\n\nconst KNOWN_DIRECTIVES: string[] = [\n  'connection',\n  'include',\n  'skip',\n  'client',\n  'rest',\n  'export',\n];\n\nexport function getStoreKeyName(\n  fieldName: string,\n  args?: Object,\n  directives?: Directives,\n): string {\n  if (\n    directives &&\n    directives['connection'] &&\n    directives['connection']['key']\n  ) {\n    if (\n      directives['connection']['filter'] &&\n      (directives['connection']['filter'] as string[]).length > 0\n    ) {\n      const filterKeys = directives['connection']['filter']\n        ? (directives['connection']['filter'] as string[])\n        : [];\n      filterKeys.sort();\n\n      const queryArgs = args as { [key: string]: any };\n      const filteredArgs = {} as { [key: string]: any };\n      filterKeys.forEach(key => {\n        filteredArgs[key] = queryArgs[key];\n      });\n\n      return `${directives['connection']['key']}(${JSON.stringify(\n        filteredArgs,\n      )})`;\n    } else {\n      return directives['connection']['key'];\n    }\n  }\n\n  let completeFieldName: string = fieldName;\n\n  if (args) {\n    // We can't use `JSON.stringify` here since it's non-deterministic,\n    // and can lead to different store key names being created even though\n    // the `args` object used during creation has the same properties/values.\n    const stringifiedArgs: string = stringify(args);\n    completeFieldName += `(${stringifiedArgs})`;\n  }\n\n  if (directives) {\n    Object.keys(directives).forEach(key => {\n      if (KNOWN_DIRECTIVES.indexOf(key) !== -1) return;\n      if (directives[key] && Object.keys(directives[key]).length) {\n        completeFieldName += `@${key}(${JSON.stringify(directives[key])})`;\n      } else {\n        completeFieldName += `@${key}`;\n      }\n    });\n  }\n\n  return completeFieldName;\n}\n\nexport function argumentsObjectFromField(\n  field: FieldNode | DirectiveNode,\n  variables: Object,\n): Object {\n  if (field.arguments && field.arguments.length) {\n    const argObj: Object = {};\n    field.arguments.forEach(({ name, value }) =>\n      valueToObjectRepresentation(argObj, name, value, variables),\n    );\n    return argObj;\n  }\n\n  return null;\n}\n\nexport function resultKeyNameFromField(field: FieldNode): string {\n  return field.alias ? field.alias.value : field.name.value;\n}\n\nexport function isField(selection: SelectionNode): selection is FieldNode {\n  return selection.kind === 'Field';\n}\n\nexport function isInlineFragment(\n  selection: SelectionNode,\n): selection is InlineFragmentNode {\n  return selection.kind === 'InlineFragment';\n}\n\nexport function isIdValue(idObject: StoreValue): idObject is IdValue {\n  return idObject &&\n    (idObject as IdValue | JsonValue).type === 'id' &&\n    typeof (idObject as IdValue).generated === 'boolean';\n}\n\nexport type IdConfig = {\n  id: string;\n  typename: string | undefined;\n};\n\nexport function toIdValue(\n  idConfig: string | IdConfig,\n  generated = false,\n): IdValue {\n  return {\n    type: 'id',\n    generated,\n    ...(typeof idConfig === 'string'\n      ? { id: idConfig, typename: undefined }\n      : idConfig),\n  };\n}\n\nexport function isJsonValue(jsonObject: StoreValue): jsonObject is JsonValue {\n  return (\n    jsonObject != null &&\n    typeof jsonObject === 'object' &&\n    (jsonObject as IdValue | JsonValue).type === 'json'\n  );\n}\n\nfunction defaultValueFromVariable(node: VariableNode) {\n  throw new InvariantError(`Variable nodes are not supported by valueFromNode`);\n}\n\nexport type VariableValue = (node: VariableNode) => any;\n\n/**\n * Evaluate a ValueNode and yield its value in its natural JS form.\n */\nexport function valueFromNode(\n  node: ValueNode,\n  onVariable: VariableValue = defaultValueFromVariable,\n): any {\n  switch (node.kind) {\n    case 'Variable':\n      return onVariable(node);\n    case 'NullValue':\n      return null;\n    case 'IntValue':\n      return parseInt(node.value, 10);\n    case 'FloatValue':\n      return parseFloat(node.value);\n    case 'ListValue':\n      return node.values.map(v => valueFromNode(v, onVariable));\n    case 'ObjectValue': {\n      const value: { [key: string]: any } = {};\n      for (const field of node.fields) {\n        value[field.name.value] = valueFromNode(field.value, onVariable);\n      }\n      return value;\n    }\n    default:\n      return node.value;\n  }\n}\n","// Provides the methods that allow QueryManager to handle the `skip` and\n// `include` directives within GraphQL.\nimport {\n  FieldNode,\n  SelectionNode,\n  VariableNode,\n  BooleanValueNode,\n  DirectiveNode,\n  DocumentNode,\n  ArgumentNode,\n  ValueNode,\n} from 'graphql';\n\nimport { visit } from 'graphql/language/visitor';\n\nimport { invariant } from 'ts-invariant';\n\nimport { argumentsObjectFromField } from './storeUtils';\n\nexport type DirectiveInfo = {\n  [fieldName: string]: { [argName: string]: any };\n};\n\nexport function getDirectiveInfoFromField(\n  field: FieldNode,\n  variables: Object,\n): DirectiveInfo {\n  if (field.directives && field.directives.length) {\n    const directiveObj: DirectiveInfo = {};\n    field.directives.forEach((directive: DirectiveNode) => {\n      directiveObj[directive.name.value] = argumentsObjectFromField(\n        directive,\n        variables,\n      );\n    });\n    return directiveObj;\n  }\n  return null;\n}\n\nexport function shouldInclude(\n  selection: SelectionNode,\n  variables: { [name: string]: any } = {},\n): boolean {\n  return getInclusionDirectives(\n    selection.directives,\n  ).every(({ directive, ifArgument }) => {\n    let evaledValue: boolean = false;\n    if (ifArgument.value.kind === 'Variable') {\n      evaledValue = variables[(ifArgument.value as VariableNode).name.value];\n      invariant(\n        evaledValue !== void 0,\n        `Invalid variable referenced in @${directive.name.value} directive.`,\n      );\n    } else {\n      evaledValue = (ifArgument.value as BooleanValueNode).value;\n    }\n    return directive.name.value === 'skip' ? !evaledValue : evaledValue;\n  });\n}\n\nexport function getDirectiveNames(doc: DocumentNode) {\n  const names: string[] = [];\n\n  visit(doc, {\n    Directive(node) {\n      names.push(node.name.value);\n    },\n  });\n\n  return names;\n}\n\nexport function hasDirectives(names: string[], doc: DocumentNode) {\n  return getDirectiveNames(doc).some(\n    (name: string) => names.indexOf(name) > -1,\n  );\n}\n\nexport function hasClientExports(document: DocumentNode) {\n  return (\n    document &&\n    hasDirectives(['client'], document) &&\n    hasDirectives(['export'], document)\n  );\n}\n\nexport type InclusionDirectives = Array<{\n  directive: DirectiveNode;\n  ifArgument: ArgumentNode;\n}>;\n\nfunction isInclusionDirective({ name: { value } }: DirectiveNode): boolean {\n  return value === 'skip' || value === 'include';\n}\n\nexport function getInclusionDirectives(\n  directives: ReadonlyArray<DirectiveNode>,\n): InclusionDirectives {\n  return directives ? directives.filter(isInclusionDirective).map(directive => {\n    const directiveArguments = directive.arguments;\n    const directiveName = directive.name.value;\n\n    invariant(\n      directiveArguments && directiveArguments.length === 1,\n      `Incorrect number of arguments for the @${directiveName} directive.`,\n    );\n\n    const ifArgument = directiveArguments[0];\n    invariant(\n      ifArgument.name && ifArgument.name.value === 'if',\n      `Invalid argument for the @${directiveName} directive.`,\n    );\n\n    const ifValue: ValueNode = ifArgument.value;\n\n    // means it has to be a variable value if this is a valid @skip or @include directive\n    invariant(\n      ifValue &&\n        (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'),\n      `Argument for the @${directiveName} directive must be a variable or a boolean value.`,\n    );\n\n    return { directive, ifArgument };\n  }) : [];\n}\n\n","import { DocumentNode, FragmentDefinitionNode } from 'graphql';\nimport { invariant, InvariantError } from 'ts-invariant';\n\n/**\n * Returns a query document which adds a single query operation that only\n * spreads the target fragment inside of it.\n *\n * So for example a document of:\n *\n * ```graphql\n * fragment foo on Foo { a b c }\n * ```\n *\n * Turns into:\n *\n * ```graphql\n * { ...foo }\n *\n * fragment foo on Foo { a b c }\n * ```\n *\n * The target fragment will either be the only fragment in the document, or a\n * fragment specified by the provided `fragmentName`. If there is more than one\n * fragment, but a `fragmentName` was not defined then an error will be thrown.\n */\nexport function getFragmentQueryDocument(\n  document: DocumentNode,\n  fragmentName?: string,\n): DocumentNode {\n  let actualFragmentName = fragmentName;\n\n  // Build an array of all our fragment definitions that will be used for\n  // validations. We also do some validations on the other definitions in the\n  // document while building this list.\n  const fragments: Array<FragmentDefinitionNode> = [];\n  document.definitions.forEach(definition => {\n    // Throw an error if we encounter an operation definition because we will\n    // define our own operation definition later on.\n    if (definition.kind === 'OperationDefinition') {\n      throw new InvariantError(\n        `Found a ${definition.operation} operation${\n          definition.name ? ` named '${definition.name.value}'` : ''\n        }. ` +\n          'No operations are allowed when using a fragment as a query. Only fragments are allowed.',\n      );\n    }\n    // Add our definition to the fragments array if it is a fragment\n    // definition.\n    if (definition.kind === 'FragmentDefinition') {\n      fragments.push(definition);\n    }\n  });\n\n  // If the user did not give us a fragment name then let us try to get a\n  // name from a single fragment in the definition.\n  if (typeof actualFragmentName === 'undefined') {\n    invariant(\n      fragments.length === 1,\n      `Found ${\n        fragments.length\n      } fragments. \\`fragmentName\\` must be provided when there is not exactly 1 fragment.`,\n    );\n    actualFragmentName = fragments[0].name.value;\n  }\n\n  // Generate a query document with an operation that simply spreads the\n  // fragment inside of it.\n  const query: DocumentNode = {\n    ...document,\n    definitions: [\n      {\n        kind: 'OperationDefinition',\n        operation: 'query',\n        selectionSet: {\n          kind: 'SelectionSet',\n          selections: [\n            {\n              kind: 'FragmentSpread',\n              name: {\n                kind: 'Name',\n                value: actualFragmentName,\n              },\n            },\n          ],\n        },\n      },\n      ...document.definitions,\n    ],\n  };\n\n  return query;\n}\n","/**\n * Adds the properties of one or more source objects to a target object. Works exactly like\n * `Object.assign`, but as a utility to maintain support for IE 11.\n *\n * @see https://github.com/apollostack/apollo-client/pull/1009\n */\nexport function assign<A, B>(a: A, b: B): A & B;\nexport function assign<A, B, C>(a: A, b: B, c: C): A & B & C;\nexport function assign<A, B, C, D>(a: A, b: B, c: C, d: D): A & B & C & D;\nexport function assign<A, B, C, D, E>(\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n): A & B & C & D & E;\nexport function assign(target: any, ...sources: Array<any>): any;\nexport function assign(\n  target: { [key: string]: any },\n  ...sources: Array<{ [key: string]: any }>\n): { [key: string]: any } {\n  sources.forEach(source => {\n    if (typeof source === 'undefined' || source === null) {\n      return;\n    }\n    Object.keys(source).forEach(key => {\n      target[key] = source[key];\n    });\n  });\n  return target;\n}\n","import {\n  DocumentNode,\n  OperationDefinitionNode,\n  FragmentDefinitionNode,\n  ValueNode,\n} from 'graphql';\n\nimport { invariant, InvariantError } from 'ts-invariant';\n\nimport { assign } from './util/assign';\n\nimport { valueToObjectRepresentation, JsonValue } from './storeUtils';\n\nexport function getMutationDefinition(\n  doc: DocumentNode,\n): OperationDefinitionNode {\n  checkDocument(doc);\n\n  let mutationDef: OperationDefinitionNode | null = doc.definitions.filter(\n    definition =>\n      definition.kind === 'OperationDefinition' &&\n      definition.operation === 'mutation',\n  )[0] as OperationDefinitionNode;\n\n  invariant(mutationDef, 'Must contain a mutation definition.');\n\n  return mutationDef;\n}\n\n// Checks the document for errors and throws an exception if there is an error.\nexport function checkDocument(doc: DocumentNode) {\n  invariant(\n    doc && doc.kind === 'Document',\n    `Expecting a parsed GraphQL document. Perhaps you need to wrap the query \\\nstring in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql`,\n  );\n\n  const operations = doc.definitions\n    .filter(d => d.kind !== 'FragmentDefinition')\n    .map(definition => {\n      if (definition.kind !== 'OperationDefinition') {\n        throw new InvariantError(\n          `Schema type definitions not allowed in queries. Found: \"${\n            definition.kind\n          }\"`,\n        );\n      }\n      return definition;\n    });\n\n  invariant(\n    operations.length <= 1,\n    `Ambiguous GraphQL document: contains ${operations.length} operations`,\n  );\n\n  return doc;\n}\n\nexport function getOperationDefinition(\n  doc: DocumentNode,\n): OperationDefinitionNode | undefined {\n  checkDocument(doc);\n  return doc.definitions.filter(\n    definition => definition.kind === 'OperationDefinition',\n  )[0] as OperationDefinitionNode;\n}\n\nexport function getOperationDefinitionOrDie(\n  document: DocumentNode,\n): OperationDefinitionNode {\n  const def = getOperationDefinition(document);\n  invariant(def, `GraphQL document is missing an operation`);\n  return def;\n}\n\nexport function getOperationName(doc: DocumentNode): string | null {\n  return (\n    doc.definitions\n      .filter(\n        definition =>\n          definition.kind === 'OperationDefinition' && definition.name,\n      )\n      .map((x: OperationDefinitionNode) => x.name.value)[0] || null\n  );\n}\n\n// Returns the FragmentDefinitions from a particular document as an array\nexport function getFragmentDefinitions(\n  doc: DocumentNode,\n): FragmentDefinitionNode[] {\n  return doc.definitions.filter(\n    definition => definition.kind === 'FragmentDefinition',\n  ) as FragmentDefinitionNode[];\n}\n\nexport function getQueryDefinition(doc: DocumentNode): OperationDefinitionNode {\n  const queryDef = getOperationDefinition(doc) as OperationDefinitionNode;\n\n  invariant(\n    queryDef && queryDef.operation === 'query',\n    'Must contain a query definition.',\n  );\n\n  return queryDef;\n}\n\nexport function getFragmentDefinition(\n  doc: DocumentNode,\n): FragmentDefinitionNode {\n  invariant(\n    doc.kind === 'Document',\n    `Expecting a parsed GraphQL document. Perhaps you need to wrap the query \\\nstring in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql`,\n  );\n\n  invariant(\n    doc.definitions.length <= 1,\n    'Fragment must have exactly one definition.',\n  );\n\n  const fragmentDef = doc.definitions[0] as FragmentDefinitionNode;\n\n  invariant(\n    fragmentDef.kind === 'FragmentDefinition',\n    'Must be a fragment definition.',\n  );\n\n  return fragmentDef as FragmentDefinitionNode;\n}\n\n/**\n * Returns the first operation definition found in this document.\n * If no operation definition is found, the first fragment definition will be returned.\n * If no definitions are found, an error will be thrown.\n */\nexport function getMainDefinition(\n  queryDoc: DocumentNode,\n): OperationDefinitionNode | FragmentDefinitionNode {\n  checkDocument(queryDoc);\n\n  let fragmentDefinition;\n\n  for (let definition of queryDoc.definitions) {\n    if (definition.kind === 'OperationDefinition') {\n      const operation = (definition as OperationDefinitionNode).operation;\n      if (\n        operation === 'query' ||\n        operation === 'mutation' ||\n        operation === 'subscription'\n      ) {\n        return definition as OperationDefinitionNode;\n      }\n    }\n    if (definition.kind === 'FragmentDefinition' && !fragmentDefinition) {\n      // we do this because we want to allow multiple fragment definitions\n      // to precede an operation definition.\n      fragmentDefinition = definition as FragmentDefinitionNode;\n    }\n  }\n\n  if (fragmentDefinition) {\n    return fragmentDefinition;\n  }\n\n  throw new InvariantError(\n    'Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.',\n  );\n}\n\n/**\n * This is an interface that describes a map from fragment names to fragment definitions.\n */\nexport interface FragmentMap {\n  [fragmentName: string]: FragmentDefinitionNode;\n}\n\n// Utility function that takes a list of fragment definitions and makes a hash out of them\n// that maps the name of the fragment to the fragment definition.\nexport function createFragmentMap(\n  fragments: FragmentDefinitionNode[] = [],\n): FragmentMap {\n  const symTable: FragmentMap = {};\n  fragments.forEach(fragment => {\n    symTable[fragment.name.value] = fragment;\n  });\n\n  return symTable;\n}\n\nexport function getDefaultValues(\n  definition: OperationDefinitionNode | undefined,\n): { [key: string]: JsonValue } {\n  if (\n    definition &&\n    definition.variableDefinitions &&\n    definition.variableDefinitions.length\n  ) {\n    const defaultValues = definition.variableDefinitions\n      .filter(({ defaultValue }) => defaultValue)\n      .map(\n        ({ variable, defaultValue }): { [key: string]: JsonValue } => {\n          const defaultValueObj: { [key: string]: JsonValue } = {};\n          valueToObjectRepresentation(\n            defaultValueObj,\n            variable.name,\n            defaultValue as ValueNode,\n          );\n\n          return defaultValueObj;\n        },\n      );\n\n    return assign({}, ...defaultValues);\n  }\n\n  return {};\n}\n\n/**\n * Returns the names of all variables declared by the operation.\n */\nexport function variablesInOperation(\n  operation: OperationDefinitionNode,\n): Set<string> {\n  const names = new Set<string>();\n  if (operation.variableDefinitions) {\n    for (const definition of operation.variableDefinitions) {\n      names.add(definition.variable.name.value);\n    }\n  }\n\n  return names;\n}\n","export function filterInPlace<T>(\n  array: T[],\n  test: (elem: T) => boolean,\n  context?: any,\n): T[] {\n  let target = 0;\n  array.forEach(function (elem, i) {\n    if (test.call(this, elem, i, array)) {\n      array[target++] = elem;\n    }\n  }, context);\n  array.length = target;\n  return array;\n}\n","import {\n  DocumentNode,\n  SelectionNode,\n  SelectionSetNode,\n  OperationDefinitionNode,\n  FieldNode,\n  DirectiveNode,\n  FragmentDefinitionNode,\n  ArgumentNode,\n  FragmentSpreadNode,\n  VariableDefinitionNode,\n  VariableNode,\n} from 'graphql';\nimport { visit } from 'graphql/language/visitor';\n\nimport {\n  checkDocument,\n  getOperationDefinition,\n  getFragmentDefinition,\n  getFragmentDefinitions,\n  createFragmentMap,\n  FragmentMap,\n  getMainDefinition,\n} from './getFromAST';\nimport { filterInPlace } from './util/filterInPlace';\nimport { invariant } from 'ts-invariant';\nimport { isField, isInlineFragment } from './storeUtils';\n\nexport type RemoveNodeConfig<N> = {\n  name?: string;\n  test?: (node: N) => boolean;\n  remove?: boolean;\n};\n\nexport type GetNodeConfig<N> = {\n  name?: string;\n  test?: (node: N) => boolean;\n};\n\nexport type RemoveDirectiveConfig = RemoveNodeConfig<DirectiveNode>;\nexport type GetDirectiveConfig = GetNodeConfig<DirectiveNode>;\nexport type RemoveArgumentsConfig = RemoveNodeConfig<ArgumentNode>;\nexport type GetFragmentSpreadConfig = GetNodeConfig<FragmentSpreadNode>;\nexport type RemoveFragmentSpreadConfig = RemoveNodeConfig<FragmentSpreadNode>;\nexport type RemoveFragmentDefinitionConfig = RemoveNodeConfig<\n  FragmentDefinitionNode\n>;\nexport type RemoveVariableDefinitionConfig = RemoveNodeConfig<\n  VariableDefinitionNode\n>;\n\nconst TYPENAME_FIELD: FieldNode = {\n  kind: 'Field',\n  name: {\n    kind: 'Name',\n    value: '__typename',\n  },\n};\n\nfunction isEmpty(\n  op: OperationDefinitionNode | FragmentDefinitionNode,\n  fragments: FragmentMap,\n): boolean {\n  return op.selectionSet.selections.every(\n    selection =>\n      selection.kind === 'FragmentSpread' &&\n      isEmpty(fragments[selection.name.value], fragments),\n  );\n}\n\nfunction nullIfDocIsEmpty(doc: DocumentNode) {\n  return isEmpty(\n    getOperationDefinition(doc) || getFragmentDefinition(doc),\n    createFragmentMap(getFragmentDefinitions(doc)),\n  )\n    ? null\n    : doc;\n}\n\nfunction getDirectiveMatcher(\n  directives: (RemoveDirectiveConfig | GetDirectiveConfig)[],\n) {\n  return function directiveMatcher(directive: DirectiveNode) {\n    return directives.some(\n      dir =>\n        (dir.name && dir.name === directive.name.value) ||\n        (dir.test && dir.test(directive)),\n    );\n  };\n}\n\nexport function removeDirectivesFromDocument(\n  directives: RemoveDirectiveConfig[],\n  doc: DocumentNode,\n): DocumentNode | null {\n  const variablesInUse: Record<string, boolean> = Object.create(null);\n  let variablesToRemove: RemoveArgumentsConfig[] = [];\n\n  const fragmentSpreadsInUse: Record<string, boolean> = Object.create(null);\n  let fragmentSpreadsToRemove: RemoveFragmentSpreadConfig[] = [];\n\n  let modifiedDoc = nullIfDocIsEmpty(\n    visit(doc, {\n      Variable: {\n        enter(node, _key, parent) {\n          // Store each variable that's referenced as part of an argument\n          // (excluding operation definition variables), so we know which\n          // variables are being used. If we later want to remove a variable\n          // we'll fist check to see if it's being used, before continuing with\n          // the removal.\n          if (\n            (parent as VariableDefinitionNode).kind !== 'VariableDefinition'\n          ) {\n            variablesInUse[node.name.value] = true;\n          }\n        },\n      },\n\n      Field: {\n        enter(node) {\n          if (directives && node.directives) {\n            // If `remove` is set to true for a directive, and a directive match\n            // is found for a field, remove the field as well.\n            const shouldRemoveField = directives.some(\n              directive => directive.remove,\n            );\n\n            if (\n              shouldRemoveField &&\n              node.directives &&\n              node.directives.some(getDirectiveMatcher(directives))\n            ) {\n              if (node.arguments) {\n                // Store field argument variables so they can be removed\n                // from the operation definition.\n                node.arguments.forEach(arg => {\n                  if (arg.value.kind === 'Variable') {\n                    variablesToRemove.push({\n                      name: (arg.value as VariableNode).name.value,\n                    });\n                  }\n                });\n              }\n\n              if (node.selectionSet) {\n                // Store fragment spread names so they can be removed from the\n                // docuemnt.\n                getAllFragmentSpreadsFromSelectionSet(node.selectionSet).forEach(\n                  frag => {\n                    fragmentSpreadsToRemove.push({\n                      name: frag.name.value,\n                    });\n                  },\n                );\n              }\n\n              // Remove the field.\n              return null;\n            }\n          }\n        },\n      },\n\n      FragmentSpread: {\n        enter(node) {\n          // Keep track of referenced fragment spreads. This is used to\n          // determine if top level fragment definitions should be removed.\n          fragmentSpreadsInUse[node.name.value] = true;\n        },\n      },\n\n      Directive: {\n        enter(node) {\n          // If a matching directive is found, remove it.\n          if (getDirectiveMatcher(directives)(node)) {\n            return null;\n          }\n        },\n      },\n    }),\n  );\n\n  // If we've removed fields with arguments, make sure the associated\n  // variables are also removed from the rest of the document, as long as they\n  // aren't being used elsewhere.\n  if (\n    modifiedDoc &&\n    filterInPlace(variablesToRemove, v => !variablesInUse[v.name]).length\n  ) {\n    modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);\n  }\n\n  // If we've removed selection sets with fragment spreads, make sure the\n  // associated fragment definitions are also removed from the rest of the\n  // document, as long as they aren't being used elsewhere.\n  if (\n    modifiedDoc &&\n    filterInPlace(fragmentSpreadsToRemove, fs => !fragmentSpreadsInUse[fs.name])\n      .length\n  ) {\n    modifiedDoc = removeFragmentSpreadFromDocument(\n      fragmentSpreadsToRemove,\n      modifiedDoc,\n    );\n  }\n\n  return modifiedDoc;\n}\n\nexport function addTypenameToDocument(doc: DocumentNode): DocumentNode {\n  return visit(checkDocument(doc), {\n    SelectionSet: {\n      enter(node, _key, parent) {\n        // Don't add __typename to OperationDefinitions.\n        if (\n          parent &&\n          (parent as OperationDefinitionNode).kind === 'OperationDefinition'\n        ) {\n          return;\n        }\n\n        // No changes if no selections.\n        const { selections } = node;\n        if (!selections) {\n          return;\n        }\n\n        // If selections already have a __typename, or are part of an\n        // introspection query, do nothing.\n        const skip = selections.some(selection => {\n          return (\n            isField(selection) &&\n            (selection.name.value === '__typename' ||\n              selection.name.value.lastIndexOf('__', 0) === 0)\n          );\n        });\n        if (skip) {\n          return;\n        }\n\n        // If this SelectionSet is @export-ed as an input variable, it should\n        // not have a __typename field (see issue #4691).\n        const field = parent as FieldNode;\n        if (\n          isField(field) &&\n          field.directives &&\n          field.directives.some(d => d.name.value === 'export')\n        ) {\n          return;\n        }\n\n        // Create and return a new SelectionSet with a __typename Field.\n        return {\n          ...node,\n          selections: [...selections, TYPENAME_FIELD],\n        };\n      },\n    },\n  });\n}\n\nconst connectionRemoveConfig = {\n  test: (directive: DirectiveNode) => {\n    const willRemove = directive.name.value === 'connection';\n    if (willRemove) {\n      if (\n        !directive.arguments ||\n        !directive.arguments.some(arg => arg.name.value === 'key')\n      ) {\n        invariant.warn(\n          'Removing an @connection directive even though it does not have a key. ' +\n            'You may want to use the key parameter to specify a store key.',\n        );\n      }\n    }\n\n    return willRemove;\n  },\n};\n\nexport function removeConnectionDirectiveFromDocument(doc: DocumentNode) {\n  return removeDirectivesFromDocument(\n    [connectionRemoveConfig],\n    checkDocument(doc),\n  );\n}\n\nfunction hasDirectivesInSelectionSet(\n  directives: GetDirectiveConfig[],\n  selectionSet: SelectionSetNode,\n  nestedCheck = true,\n): boolean {\n  return (\n    selectionSet &&\n    selectionSet.selections &&\n    selectionSet.selections.some(selection =>\n      hasDirectivesInSelection(directives, selection, nestedCheck),\n    )\n  );\n}\n\nfunction hasDirectivesInSelection(\n  directives: GetDirectiveConfig[],\n  selection: SelectionNode,\n  nestedCheck = true,\n): boolean {\n  if (!isField(selection)) {\n    return true;\n  }\n\n  if (!selection.directives) {\n    return false;\n  }\n\n  return (\n    selection.directives.some(getDirectiveMatcher(directives)) ||\n    (nestedCheck &&\n      hasDirectivesInSelectionSet(\n        directives,\n        selection.selectionSet,\n        nestedCheck,\n      ))\n  );\n}\n\nexport function getDirectivesFromDocument(\n  directives: GetDirectiveConfig[],\n  doc: DocumentNode,\n): DocumentNode {\n  checkDocument(doc);\n\n  let parentPath: string;\n\n  return nullIfDocIsEmpty(\n    visit(doc, {\n      SelectionSet: {\n        enter(node, _key, _parent, path) {\n          const currentPath = path.join('-');\n\n          if (\n            !parentPath ||\n            currentPath === parentPath ||\n            !currentPath.startsWith(parentPath)\n          ) {\n            if (node.selections) {\n              const selectionsWithDirectives = node.selections.filter(\n                selection => hasDirectivesInSelection(directives, selection),\n              );\n\n              if (hasDirectivesInSelectionSet(directives, node, false)) {\n                parentPath = currentPath;\n              }\n\n              return {\n                ...node,\n                selections: selectionsWithDirectives,\n              };\n            } else {\n              return null;\n            }\n          }\n        },\n      },\n    }),\n  );\n}\n\nfunction getArgumentMatcher(config: RemoveArgumentsConfig[]) {\n  return function argumentMatcher(argument: ArgumentNode) {\n    return config.some(\n      (aConfig: RemoveArgumentsConfig) =>\n        argument.value &&\n        argument.value.kind === 'Variable' &&\n        argument.value.name &&\n        (aConfig.name === argument.value.name.value ||\n          (aConfig.test && aConfig.test(argument))),\n    );\n  };\n}\n\nexport function removeArgumentsFromDocument(\n  config: RemoveArgumentsConfig[],\n  doc: DocumentNode,\n): DocumentNode {\n  const argMatcher = getArgumentMatcher(config);\n\n  return nullIfDocIsEmpty(\n    visit(doc, {\n      OperationDefinition: {\n        enter(node) {\n          return {\n            ...node,\n            // Remove matching top level variables definitions.\n            variableDefinitions: node.variableDefinitions.filter(\n              varDef =>\n                !config.some(arg => arg.name === varDef.variable.name.value),\n            ),\n          };\n        },\n      },\n\n      Field: {\n        enter(node) {\n          // If `remove` is set to true for an argument, and an argument match\n          // is found for a field, remove the field as well.\n          const shouldRemoveField = config.some(argConfig => argConfig.remove);\n\n          if (shouldRemoveField) {\n            let argMatchCount = 0;\n            node.arguments.forEach(arg => {\n              if (argMatcher(arg)) {\n                argMatchCount += 1;\n              }\n            });\n            if (argMatchCount === 1) {\n              return null;\n            }\n          }\n        },\n      },\n\n      Argument: {\n        enter(node) {\n          // Remove all matching arguments.\n          if (argMatcher(node)) {\n            return null;\n          }\n        },\n      },\n    }),\n  );\n}\n\nexport function removeFragmentSpreadFromDocument(\n  config: RemoveFragmentSpreadConfig[],\n  doc: DocumentNode,\n): DocumentNode {\n  function enter(\n    node: FragmentSpreadNode | FragmentDefinitionNode,\n  ): null | void {\n    if (config.some(def => def.name === node.name.value)) {\n      return null;\n    }\n  }\n\n  return nullIfDocIsEmpty(\n    visit(doc, {\n      FragmentSpread: { enter },\n      FragmentDefinition: { enter },\n    }),\n  );\n}\n\nfunction getAllFragmentSpreadsFromSelectionSet(\n  selectionSet: SelectionSetNode,\n): FragmentSpreadNode[] {\n  const allFragments: FragmentSpreadNode[] = [];\n\n  selectionSet.selections.forEach(selection => {\n    if (\n      (isField(selection) || isInlineFragment(selection)) &&\n      selection.selectionSet\n    ) {\n      getAllFragmentSpreadsFromSelectionSet(selection.selectionSet).forEach(\n        frag => allFragments.push(frag),\n      );\n    } else if (selection.kind === 'FragmentSpread') {\n      allFragments.push(selection);\n    }\n  });\n\n  return allFragments;\n}\n\n// If the incoming document is a query, return it as is. Otherwise, build a\n// new document containing a query operation based on the selection set\n// of the previous main operation.\nexport function buildQueryFromSelectionSet(\n  document: DocumentNode,\n): DocumentNode {\n  const definition = getMainDefinition(document);\n  const definitionOperation = (<OperationDefinitionNode>definition).operation;\n\n  if (definitionOperation === 'query') {\n    // Already a query, so return the existing document.\n    return document;\n  }\n\n  // Build a new query using the selection set of the main operation.\n  const modifiedDoc = visit(document, {\n    OperationDefinition: {\n      enter(node) {\n        return {\n          ...node,\n          operation: 'query',\n        };\n      },\n    },\n  });\n  return modifiedDoc;\n}\n\n// Remove fields / selection sets that include an @client directive.\nexport function removeClientSetsFromDocument(\n  document: DocumentNode,\n): DocumentNode | null {\n  checkDocument(document);\n\n  let modifiedDoc = removeDirectivesFromDocument(\n    [\n      {\n        test: (directive: DirectiveNode) => directive.name.value === 'client',\n        remove: true,\n      },\n    ],\n    document,\n  );\n\n  // After a fragment definition has had its @client related document\n  // sets removed, if the only field it has left is a __typename field,\n  // remove the entire fragment operation to prevent it from being fired\n  // on the server.\n  if (modifiedDoc) {\n    modifiedDoc = visit(modifiedDoc, {\n      FragmentDefinition: {\n        enter(node) {\n          if (node.selectionSet) {\n            const isTypenameOnly = node.selectionSet.selections.every(\n              selection =>\n                isField(selection) && selection.name.value === '__typename',\n            );\n            if (isTypenameOnly) {\n              return null;\n            }\n          }\n        },\n      },\n    });\n  }\n\n  return modifiedDoc;\n}\n","export const canUseWeakMap = typeof WeakMap === 'function' && !(\n  typeof navigator === 'object' &&\n  navigator.product === 'ReactNative'\n);\n","const { toString } = Object.prototype;\n\n/**\n * Deeply clones a value to create a new instance.\n */\nexport function cloneDeep<T>(value: T): T {\n  return cloneDeepHelper(value, new Map());\n}\n\nfunction cloneDeepHelper<T>(val: T, seen: Map<any, any>): T {\n  switch (toString.call(val)) {\n  case \"[object Array]\": {\n    if (seen.has(val)) return seen.get(val);\n    const copy: T & any[] = (val as any).slice(0);\n    seen.set(val, copy);\n    copy.forEach(function (child, i) {\n      copy[i] = cloneDeepHelper(child, seen);\n    });\n    return copy;\n  }\n\n  case \"[object Object]\": {\n    if (seen.has(val)) return seen.get(val);\n    // High fidelity polyfills of Object.create and Object.getPrototypeOf are\n    // possible in all JS environments, so we will assume they exist/work.\n    const copy = Object.create(Object.getPrototypeOf(val));\n    seen.set(val, copy);\n    Object.keys(val).forEach(key => {\n      copy[key] = cloneDeepHelper((val as any)[key], seen);\n    });\n    return copy;\n  }\n\n  default:\n    return val;\n  }\n}\n","export function getEnv(): string | undefined {\n  if (typeof process !== 'undefined' && process.env.NODE_ENV) {\n    return process.env.NODE_ENV;\n  }\n\n  // default environment\n  return 'development';\n}\n\nexport function isEnv(env: string): boolean {\n  return getEnv() === env;\n}\n\nexport function isProduction(): boolean {\n  return isEnv('production') === true;\n}\n\nexport function isDevelopment(): boolean {\n  return isEnv('development') === true;\n}\n\nexport function isTest(): boolean {\n  return isEnv('test') === true;\n}\n","import { ExecutionResult } from 'graphql';\n\nexport function tryFunctionOrLogError(f: Function) {\n  try {\n    return f();\n  } catch (e) {\n    if (console.error) {\n      console.error(e);\n    }\n  }\n}\n\nexport function graphQLResultHasError(result: ExecutionResult) {\n  return result.errors && result.errors.length;\n}\n","import { isDevelopment, isTest } from './environment';\n\n// Taken (mostly) from https://github.com/substack/deep-freeze to avoid\n// import hassles with rollup.\nfunction deepFreeze(o: any) {\n  Object.freeze(o);\n\n  Object.getOwnPropertyNames(o).forEach(function(prop) {\n    if (\n      o[prop] !== null &&\n      (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&\n      !Object.isFrozen(o[prop])\n    ) {\n      deepFreeze(o[prop]);\n    }\n  });\n\n  return o;\n}\n\nexport function maybeDeepFreeze(obj: any) {\n  if (isDevelopment() || isTest()) {\n    // Polyfilled Symbols potentially cause infinite / very deep recursion while deep freezing\n    // which is known to crash IE11 (https://github.com/apollographql/apollo-client/issues/3043).\n    const symbolIsPolyfilled =\n      typeof Symbol === 'function' && typeof Symbol('') === 'string';\n\n    if (!symbolIsPolyfilled) {\n      return deepFreeze(obj);\n    }\n  }\n  return obj;\n}\n","const { hasOwnProperty } = Object.prototype;\n\n// These mergeDeep and mergeDeepArray utilities merge any number of objects\n// together, sharing as much memory as possible with the source objects, while\n// remaining careful to avoid modifying any source objects.\n\n// Logically, the return type of mergeDeep should be the intersection of\n// all the argument types. The binary call signature is by far the most\n// common, but we support 0- through 5-ary as well. After that, the\n// resulting type is just the inferred array element type. Note to nerds:\n// there is a more clever way of doing this that converts the tuple type\n// first to a union type (easy enough: T[number]) and then converts the\n// union to an intersection type using distributive conditional type\n// inference, but that approach has several fatal flaws (boolean becomes\n// true & false, and the inferred type ends up as unknown in many cases),\n// in addition to being nearly impossible to explain/understand.\nexport type TupleToIntersection<T extends any[]> =\n  T extends [infer A] ? A :\n  T extends [infer A, infer B] ? A & B :\n  T extends [infer A, infer B, infer C] ? A & B & C :\n  T extends [infer A, infer B, infer C, infer D] ? A & B & C & D :\n  T extends [infer A, infer B, infer C, infer D, infer E] ? A & B & C & D & E :\n  T extends (infer U)[] ? U : any;\n\nexport function mergeDeep<T extends any[]>(\n  ...sources: T\n): TupleToIntersection<T> {\n  return mergeDeepArray(sources);\n}\n\n// In almost any situation where you could succeed in getting the\n// TypeScript compiler to infer a tuple type for the sources array, you\n// could just use mergeDeep instead of mergeDeepArray, so instead of\n// trying to convert T[] to an intersection type we just infer the array\n// element type, which works perfectly when the sources array has a\n// consistent element type.\nexport function mergeDeepArray<T>(sources: T[]): T {\n  let target = sources[0] || {} as T;\n  const count = sources.length;\n  if (count > 1) {\n    const pastCopies: any[] = [];\n    target = shallowCopyForMerge(target, pastCopies);\n    for (let i = 1; i < count; ++i) {\n      target = mergeHelper(target, sources[i], pastCopies);\n    }\n  }\n  return target;\n}\n\nfunction isObject(obj: any): obj is Record<string | number, any> {\n  return obj !== null && typeof obj === 'object';\n}\n\nfunction mergeHelper(\n  target: any,\n  source: any,\n  pastCopies: any[],\n) {\n  if (isObject(source) && isObject(target)) {\n    // In case the target has been frozen, make an extensible copy so that\n    // we can merge properties into the copy.\n    if (Object.isExtensible && !Object.isExtensible(target)) {\n      target = shallowCopyForMerge(target, pastCopies);\n    }\n\n    Object.keys(source).forEach(sourceKey => {\n      const sourceValue = source[sourceKey];\n      if (hasOwnProperty.call(target, sourceKey)) {\n        const targetValue = target[sourceKey];\n        if (sourceValue !== targetValue) {\n          // When there is a key collision, we need to make a shallow copy of\n          // target[sourceKey] so the merge does not modify any source objects.\n          // To avoid making unnecessary copies, we use a simple array to track\n          // past copies, since it's safe to modify copies created earlier in\n          // the merge. We use an array for pastCopies instead of a Map or Set,\n          // since the number of copies should be relatively small, and some\n          // Map/Set polyfills modify their keys.\n          target[sourceKey] = mergeHelper(\n            shallowCopyForMerge(targetValue, pastCopies),\n            sourceValue,\n            pastCopies,\n          );\n        }\n      } else {\n        // If there is no collision, the target can safely share memory with\n        // the source, and the recursion can terminate here.\n        target[sourceKey] = sourceValue;\n      }\n    });\n\n    return target;\n  }\n\n  // If source (or target) is not an object, let source replace target.\n  return source;\n}\n\nfunction shallowCopyForMerge<T>(value: T, pastCopies: any[]): T {\n  if (\n    value !== null &&\n    typeof value === 'object' &&\n    pastCopies.indexOf(value) < 0\n  ) {\n    if (Array.isArray(value)) {\n      value = (value as any).slice(0);\n    } else {\n      value = {\n        __proto__: Object.getPrototypeOf(value),\n        ...value,\n      };\n    }\n    pastCopies.push(value);\n  }\n  return value;\n}\n","import { isProduction, isTest } from './environment';\n\nconst haveWarned = Object.create({});\n\n/**\n * Print a warning only once in development.\n * In production no warnings are printed.\n * In test all warnings are printed.\n *\n * @param msg The warning message\n * @param type warn or error (will call console.warn or console.error)\n */\nexport function warnOnceInDevelopment(msg: string, type = 'warn') {\n  if (!isProduction() && !haveWarned[msg]) {\n    if (!isTest()) {\n      haveWarned[msg] = true;\n    }\n    if (type === 'error') {\n      console.error(msg);\n    } else {\n      console.warn(msg);\n    }\n  }\n}\n","/**\n * In order to make assertions easier, this function strips `symbol`'s from\n * the incoming data.\n *\n * This can be handy when running tests against `apollo-client` for example,\n * since it adds `symbol`'s to the data in the store. Jest's `toEqual`\n * function now covers `symbol`'s (https://github.com/facebook/jest/pull/3437),\n * which means all test data used in a `toEqual` comparison would also have to\n * include `symbol`'s, to pass. By stripping `symbol`'s from the cache data\n * we can compare against more simplified test data.\n */\nexport function stripSymbols<T>(data: T): T {\n  return JSON.parse(JSON.stringify(data));\n}\n"]}