babel-schmooze-sprockets 0.1.2 → 0.1.3

data/node_modules/babel-generator/lib/generators/flow.js

@@ -1,28 +1,28 @@
-/*istanbul ignore next*/"use strict";
+"use strict";
 
 exports.__esModule = true;
-exports.TypeParameterDeclaration = exports.NumericLiteralTypeAnnotation = exports.GenericTypeAnnotation = exports.ClassImplements = undefined;
+exports.TypeParameterDeclaration = exports.StringLiteralTypeAnnotation = exports.NumericLiteralTypeAnnotation = exports.GenericTypeAnnotation = exports.ClassImplements = undefined;
 exports.AnyTypeAnnotation = AnyTypeAnnotation;
-/*istanbul ignore next*/exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
-/*istanbul ignore next*/exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
-/*istanbul ignore next*/exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
-/*istanbul ignore next*/exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
-/*istanbul ignore next*/exports.DeclareClass = DeclareClass;
-/*istanbul ignore next*/exports.DeclareFunction = DeclareFunction;
-/*istanbul ignore next*/exports.DeclareInterface = DeclareInterface;
-/*istanbul ignore next*/exports.DeclareModule = DeclareModule;
-/*istanbul ignore next*/exports.DeclareTypeAlias = DeclareTypeAlias;
-/*istanbul ignore next*/exports.DeclareVariable = DeclareVariable;
-/*istanbul ignore next*/exports.ExistentialTypeParam = ExistentialTypeParam;
-/*istanbul ignore next*/exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
-/*istanbul ignore next*/exports.FunctionTypeParam = FunctionTypeParam;
-/*istanbul ignore next*/exports.InterfaceExtends = InterfaceExtends;
-/*istanbul ignore next*/exports._interfaceish = _interfaceish;
-/*istanbul ignore next*/exports.InterfaceDeclaration = InterfaceDeclaration;
-/*istanbul ignore next*/exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
-/*istanbul ignore next*/exports.MixedTypeAnnotation = MixedTypeAnnotation;
-/*istanbul ignore next*/exports.NullableTypeAnnotation = NullableTypeAnnotation;
-/*istanbul ignore next*/
+exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
+exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
+exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
+exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
+exports.DeclareClass = DeclareClass;
+exports.DeclareFunction = DeclareFunction;
+exports.DeclareInterface = DeclareInterface;
+exports.DeclareModule = DeclareModule;
+exports.DeclareTypeAlias = DeclareTypeAlias;
+exports.DeclareVariable = DeclareVariable;
+exports.ExistentialTypeParam = ExistentialTypeParam;
+exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
+exports.FunctionTypeParam = FunctionTypeParam;
+exports.InterfaceExtends = InterfaceExtends;
+exports._interfaceish = _interfaceish;
+exports.InterfaceDeclaration = InterfaceDeclaration;
+exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
+exports.MixedTypeAnnotation = MixedTypeAnnotation;
+exports.NullableTypeAnnotation = NullableTypeAnnotation;
+
 var _types = require("./types");
 
 Object.defineProperty(exports, "NumericLiteralTypeAnnotation", {
@@ -31,116 +31,134 @@ Object.defineProperty(exports, "NumericLiteralTypeAnnotation", {
     return _types.NumericLiteral;
   }
 });
-/*istanbul ignore next*/exports.NumberTypeAnnotation = NumberTypeAnnotation;
-/*istanbul ignore next*/exports.StringLiteralTypeAnnotation = StringLiteralTypeAnnotation;
-/*istanbul ignore next*/exports.StringTypeAnnotation = StringTypeAnnotation;
-/*istanbul ignore next*/exports.ThisTypeAnnotation = ThisTypeAnnotation;
-/*istanbul ignore next*/exports.TupleTypeAnnotation = TupleTypeAnnotation;
-/*istanbul ignore next*/exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
-/*istanbul ignore next*/exports.TypeAlias = TypeAlias;
-/*istanbul ignore next*/exports.TypeAnnotation = TypeAnnotation;
-/*istanbul ignore next*/exports.TypeParameterInstantiation = TypeParameterInstantiation;
-/*istanbul ignore next*/exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
-/*istanbul ignore next*/exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
-/*istanbul ignore next*/exports.ObjectTypeIndexer = ObjectTypeIndexer;
-/*istanbul ignore next*/exports.ObjectTypeProperty = ObjectTypeProperty;
-/*istanbul ignore next*/exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
-/*istanbul ignore next*/exports.UnionTypeAnnotation = UnionTypeAnnotation;
-/*istanbul ignore next*/exports.TypeCastExpression = TypeCastExpression;
-/*istanbul ignore next*/exports.VoidTypeAnnotation = VoidTypeAnnotation;
-
-var /*istanbul ignore next*/_babelTypes = require("babel-types");
-
-/*istanbul ignore next*/
+Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function get() {
+    return _types.StringLiteral;
+  }
+});
+exports.NumberTypeAnnotation = NumberTypeAnnotation;
+exports.StringTypeAnnotation = StringTypeAnnotation;
+exports.ThisTypeAnnotation = ThisTypeAnnotation;
+exports.TupleTypeAnnotation = TupleTypeAnnotation;
+exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
+exports.TypeAlias = TypeAlias;
+exports.TypeAnnotation = TypeAnnotation;
+exports.TypeParameter = TypeParameter;
+exports.TypeParameterInstantiation = TypeParameterInstantiation;
+exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
+exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
+exports.ObjectTypeIndexer = ObjectTypeIndexer;
+exports.ObjectTypeProperty = ObjectTypeProperty;
+exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
+exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.TypeCastExpression = TypeCastExpression;
+exports.VoidTypeAnnotation = VoidTypeAnnotation;
+
+var _babelTypes = require("babel-types");
+
 var t = _interopRequireWildcard(_babelTypes);
 
