@khanacademy/graphql-flow 3.1.2 → 3.2.0

package/dist/generateResponseType.js

@@ -4,29 +4,22 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.unionOrInterfaceToFlow = exports.typeToFlow = exports.objectPropertiesToFlow = exports.generateResponseType = exports.generateFragmentType = void 0;
-
 var _generator = _interopRequireDefault(require("@babel/generator"));
-
 var babelTypes = _interopRequireWildcard(require("@babel/types"));
-
 var _utils = require("./utils");
-
 var _enums = require("./enums");
-
-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; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /* eslint-disable no-console */
+
 const generateResponseType = (schema, query, ctx) => {
   const ast = querySelectionToObjectType(ctx, query.selectionSet.selections, query.operation === "mutation" ? schema.typesByName.Mutation : schema.typesByName.Query, query.operation === "mutation" ? "mutation" : "query");
-  return (0, _generator.default)(ast).code;
+  return (0, _generator.default)(ast, {
+    comments: ctx.noComments ? false : true
+  }).code;
 };
-
 exports.generateResponseType = generateResponseType;
-
 const sortedObjectTypeAnnotation = (ctx, properties) => {
   const obj = (0, _utils.objectTypeFromProperties)(properties.sort((a, b) => {
     if (a.type === "TSPropertySignature" && b.type === "TSPropertySignature") {
@@ -34,12 +27,10 @@ const sortedObjectTypeAnnotation = (ctx, properties) => {
       const bName = b.key.type === "Identifier" ? b.key.name : "";
       return aName < bName ? -1 : 1;
     }
-
     return 0;
   }));
   const name = ctx.path.join("_");
   const isTopLevelType = ctx.path.length <= 1;
-
   if (ctx.allObjectTypes != null && !isTopLevelType) {
     ctx.allObjectTypes[name] = obj;
     return babelTypes.tsTypeReference(babelTypes.identifier(name));
@@ -47,11 +38,9 @@ const sortedObjectTypeAnnotation = (ctx, properties) => {
     return obj;
   }
 };
-
 const generateFragmentType = (schema, fragment, ctx) => {
   const onType = fragment.typeCondition.name.value;
   let ast;
-
   if (schema.typesByName[onType]) {
     ast = sortedObjectTypeAnnotation(ctx, objectPropertiesToFlow(ctx, schema.typesByName[onType], onType, fragment.selectionSet.selections));
   } else if (schema.interfacesByName[onType]) {
@@ -61,86 +50,66 @@ const generateFragmentType = (schema, fragment, ctx) => {
   } else {
     throw new Error(`Unknown ${onType}`);
   }
-
-  return (0, _generator.default)(ast).code;
+  return (0, _generator.default)(ast, {
+    comments: ctx.noComments ? false : true
+  }).code;
 };
-
 exports.generateFragmentType = generateFragmentType;
-
 const _typeToFlow = (ctx, type, selection) => {
   if (type.kind === "SCALAR") {
     return (0, _enums.scalarTypeToFlow)(ctx, type.name);
   }
-
   if (type.kind === "LIST") {
     return babelTypes.tsTypeReference(ctx.readOnlyArray ? babelTypes.identifier("ReadonlyArray") : babelTypes.identifier("Array"), babelTypes.tsTypeParameterInstantiation([typeToFlow(ctx, type.ofType, selection)]));
   }
-
   if (type.kind === "UNION") {
     const union = ctx.schema.unionsByName[type.name];
-
     if (!selection.selectionSet) {
       console.log("no selection set", selection);
       return babelTypes.tsAnyKeyword();
     }
-
     return unionOrInterfaceToFlow(ctx, union, selection.selectionSet.selections);
   }
-
   if (type.kind === "INTERFACE") {
     if (!selection.selectionSet) {
       console.log("no selection set", selection);
       return babelTypes.tsAnyKeyword();
     }
-
     return unionOrInterfaceToFlow(ctx, ctx.schema.interfacesByName[type.name], selection.selectionSet.selections);
   }
-
   if (type.kind === "ENUM") {
     return (0, _enums.enumTypeToFlow)(ctx, type.name);
   }
-
   if (type.kind !== "OBJECT") {
     console.log("not object", type);
     return babelTypes.tsAnyKeyword();
   }
-
   const tname = type.name;
-
   if (!ctx.schema.typesByName[tname]) {
     console.log("unknown referenced type", tname);
     return babelTypes.tsAnyKeyword();
   }
-
   const childType = ctx.schema.typesByName[tname];
-
   if (!selection.selectionSet) {
     console.log("no selection set", selection);
     return babelTypes.tsAnyKeyword();
   }
-
   return (0, _utils.maybeAddDescriptionComment)(childType.description, querySelectionToObjectType(ctx, selection.selectionSet.selections, childType, tname));
 };
-
 const typeToFlow = (ctx, type, selection) => {
   // throw new Error('npoe');
   if (type.kind === "NON_NULL") {
     return _typeToFlow(ctx, type.ofType, selection);
-  } // If we don'babelTypes care about strict nullability checking, then pretend everything is non-null
-
-
+  }
+  // If we don'babelTypes care about strict nullability checking, then pretend everything is non-null
   if (!ctx.strictNullability) {
     return _typeToFlow(ctx, type, selection);
   }
-
   const inner = _typeToFlow(ctx, type, selection);
-
   const result = (0, _utils.nullableType)(inner);
   return (0, _utils.transferLeadingComments)(inner, result);
 };
-
 exports.typeToFlow = typeToFlow;
-
 const ensureOnlyOneTypenameProperty = properties => {
   let seenTypeName = false;
   return properties.filter(type => {
@@ -149,104 +118,84 @@ const ensureOnlyOneTypenameProperty = properties => {
     // the extra one here.
     if (type.type === "TSPropertySignature" && type.key.type === "Identifier" && type.key.name === "__typename") {
       var _type$typeAnnotation;
-
       const name = ((_type$typeAnnotation = type.typeAnnotation) === null || _type$typeAnnotation === void 0 ? void 0 : _type$typeAnnotation.typeAnnotation.type) === "TSLiteralType" && type.typeAnnotation.typeAnnotation.literal.type === "StringLiteral" ? type.typeAnnotation.typeAnnotation.literal.value : "INVALID";
-
       if (seenTypeName) {
         if (name !== seenTypeName) {
           throw new Error(`Got two different type names ${name}, ${seenTypeName}`);
         }
-
         return false;
       }
-
       seenTypeName = name;
     }
-
     return true;
   });
 };
-
 const querySelectionToObjectType = (ctx, selections, type, typeName) => {
   return sortedObjectTypeAnnotation(ctx, ensureOnlyOneTypenameProperty(objectPropertiesToFlow(ctx, type, typeName, selections)));
 };
-
 const objectPropertiesToFlow = (ctx, type, typeName, selections) => {
   return selections.flatMap(selection => {
     switch (selection.kind) {
       case "InlineFragment":
         {
           var _selection$typeCondit, _selection$typeCondit2;
-
           const newTypeName = (_selection$typeCondit = (_selection$typeCondit2 = selection.typeCondition) === null || _selection$typeCondit2 === void 0 ? void 0 : _selection$typeCondit2.name.value) !== null && _selection$typeCondit !== void 0 ? _selection$typeCondit : typeName;
-
           if (newTypeName !== typeName) {
             return [];
           }
-
           return objectPropertiesToFlow(ctx, ctx.schema.typesByName[newTypeName], newTypeName, selection.selectionSet.selections);
         }
-
       case "FragmentSpread":
         if (!ctx.fragments[selection.name.value]) {
           ctx.errors.push(`No fragment named '${selection.name.value}'. Did you forget to include it in the template literal?`);
           return [babelTypes.tsPropertySignature(babelTypes.identifier(selection.name.value), babelTypes.tsTypeAnnotation(babelTypes.tsTypeReference(babelTypes.identifier(`UNKNOWN_FRAGMENT`))))];
         }
-
         return objectPropertiesToFlow(ctx, type, typeName, ctx.fragments[selection.name.value].selectionSet.selections);
-
       case "Field":
         const name = selection.name.value;
         const alias = selection.alias ? selection.alias.value : name;
-
         if (name === "__typename") {
           return [babelTypes.tsPropertySignature(babelTypes.identifier(alias), babelTypes.tsTypeAnnotation(babelTypes.tsLiteralType(babelTypes.stringLiteral(typeName))))];
         }
-
         if (!type.fieldsByName[name]) {
           ctx.errors.push(`Unknown field '${name}' for type '${typeName}'`);
           return [babelTypes.tsPropertySignature(babelTypes.identifier(alias), babelTypes.tsTypeAnnotation(babelTypes.tsTypeReference(babelTypes.identifier(`UNKNOWN_FIELD["${name}"]`))))];
         }
-
         const typeField = type.fieldsByName[name];
-        return [(0, _utils.maybeAddDescriptionComment)(typeField.description, (0, _utils.liftLeadingPropertyComments)(babelTypes.tsPropertySignature(babelTypes.identifier(alias), babelTypes.tsTypeAnnotation(typeToFlow({ ...ctx,
+        return [(0, _utils.maybeAddDescriptionComment)(typeField.description, (0, _utils.liftLeadingPropertyComments)(babelTypes.tsPropertySignature(babelTypes.identifier(alias), babelTypes.tsTypeAnnotation(typeToFlow({
+          ...ctx,
           path: ctx.path.concat([alias])
         }, typeField.type, selection)))))];
-
       default:
         ctx.errors.push(`Unsupported selection kind '${selection.kind}'`);
         return [];
     }
   });
 };
-
 exports.objectPropertiesToFlow = objectPropertiesToFlow;
-
 const unionOrInterfaceToFlow = (ctx, type, selections) => {
   const allFields = selections.every(selection => selection.kind === "Field");
   const selectedAttributes = type.possibleTypes.slice().sort((a, b) => {
     return a.name < b.name ? -1 : 1;
   }).map(possible => {
-    const configWithUpdatedPath = { ...ctx,
+    const configWithUpdatedPath = {
+      ...ctx,
       path: allFields ? ctx.path : ctx.path.concat([possible.name])
     };
     return {
       typeName: possible.name,
       attributes: ensureOnlyOneTypenameProperty(selections.map(selection => unionOrInterfaceSelection(configWithUpdatedPath, type, possible, selection)).flat())
     };
-  }); // If they're all fields, the only selection that could be different is __typename
-
+  });
+  // If they're all fields, the only selection that could be different is __typename
   if (allFields) {
     const sharedAttributes = selectedAttributes[0].attributes.slice();
     const typeNameIndex = selectedAttributes[0].attributes.findIndex(x => x.type === "TSPropertySignature" && x.key.type === "Identifier" && x.key.name === "__typename");
-
     if (typeNameIndex !== -1) {
       sharedAttributes[typeNameIndex] = babelTypes.tsPropertySignature(babelTypes.identifier("__typename"), babelTypes.tsTypeAnnotation(babelTypes.tsUnionType(selectedAttributes.map(attrs => attrs.attributes[typeNameIndex].typeAnnotation.typeAnnotation))));
     }
-
     return sortedObjectTypeAnnotation(ctx, sharedAttributes);
   }
-
   if (selectedAttributes.length === 1) {
     return sortedObjectTypeAnnotation(ctx, selectedAttributes[0].attributes);
   }
@@ -280,86 +229,68 @@ const unionOrInterfaceToFlow = (ctx, type, selections) => {
    * ```
    * instead of e.g. `getHuman_me_Human`.
    */
-
-
   const result = babelTypes.tsUnionType(selectedAttributes.map(({
     typeName,
     attributes
-  }) => sortedObjectTypeAnnotation({ ...ctx,
+  }) => sortedObjectTypeAnnotation({
+    ...ctx,
     path: ctx.path.concat([typeName])
   }, attributes)));
   const name = ctx.path.join("_");
-
   if (ctx.allObjectTypes && ctx.path.length > 1) {
     ctx.allObjectTypes[name] = result;
     return babelTypes.tsTypeReference(babelTypes.identifier(name));
   }
-
   return result;
 };
-
 exports.unionOrInterfaceToFlow = unionOrInterfaceToFlow;
-
 const unionOrInterfaceSelection = (config, type, possible, selection) => {
   if (selection.kind === "Field" && selection.name.value === "__typename") {
     const alias = selection.alias ? selection.alias.value : selection.name.value;
     return [babelTypes.tsPropertySignature(babelTypes.identifier(alias), babelTypes.tsTypeAnnotation(babelTypes.tsLiteralType(babelTypes.stringLiteral(possible.name))))];
   }
-
   if (selection.kind === "Field" && type.kind !== "UNION") {
     // this is an interface
     const name = selection.name.value;
     const alias = selection.alias ? selection.alias.value : name;
-
     if (!type.fieldsByName[name]) {
       config.errors.push("Unknown field: " + name + " on type " + type.name + " for possible " + possible.name);
       return [babelTypes.tsPropertySignature(babelTypes.identifier(alias), babelTypes.tsTypeAnnotation(babelTypes.tsTypeReference(babelTypes.identifier(`UNKNOWN_FIELD`))))];
     }
-
     const typeField = type.fieldsByName[name];
-    return [(0, _utils.liftLeadingPropertyComments)(babelTypes.tsPropertySignature(babelTypes.identifier(alias), babelTypes.tsTypeAnnotation(typeToFlow({ ...config,
+    return [(0, _utils.liftLeadingPropertyComments)(babelTypes.tsPropertySignature(babelTypes.identifier(alias), babelTypes.tsTypeAnnotation(typeToFlow({
+      ...config,
       path: config.path.concat([name])
     }, typeField.type, selection))))];
   }
-
   if (selection.kind === "FragmentSpread") {
     const fragment = config.fragments[selection.name.value];
-
     if (!fragment) {
       throw new Error(`Unknown fragment ${selection.name.value}`);
     }
-
     const typeName = fragment.typeCondition.name.value;
-
     if (config.schema.interfacesByName[typeName] && config.schema.interfacesByName[typeName].possibleTypesByName[possible.name] || typeName === possible.name) {
       return fragment.selectionSet.selections.flatMap(selection => unionOrInterfaceSelection(config, config.schema.typesByName[possible.name], possible, selection));
     } else {
       return [];
     }
   }
-
   if (selection.kind !== "InlineFragment") {
     config.errors.push(`union selectors must be inline fragment: found ${selection.kind}`);
-
     if (type.kind === "UNION") {
       config.errors.push(`You're trying to select a field from the union ${type.name},
 but the only field you're allowed to select is "__typename".
 Try using an inline fragment "... on SomeType {}".`);
     }
-
     return [];
   }
-
   if (selection.typeCondition) {
     var _config$schema$interf;
-
     const typeName = selection.typeCondition.name.value;
     const indirectMatch = (_config$schema$interf = config.schema.interfacesByName[typeName]) === null || _config$schema$interf === void 0 ? void 0 : _config$schema$interf.possibleTypesByName[possible.name];
-
     if (typeName !== possible.name && !indirectMatch) {
       return [];
     }
   }
-
   return objectPropertiesToFlow(config, config.schema.typesByName[possible.name], possible.name, selection.selectionSet.selections);
 };

package/dist/generateTypeFiles.js

@@ -4,15 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.processPragmas = exports.indexPrelude = exports.generateTypeFiles = exports.generateTypeFileContents = void 0;
-
 var _fs = _interopRequireDefault(require("fs"));
-
 var _path = _interopRequireDefault(require("path"));
-
 var _ = require(".");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const indexPrelude = regenerateCommand => `// AUTOGENERATED
 // NOTE: New response types are added to this file automatically.
 //       Outdated response types can be removed manually as they are deprecated.
@@ -20,26 +15,22 @@ const indexPrelude = regenerateCommand => `// AUTOGENERATED
 //
 
 `;
-
 exports.indexPrelude = indexPrelude;
+const generateTypeFileContents = (fileName, schema, document, options, generatedDir, originalIndexContents) => {
+  let indexContents = originalIndexContents;
+  const files = {};
 
-const generateTypeFileContents = (fileName, schema, document, options, generatedDir, indexContents) => {
-  const files = {}; /// Write export for __generated__/index.ts if it doesn't exist
-
+  /// Write export for __generated__/index.ts if it doesn't exist
   const addToIndex = (filePath, typeName) => {
-    if (options.typeScript || options.omitFileExtensions) {
+    if (options.omitFileExtensions) {
       // Typescript doesn't like file extensions
       filePath = filePath.replace(/\.ts$/, "");
     }
-
-    const newLine = `export type {${typeName}} from './${_path.default.basename(filePath)}';`; // We match the entire new line to avoid issues that can arise from
-    // prefix matches.
-
-    if (indexContents.indexOf(newLine) === -1) {
+    const newLine = `export type {${typeName}} from "./${_path.default.basename(filePath)}";`;
+    if (!indexContents.includes(newLine)) {
       indexContents += newLine + "\n";
     }
   };
-
   const generated = (0, _.documentToFlowTypes)(document, schema, options);
   generated.forEach(({
     name,
@@ -52,18 +43,13 @@ const generateTypeFileContents = (fileName, schema, document, options, generated
     // We write all generated files to a `__generated__` subdir to keep
     // things tidy.
     const targetFileName = options.typeFileName ? options.typeFileName.replace("[operationName]", name) : `${name}.ts`;
-
     const targetPath = _path.default.join(generatedDir, targetFileName);
-
     let fileContents = `// AUTOGENERATED -- DO NOT EDIT\n` + `// Generated for operation '${name}' in file '../${_path.default.basename(fileName)}'\n` + (options.regenerateCommand ? `// To regenerate, run '${options.regenerateCommand}'.\n` : "") + code;
-
     if (options.splitTypes && !isFragment) {
       fileContents += `\nexport type ${name} = ${typeName}['response'];\n` + `export type ${name}Variables = ${typeName}['variables'];\n`;
     }
-
     Object.keys(extraTypes).forEach(name => fileContents += `\n\nexport type ${name} = ${extraTypes[name]};`);
     const enumNames = Object.keys(experimentalEnums);
-
     if (options.experimentalEnums && enumNames.length) {
       // TODO(somewhatabstract, FEI-4172): Update to fixed eslint-plugin-flowtype
       // and remove this disable.
@@ -71,9 +57,9 @@ const generateTypeFileContents = (fileName, schema, document, options, generated
       enumNames.forEach(name => fileContents += `\nexport ${experimentalEnums[name]};\n`);
       fileContents += `/* eslint-enable no-undef */`;
     }
-
     addToIndex(targetPath, typeName);
-    files[targetPath] = fileContents // Remove whitespace from the ends of lines; babel's generate sometimes
+    files[targetPath] = fileContents
+    // Remove whitespace from the ends of lines; babel's generate sometimes
     // leaves them hanging around.
     .replace(/\s+$/gm, "") + "\n";
   });
@@ -82,14 +68,10 @@ const generateTypeFileContents = (fileName, schema, document, options, generated
     indexContents
   };
 };
-
 exports.generateTypeFileContents = generateTypeFileContents;
-
 const getGeneratedDir = (fileName, options) => {
   var _options$generatedDir;
-
   const generatedDirectory = (_options$generatedDir = options.generatedDirectory) !== null && _options$generatedDir !== void 0 ? _options$generatedDir : "__generated__";
-
   if (_path.default.isAbsolute(generatedDirectory)) {
     // fileName is absolute here, so we make it relative to cwd
     // for more reasonable filenames.  We convert leading ..'s
@@ -99,49 +81,41 @@ const getGeneratedDir = (fileName, options) => {
     return _path.default.join(_path.default.dirname(fileName), generatedDirectory);
   }
 };
-
-const generateTypeFiles = (fileName, schema, document, options) => {
+const generateTypeFiles = (fileName, schema, document, options, outputFiles) => {
   const generatedDir = getGeneratedDir(fileName, options);
-
   const indexFile = _path.default.join(generatedDir, "index.ts");
-
   if (!_fs.default.existsSync(generatedDir)) {
     _fs.default.mkdirSync(generatedDir, {
       recursive: true
     });
   }
-
-  if (!_fs.default.existsSync(indexFile)) {
-    _fs.default.writeFileSync(indexFile, indexPrelude(options.regenerateCommand));
+  if (!outputFiles[indexFile]) {
+    outputFiles[indexFile] = indexPrelude(options.regenerateCommand);
   }
-
   const {
     indexContents,
     files
-  } = generateTypeFileContents(fileName, schema, document, options, generatedDir, _fs.default.readFileSync(indexFile, "utf8"));
+  } = generateTypeFileContents(fileName, schema, document, options, generatedDir, outputFiles[indexFile]);
 
-  _fs.default.writeFileSync(indexFile, indexContents);
-
-  Object.keys(files).forEach(fname => {
-    _fs.default.writeFileSync(fname, files[fname]);
-  });
+  // Write out files
+  for (const [fname, content] of Object.entries(files)) {
+    outputFiles[fname] = content;
+  }
 
-  _fs.default.writeFileSync(indexFile, indexContents);
+  // Write out index file
+  outputFiles[indexFile] = indexContents;
+  return outputFiles;
 };
-
 exports.generateTypeFiles = generateTypeFiles;
-
 const processPragmas = (generateConfig, crawlConfig, rawSource) => {
   if (crawlConfig.ignorePragma && rawSource.includes(crawlConfig.ignorePragma)) {
     return {
       generate: false
     };
   }
-
   const autogen = crawlConfig.loosePragma ? rawSource.includes(crawlConfig.loosePragma) : false;
   const autogenStrict = crawlConfig.pragma ? rawSource.includes(crawlConfig.pragma) : false;
   const noPragmas = !crawlConfig.loosePragma && !crawlConfig.pragma;
-
   if (autogen || autogenStrict || noPragmas) {
     return {
       generate: true,
@@ -153,5 +127,4 @@ const processPragmas = (generateConfig, crawlConfig, rawSource) => {
     };
   }
 };
-
 exports.processPragmas = processPragmas;

package/dist/generateVariablesType.js

@@ -4,121 +4,86 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.maybeOptionalObjectTypeProperty = exports.inputRefToFlow = exports.inputObjectToFlow = exports.generateVariablesType = void 0;
-
 var _generator = _interopRequireDefault(require("@babel/generator"));
-
 var babelTypes = _interopRequireWildcard(require("@babel/types"));
-
 var _enums = require("./enums");
-
 var _utils = require("./utils");
-
-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; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const inputObjectToFlow = (ctx, name) => {
   const inputObject = ctx.schema.inputObjectsByName[name];
-
   if (!inputObject) {
     ctx.errors.push(`Unknown input object ${name}`);
     return babelTypes.tsLiteralType(babelTypes.stringLiteral(`Unknown input object ${name}`));
   }
-
   return (0, _utils.maybeAddDescriptionComment)(inputObject.description, (0, _utils.objectTypeFromProperties)(inputObject.inputFields.map(vbl => (0, _utils.maybeAddDescriptionComment)(vbl.description, maybeOptionalObjectTypeProperty(vbl.name, inputRefToFlow(ctx, vbl.type, vbl.defaultValue != null))))));
 };
-
 exports.inputObjectToFlow = inputObjectToFlow;
-
 const maybeOptionalObjectTypeProperty = (name, type) => {
   const prop = (0, _utils.liftLeadingPropertyComments)(babelTypes.tsPropertySignature(babelTypes.identifier(name), babelTypes.tsTypeAnnotation(type)));
-
   if ((0, _utils.isnNullableType)(type)) {
     prop.optional = true;
   }
-
   return prop;
 };
-
 exports.maybeOptionalObjectTypeProperty = maybeOptionalObjectTypeProperty;
-
 const inputRefToFlow = (ctx, inputRef, hasDefaultValue = false) => {
   if (inputRef.kind === "NON_NULL") {
     const result = _inputRefToFlow(ctx, inputRef.ofType);
-
     return hasDefaultValue ? (0, _utils.nullableType)(result) : result;
   }
-
   const result = _inputRefToFlow(ctx, inputRef);
-
   return (0, _utils.transferLeadingComments)(result, (0, _utils.nullableType)(result));
 };
-
 exports.inputRefToFlow = inputRefToFlow;
-
 const _inputRefToFlow = (ctx, inputRef) => {
   if (inputRef.kind === "SCALAR") {
     return (0, _enums.scalarTypeToFlow)(ctx, inputRef.name);
   }
-
   if (inputRef.kind === "ENUM") {
     return (0, _enums.enumTypeToFlow)(ctx, inputRef.name);
   }
-
   if (inputRef.kind === "INPUT_OBJECT") {
     return inputObjectToFlow(ctx, inputRef.name);
   }
-
   if (inputRef.kind === "LIST") {
     return babelTypes.tsTypeReference(babelTypes.identifier("ReadonlyArray"), babelTypes.tsTypeParameterInstantiation([inputRefToFlow(ctx, inputRef.ofType)]));
   }
-
   return babelTypes.tsLiteralType(babelTypes.stringLiteral(JSON.stringify(inputRef)));
 };
-
 const variableToFlow = (ctx, type) => {
   if (type.kind === "NonNullType") {
     return _variableToFlow(ctx, type.type);
   }
-
   const result = _variableToFlow(ctx, type);
-
   return (0, _utils.transferLeadingComments)(result, (0, _utils.nullableType)(result));
 };
-
 const _variableToFlow = (ctx, type) => {
   if (type.kind === "NamedType") {
     if (_enums.builtinScalars[type.name.value]) {
       return (0, _enums.scalarTypeToFlow)(ctx, type.name.value);
     }
-
     if (ctx.schema.enumsByName[type.name.value]) {
       return (0, _enums.enumTypeToFlow)(ctx, type.name.value);
     }
-
     const customScalarType = ctx.scalars[type.name.value];
-
     if (customScalarType) {
       return babelTypes.tsTypeReference(babelTypes.identifier(customScalarType));
     }
-
     return inputObjectToFlow(ctx, type.name.value);
   }
-
   if (type.kind === "ListType") {
     return babelTypes.tsTypeReference(babelTypes.identifier("ReadonlyArray"), babelTypes.tsTypeParameterInstantiation([variableToFlow(ctx, type.type)]));
   }
-
   return babelTypes.tsLiteralType(babelTypes.stringLiteral("UNKNOWN" + JSON.stringify(type)));
 };
-
 const generateVariablesType = (schema, item, ctx) => {
   const variableObject = (0, _utils.objectTypeFromProperties)((item.variableDefinitions || []).map(vbl => {
     return maybeOptionalObjectTypeProperty(vbl.variable.name.value, variableToFlow(ctx, vbl.type));
   }));
-  return (0, _generator.default)(variableObject).code;
+  return (0, _generator.default)(variableObject, {
+    comments: ctx.noComments ? false : true
+  }).code;
 };
-
 exports.generateVariablesType = generateVariablesType;