function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/* eslint-disable no-use-before-define */
import { GraphQLScalarType, GraphQLList, GraphQLNonNull, valueFromASTUntyped } from './graphql';
import { isObject, isString } from './utils/is';
import { SchemaComposer } from './SchemaComposer';
import { inspect } from './utils/misc';
export class ScalarTypeComposer {
  static create(typeDef, schemaComposer) {
    if (!(schemaComposer instanceof SchemaComposer)) {
      throw new Error('You must provide SchemaComposer instance as a second argument for `ScalarTypeComposer.create(typeDef, schemaComposer)`');
    }

    const stc = this.createTemp(typeDef, schemaComposer);
    schemaComposer.add(stc);
    return stc;
  }

  static createTemp(typeDef, schemaComposer) {
    const sc = schemaComposer || new SchemaComposer();
    let STC;

    if (isString(typeDef)) {
      const typeName = typeDef;
      const NAME_RX = /^[_a-zA-Z][_a-zA-Z0-9]*$/;

      if (NAME_RX.test(typeName)) {
        STC = new ScalarTypeComposer(new GraphQLScalarType({
          name: typeName,
          serialize: () => {}
        }), sc);
      } else {
        STC = sc.typeMapper.createType(typeName);

        if (!(STC instanceof ScalarTypeComposer)) {
          throw new Error('You should provide correct GraphQLScalarType type definition. Eg. `scalar UInt`');
        }
      }
    } else if (typeDef instanceof GraphQLScalarType) {
      STC = new ScalarTypeComposer(typeDef, sc);
    } else if (isObject(typeDef)) {
      const type = new GraphQLScalarType(_objectSpread({}, typeDef));
      STC = new ScalarTypeComposer(type, sc);
      STC.gqType._gqcExtensions = typeDef.extensions || {};
    } else {
      throw new Error(`You should provide GraphQLScalarTypeConfig or string with scalar name or SDL. Provided:\n${inspect(typeDef)}`);
    }

    return STC;
  }

  constructor(gqType, schemaComposer) {
    if (!(schemaComposer instanceof SchemaComposer)) {
      throw new Error('You must provide SchemaComposer instance as a second argument for `new ScalarTypeComposer(GraphQLScalarType, SchemaComposer)`');
    }

    this.schemaComposer = schemaComposer;

    if (!(gqType instanceof GraphQLScalarType)) {
      throw new Error('ScalarTypeComposer accept only GraphQLScalarType in constructor');
    }

    this.gqType = gqType; // alive proper Flow type casting in autosuggestions for class with Generics

    /* :: return this; */
  } // -----------------------------------------------
  // Serialize methods
  // -----------------------------------------------


  setSerialize(fn) {
    this.gqType.serialize = fn;
  }

  getSerialize() {
    return this.gqType.serialize;
  }

  setParseValue(fn) {
    this.gqType.parseValue = fn || (value => value);
  }

  getParseValue() {
    return this.gqType.parseValue;
  }

  setParseLiteral(fn) {
    this.gqType.parseLiteral = fn || valueFromASTUntyped;
  }

  getParseLiteral() {
    return this.gqType.parseLiteral;
  } // -----------------------------------------------
  // Type methods
  // -----------------------------------------------


  getType() {
    return this.gqType;
  }

  getTypePlural() {
    return new GraphQLList(this.gqType);
  }

  getTypeNonNull() {
    return new GraphQLNonNull(this.gqType);
  }

  getTypeName() {
    return this.gqType.name;
  }

  setTypeName(name) {
    this.gqType.name = name;
    this.schemaComposer.add(this);
    return this;
  }

  getDescription() {
    return this.gqType.description || '';
  }

  setDescription(description) {
    this.gqType.description = description;
    return this;
  }

  clone(newTypeName) {
    if (!newTypeName) {
      throw new Error('You should provide newTypeName:string for ScalarTypeComposer.clone()');
    }

    const cloned = new ScalarTypeComposer(new GraphQLScalarType({
      name: newTypeName,
      serialize: this.getSerialize(),
      parseValue: this.getParseValue(),
      parseLiteral: this.getParseLiteral()
    }), this.schemaComposer);
    cloned.setDescription(this.getDescription());
    return cloned;
  }

  merge(type) {
    if (type instanceof GraphQLScalarType) {
      this.setSerialize(type.serialize);
      this.setParseValue(type.parseValue);
      this.setParseLiteral(type.parseLiteral);
    } else if (type instanceof ScalarTypeComposer) {
      this.setSerialize(type.getSerialize());
      this.setParseValue(type.getParseValue());
      this.setParseLiteral(type.getParseLiteral());
    } else {
      throw new Error(`Cannot merge ${inspect(type)} with ScalarType(${this.getTypeName()}). Provided type should be GraphQLScalarType or ScalarTypeComposer.`);
    }

    return this;
  } // -----------------------------------------------
  // Extensions methods
  // -----------------------------------------------


  getExtensions() {
    if (!this.gqType._gqcExtensions) {
      return {};
    } else {
      return this.gqType._gqcExtensions;
    }
  }

  setExtensions(extensions) {
    this.gqType._gqcExtensions = extensions;
    return this;
  }

  extendExtensions(extensions) {
    const current = this.getExtensions();
    this.setExtensions(_objectSpread({}, current, extensions));
    return this;
  }

  clearExtensions() {
    this.setExtensions({});
    return this;
  }

  getExtension(extensionName) {
    const extensions = this.getExtensions();
    return extensions[extensionName];
  }

  hasExtension(extensionName) {
    const extensions = this.getExtensions();
    return extensionName in extensions;
  }

  setExtension(extensionName, value) {
    this.extendExtensions({
      [extensionName]: value
    });
    return this;
  }

  removeExtension(extensionName) {
    const extensions = _objectSpread({}, this.getExtensions());

    delete extensions[extensionName];
    this.setExtensions(extensions);
    return this;
  } // -----------------------------------------------
  // Directive methods
  // -----------------------------------------------


  getDirectives() {
    const directives = this.getExtension('directives');

    if (Array.isArray(directives)) {
      return directives;
    }

    return [];
  }

  getDirectiveNames() {
    return this.getDirectives().map(d => d.name);
  }

  getDirectiveByName(directiveName) {
    const directive = this.getDirectives().find(d => d.name === directiveName);
    if (!directive) return undefined;
    return directive.args;
  }

  getDirectiveById(idx) {
    const directive = this.getDirectives()[idx];
    if (!directive) return undefined;
    return directive.args;
  }

}