-/*istanbul ignore next*/
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
 function AnyTypeAnnotation() {
-  this.push("any");
+  this.word("any");
 } /* eslint max-len: 0 */
 
 function ArrayTypeAnnotation(node) {
   this.print(node.elementType, node);
-  this.push("[");
-  this.push("]");
+  this.token("[");
+  this.token("]");
 }
 
 function BooleanTypeAnnotation() {
-  this.push("bool");
+  this.word("bool");
 }
 
 function BooleanLiteralTypeAnnotation(node) {
-  this.push(node.value ? "true" : "false");
+  this.word(node.value ? "true" : "false");
 }
 
 function NullLiteralTypeAnnotation() {
-  this.push("null");
+  this.word("null");
 }
 
 function DeclareClass(node) {
-  this.push("declare class ");
+  this.word("declare");
+  this.space();
+  this.word("class");
+  this.space();
   this._interfaceish(node);
 }
 
 function DeclareFunction(node) {
-  this.push("declare function ");
+  this.word("declare");
+  this.space();
+  this.word("function");
+  this.space();
   this.print(node.id, node);
   this.print(node.id.typeAnnotation.typeAnnotation, node);
   this.semicolon();
 }
 
 function DeclareInterface(node) {
-  this.push("declare ");
+  this.word("declare");
+  this.space();
   this.InterfaceDeclaration(node);
 }
 
 function DeclareModule(node) {
-  this.push("declare module ");
+  this.word("declare");
+  this.space();
+  this.word("module");
+  this.space();
   this.print(node.id, node);
   this.space();
   this.print(node.body, node);
 }
 
 function DeclareTypeAlias(node) {
-  this.push("declare ");
+  this.word("declare");
+  this.space();
   this.TypeAlias(node);
 }
 
 function DeclareVariable(node) {
-  this.push("declare var ");
+  this.word("declare");
+  this.space();
+  this.word("var");
+  this.space();
   this.print(node.id, node);
   this.print(node.id.typeAnnotation, node);
   this.semicolon();
 }
 
 function ExistentialTypeParam() {
-  this.push("*");
+  this.token("*");
 }
 
 function FunctionTypeAnnotation(node, parent) {
   this.print(node.typeParameters, node);
-  this.push("(");
+  this.token("(");
   this.printList(node.params, node);
 
   if (node.rest) {
     if (node.params.length) {
-      this.push(",");
+      this.token(",");
       this.space();
     }
-    this.push("...");
+    this.token("...");
     this.print(node.rest, node);
   }
 
-  this.push(")");
+  this.token(")");
 
   // this node type is overloaded, not sure why but it makes it EXTREMELY annoying
   if (parent.type === "ObjectTypeProperty" || parent.type === "ObjectTypeCallProperty" || parent.type === "DeclareFunction") {
-    this.push(":");
+    this.token(":");
   } else {
     this.space();
-    this.push("=>");
+    this.token("=>");
   }
 
   this.space();
@@ -149,8 +167,8 @@ function FunctionTypeAnnotation(node, parent) {
 
 function FunctionTypeParam(node) {
   this.print(node.name, node);
-  if (node.optional) this.push("?");
-  this.push(":");
+  if (node.optional) this.token("?");
+  this.token(":");
   this.space();
   this.print(node.typeAnnotation, node);
 }
@@ -160,118 +178,144 @@ function InterfaceExtends(node) {
   this.print(node.typeParameters, node);
 }
 
-/*istanbul ignore next*/exports.ClassImplements = InterfaceExtends;
-/*istanbul ignore next*/exports.GenericTypeAnnotation = InterfaceExtends;
+exports.ClassImplements = InterfaceExtends;
+exports.GenericTypeAnnotation = InterfaceExtends;
 function _interfaceish(node) {
   this.print(node.id, node);
   this.print(node.typeParameters, node);
   if (node.extends.length) {
-    this.push(" extends ");
-    this.printJoin(node.extends, node, { separator: ", " });
+    this.space();
+    this.word("extends");
+    this.space();
+    this.printList(node.extends, node);
   }
   if (node.mixins && node.mixins.length) {
-    this.push(" mixins ");
-    this.printJoin(node.mixins, node, { separator: ", " });
+    this.space();
+    this.word("mixins");
+    this.space();
+    this.printList(node.mixins, node);
   }
   this.space();
   this.print(node.body, node);
 }
 
 function InterfaceDeclaration(node) {
-  this.push("interface ");
+  this.word("interface");
+  this.space();
   this._interfaceish(node);
 }
 
+function andSeparator() {
+  this.space();
+  this.token("&");
+  this.space();
+}
+
 function IntersectionTypeAnnotation(node) {
-  this.printJoin(node.types, node, { separator: " & " });
+  this.printJoin(node.types, node, { separator: andSeparator });
 }
 
 function MixedTypeAnnotation() {
-  this.push("mixed");
+  this.word("mixed");
 }
 
 function NullableTypeAnnotation(node) {
-  this.push("?");
+  this.token("?");
   this.print(node.typeAnnotation, node);
 }
 
 function NumberTypeAnnotation() {
-  this.push("number");
-}
-
-function StringLiteralTypeAnnotation(node) {
-  this.push(this._stringLiteral(node.value));
+  this.word("number");
 }
 
 function StringTypeAnnotation() {
-  this.push("string");
+  this.word("string");
 }
 
 function ThisTypeAnnotation() {
-  this.push("this");
+  this.word("this");
 }
 
 function TupleTypeAnnotation(node) {
-  this.push("[");
-  this.printJoin(node.types, node, { separator: ", " });
-  this.push("]");
+  this.token("[");
+  this.printList(node.types, node);
+  this.token("]");
 }
 
 function TypeofTypeAnnotation(node) {
-  this.push("typeof ");
+  this.word("typeof");
+  this.space();
   this.print(node.argument, node);
 }
 
 function TypeAlias(node) {
-  this.push("type ");
+  this.word("type");
+  this.space();
   this.print(node.id, node);
   this.print(node.typeParameters, node);
   this.space();
-  this.push("=");
+  this.token("=");
   this.space();
   this.print(node.right, node);
   this.semicolon();
 }
 
 function TypeAnnotation(node) {
-  this.push(":");
+  this.token(":");
   this.space();
-  if (node.optional) this.push("?");
+  if (node.optional) this.token("?");
   this.print(node.typeAnnotation, node);
 }
 
+function TypeParameter(node) {
+  if (node.variance === "plus") {
+    this.token("+");
+  } else if (node.variance === "minus") {
+    this.token("-");
+  }
+
+  this.word(node.name);
+
+  if (node.bound) {
+    this.print(node.bound, node);
+  }
+
+  if (node.default) {
+    this.space();
+    this.token("=");
+    this.space();
+    this.print(node.default, node);
+  }
+}
+
 function TypeParameterInstantiation(node) {
-  /*istanbul ignore next*/
   var _this = this;
 
-  this.push("<");
-  this.printJoin(node.params, node, {
-    separator: ", ",
-    iterator: function /*istanbul ignore next*/iterator(node) {
-      /*istanbul ignore next*/_this.print(node.typeAnnotation, node);
+  this.token("<");
+  this.printList(node.params, node, {
+    iterator: function iterator(node) {
+      _this.print(node.typeAnnotation, node);
     }
   });
-  this.push(">");
+  this.token(">");
 }
 
-/*istanbul ignore next*/exports.TypeParameterDeclaration = TypeParameterInstantiation;
+exports.TypeParameterDeclaration = TypeParameterInstantiation;
 function ObjectTypeAnnotation(node) {
-  /*istanbul ignore next*/
   var _this2 = this;
 
-  this.push("{");
+  this.token("{");
   var props = node.properties.concat(node.callProperties, node.indexers);
 
   if (props.length) {
     this.space();
 
     this.printJoin(props, node, {
-      separator: false,
       indent: true,
-      iterator: function /*istanbul ignore next*/iterator() {
+      iterator: function iterator() {
         if (props.length !== 1) {
-          /*istanbul ignore next*/_this2.semicolon();
-          /*istanbul ignore next*/_this2.space();
+          _this2.semicolon();
+          _this2.space();
         }
       }
     });
@@ -279,33 +323,42 @@ function ObjectTypeAnnotation(node) {
     this.space();
   }
 
-  this.push("}");
+  this.token("}");
 }
 
 function ObjectTypeCallProperty(node) {
-  if (node.static) this.push("static ");
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
   this.print(node.value, node);
 }
 
 function ObjectTypeIndexer(node) {
-  if (node.static) this.push("static ");
-  this.push("[");
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
+  this.token("[");
   this.print(node.id, node);
-  this.push(":");
+  this.token(":");
   this.space();
   this.print(node.key, node);
-  this.push("]");
-  this.push(":");
+  this.token("]");
+  this.token(":");
   this.space();
   this.print(node.value, node);
 }
 
 function ObjectTypeProperty(node) {
-  if (node.static) this.push("static ");
+  if (node.static) {
+    this.word("static");
+    this.space();
+  }
   this.print(node.key, node);
-  if (node.optional) this.push("?");
+  if (node.optional) this.token("?");
   if (!t.isFunctionTypeAnnotation(node.value)) {
-    this.push(":");
+    this.token(":");
     this.space();
   }
   this.print(node.value, node);
@@ -313,21 +366,27 @@ function ObjectTypeProperty(node) {
 
 function QualifiedTypeIdentifier(node) {
   this.print(node.qualification, node);
-  this.push(".");
+  this.token(".");
   this.print(node.id, node);
 }
 
+function orSeparator() {
+  this.space();
+  this.token("|");
+  this.space();
+}
+
 function UnionTypeAnnotation(node) {
-  this.printJoin(node.types, node, { separator: " | " });
+  this.printJoin(node.types, node, { separator: orSeparator });
 }
 
 function TypeCastExpression(node) {
-  this.push("(");
+  this.token("(");
   this.print(node.expression, node);
   this.print(node.typeAnnotation, node);
-  this.push(")");
+  this.token(")");
 }
 
 function VoidTypeAnnotation() {
-  this.push("void");
+  this.word("void");
 }