sequenceserver 2.0.0.rc8 → 2.1.0

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/reserved-words-test.js

@@ -1,40 +0,0 @@
-/* */ 
-jest.autoMockOff();
-describe('reserved-words', function() {
-  var transformFn;
-  var visitors;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    visitors = require("../reserved-words-visitors").visitorList;
-    transformFn = require("../../src/jstransform").transform;
-  });
-  function transform(code, opts) {
-    return transformFn(visitors, code, opts).code;
-  }
-  describe('reserved words in member expressions', function() {
-    it('should transform to reserved word members to computed', function() {
-      var code = 'foo.delete;';
-      expect(transform(code)).toEqual('foo["delete"];');
-      code = '(foo++).delete;';
-      expect(transform(code)).toEqual('(foo++)["delete"];');
-    });
-    it('should handle call expressions', function() {
-      var code = 'foo.return();';
-      expect(transform(code)).toEqual('foo["return"]();');
-    });
-    it('should only quote ES3 reserved words', function() {
-      var code = 'foo.await();';
-      expect(transform(code)).toEqual('foo.await();');
-    });
-  });
-  describe('reserved words in properties', function() {
-    it('should quote reserved words in properties', function() {
-      var code = 'var x = {null: 1};';
-      expect(transform(code)).toEqual('var x = {"null": 1};');
-    });
-    it('should only quote ES3 reserved words', function() {
-      var code = 'var x = {await: 1};';
-      expect(transform(code)).toEqual('var x = {await: 1};');
-    });
-  });
-});

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/type-alias-syntax-test.js

@@ -1,34 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('static type syntax syntax', function() {
-  var flowSyntaxVisitors;
-  var jstransform;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    flowSyntaxVisitors = require("../type-syntax").visitorList;
-    jstransform = require("../../src/jstransform");
-  });
-  function transform(code, visitors) {
-    code = jstransform.transform(flowSyntaxVisitors, code.join('\n'), {sourceType: 'nonStrictModule'}).code;
-    if (visitors) {
-      code = jstransform.transform(visitors, code).code;
-    }
-    return code;
-  }
-  describe('type alias', () => {
-    it('strips type aliases', () => {
-      var code = transform(['var type = 42;', 'type FBID = number;', 'type type = string', 'type += 42;']);
-      eval(code);
-      expect(type).toBe(84);
-    });
-    it('strips import-type declarations', () => {
-      var code = transform(['import type DefaultExport from "MyModule";', 'var sanityCheck = 42;']);
-      eval(code);
-      expect(sanityCheck).toBe(42);
-    });
-    it('catches up correctly', () => {
-      var code = transform(["var X = require('X');", 'type FBID = number;']);
-      expect(code).toBe(["var X = require('X');", '                   '].join('\n'));
-    });
-  });
-});

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/type-class-syntax-test.js

@@ -1,105 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('static type class syntax', function() {
-  var classSyntaxVisitors;
-  var visitorList;
-  var flowSyntaxVisitors;
-  var jstransform;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    classSyntaxVisitors = require("../es6-class-visitors").visitorList;
-    flowSyntaxVisitors = require("../type-syntax").visitorList;
-    jstransform = require("../../src/jstransform");
-    visitorList = classSyntaxVisitors;
-  });
-  function transform(code, visitors) {
-    visitors = visitors ? visitorList.concat(visitors) : visitorList;
-    code = jstransform.transform(flowSyntaxVisitors, code.join('\n')).code;
-    return jstransform.transform(visitors, code).code;
-  }
-  describe('param type annotations', () => {
-    it('strips single param annotation', () => {
-      var code = transform(['class Foo {', '  method1(param1: bool) {', '    return param1;', '  }', '}', '', 'var Bar = class {', '  method1(param1: bool) {', '    return param1;', '  }', '}']);
-      eval(code);
-      expect((new Foo()).method1(42)).toBe(42);
-      expect((new Bar()).method1(42)).toBe(42);
-    });
-    it('strips multiple param annotations', () => {
-      var code = transform(['class Foo {', '  method1(param1: bool, param2: number) {', '    return [param1, param2];', '  }', '}', '', 'var Bar = class {', '  method1(param1: bool, param2: number) {', '    return [param1, param2];', '  }', '}']);
-      eval(code);
-      expect((new Foo()).method1(true, 42)).toEqual([true, 42]);
-      expect((new Bar()).method1(true, 42)).toEqual([true, 42]);
-    });
-    it('strips higher-order param annotations', () => {
-      var code = transform(['class Foo {', '  method1(param1: (_:bool) => number) {', '    return param1;', '  }', '}', '', 'var Bar = class {', '  method1(param1: (_:bool) => number) {', '    return param1;', '  }', '}']);
-      eval(code);
-      var callback = function(param) {
-        return param ? 42 : 0;
-      };
-      expect((new Foo()).method1(callback)).toBe(callback);
-      expect((new Bar()).method1(callback)).toBe(callback);
-    });
-    it('strips annotated params next to non-annotated params', () => {
-      var code = transform(['class Foo {', '  method1(param1, param2: number) {', '    return [param1, param2];', '  }', '}', '', 'var Bar = class {', '  method1(param1, param2: number) {', '    return [param1, param2];', '  }', '}']);
-      eval(code);
-      expect((new Foo()).method1('p1', 42)).toEqual(['p1', 42]);
-      expect((new Bar()).method1('p1', 42)).toEqual(['p1', 42]);
-    });
-    it('strips annotated params before a rest parameter', () => {
-      var restParamVisitors = require("../es6-rest-param-visitors").visitorList;
-      var code = transform(['class Foo {', '  method1(param1: number, ...args) {', '    return [param1, args];', '  }', '}', '', 'var Bar = class {', '  method1(param1: number, ...args) {', '    return [param1, args];', '  }', '}'], restParamVisitors);
-      eval(code);
-      expect((new Foo()).method1(42, 43, 44)).toEqual([42, [43, 44]]);
-      expect((new Bar()).method1(42, 43, 44)).toEqual([42, [43, 44]]);
-    });
-  });
-  describe('return type annotations', () => {
-    it('strips method return types', () => {
-      var code = transform(['class Foo {', '  method1(param1:number): () => number {', '    return function() { return param1; };', '  }', '}', '', 'var Bar = class {', '  method1(param1:number): () => number {', '    return function() { return param1; };', '  }', '}']);
-      eval(code);
-      expect((new Foo()).method1(42)()).toBe(42);
-      expect((new Bar()).method1(42)()).toBe(42);
-    });
-  });
-  describe('parametric type annotation', () => {
-    it('strips parametric class type annotations', () => {
-      var code = transform(['class Foo<T> {', '  method1(param1) {', '    return param1;', '  }', '}', '']);
-      eval(code);
-      expect((new Foo()).method1(42)).toBe(42);
-    });
-    it('strips multi-parameter class type annotations', () => {
-      var code = transform(['class Foo<T,S> {', '  method1(param1) {', '    return param1;', '  }', '}', '']);
-      eval(code);
-      expect((new Foo()).method1(42)).toBe(42);
-    });
-    it('strips parametric method type annotations', () => {
-      var code = transform(['class Foo<T> {', '  method1<T>(param1) {', '    return param1;', '  }', '}', '']);
-      eval(code);
-      expect((new Foo()).method1(42)).toBe(42);
-    });
-    it('strips multi-parameter class type annotations', () => {
-      var code = transform(['class Foo<T,S> {', '  method1<T,S>(param1) {', '    return param1;', '  }', '}', '']);
-      eval(code);
-      expect((new Foo()).method1(42)).toBe(42);
-    });
-  });
-  describe('class property annotations', () => {
-    it('strips single class property', () => {
-      var code = transform(['class Foo {', '  prop1: T;', '}']);
-      eval(code);
-      expect((new Foo()).prop1).toEqual(undefined);
-    });
-    it('strips multiple adjacent class properties', () => {
-      var code = transform(['class Foo {', '  prop1: T;', '  prop2: U;', '}']);
-      eval(code);
-      expect((new Foo()).prop1).toEqual(undefined);
-      expect((new Foo()).prop2).toEqual(undefined);
-    });
-    it('strips class properties between methods', () => {
-      var code = transform(['class Foo {', '  method1() {}', '  prop1: T;', '  method2() {}', '  prop2: U;', '  method3() {}', '}']);
-      eval(code);
-      expect((new Foo()).prop1).toEqual(undefined);
-      expect((new Foo()).prop2).toEqual(undefined);
-    });
-  });
-});

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/type-function-syntax-test.js

@@ -1,126 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('static type function syntax', function() {
-  var flowSyntaxVisitors;
-  var jstransform;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    flowSyntaxVisitors = require("../type-syntax").visitorList;
-    jstransform = require("../../src/jstransform");
-  });
-  function transform(code, visitors) {
-    code = code.join('\n');
-    code = jstransform.transform(flowSyntaxVisitors, code).code;
-    if (visitors) {
-      code = jstransform.transform(visitors, code).code;
-    }
-    return code;
-  }
-  describe('param type annotations', () => {
-    it('strips single param annotation', () => {
-      var code = transform(['function foo(param1: bool) {', '  return param1;', '}', '', 'var bar = function(param1: bool) {', '  return param1;', '}']);
-      eval(code);
-      expect(foo(42)).toBe(42);
-      expect(bar(42)).toBe(42);
-    });
-    it('strips multiple param annotations', () => {
-      var code = transform(['function foo(param1: bool, param2: number) {', '  return [param1, param2];', '}', '', 'var bar = function(param1: bool, param2: number) {', '  return [param1, param2];', '}']);
-      eval(code);
-      expect(foo(true, 42)).toEqual([true, 42]);
-      expect(bar(true, 42)).toEqual([true, 42]);
-    });
-    it('strips higher-order param annotations', () => {
-      var code = transform(['function foo(param1: (_:bool) => number) {', '  return param1;', '}', '', 'var bar = function(param1: (_:bool) => number) {', '  return param1;', '}']);
-      eval(code);
-      var callback = function(param) {
-        return param ? 42 : 0;
-      };
-      expect(foo(callback)).toBe(callback);
-      expect(bar(callback)).toBe(callback);
-    });
-    it('strips annotated params next to non-annotated params', () => {
-      var code = transform(['function foo(param1, param2: number) {', '  return [param1, param2];', '}', '', 'var bar = function(param1, param2: number) {', '  return [param1, param2];', '}']);
-      eval(code);
-      expect(foo('p1', 42)).toEqual(['p1', 42]);
-      expect(bar('p1', 42)).toEqual(['p1', 42]);
-    });
-    it('strips annotated params before a rest parameter', () => {
-      var restParamVisitors = require("../es6-rest-param-visitors").visitorList;
-      var code = transform(['function foo(param1: number, ...args) {', '  return [param1, args];', '}', '', 'var bar = function(param1: number, ...args) {', '  return [param1, args];', '}'], restParamVisitors);
-      eval(code);
-      expect(foo(42, 43, 44)).toEqual([42, [43, 44]]);
-      expect(bar(42, 43, 44)).toEqual([42, [43, 44]]);
-    });
-    it('strips annotated rest parameter', () => {
-      var restParamVisitors = require("../es6-rest-param-visitors").visitorList;
-      var code = transform(['function foo(param1: number, ...args: Array<number>) {', '  return [param1, args];', '}', '', 'var bar = function(param1: number, ...args: Array<number>) {', '  return [param1, args];', '}'], restParamVisitors);
-      eval(code);
-      expect(foo(42, 43, 44)).toEqual([42, [43, 44]]);
-      expect(bar(42, 43, 44)).toEqual([42, [43, 44]]);
-    });
-    it('strips optional param marker without type annotation', () => {
-      var code = transform(['function foo(param1?, param2 ?) {', '  return 42;', '}']);
-      eval(code);
-      expect(foo()).toBe(42);
-    });
-    it('strips optional param marker with type annotation', () => {
-      var code = transform(['function foo(param1?:number, param2 ?: string, param3 ? : bool) {', '  return 42;', '}']);
-      eval(code);
-      expect(foo()).toBe(42);
-    });
-  });
-  describe('return type annotations', () => {
-    it('strips function return types', () => {
-      var code = transform(['function foo(param1:number): () => number {', '  return function() { return param1; };', '}', '', 'var bar = function(param1:number): () => number {', '  return function() { return param1; };', '}']);
-      eval(code);
-      expect(foo(42)()).toBe(42);
-      expect(bar(42)()).toBe(42);
-    });
-    it('strips void return types', () => {
-      var code = transform(['function foo(param1): void {', '  param1();', '}', '', 'var bar = function(param1): void {', '  param1();', '}']);
-      eval(code);
-      var counter = 0;
-      function testFn() {
-        counter++;
-      }
-      foo(testFn);
-      expect(counter).toBe(1);
-      bar(testFn);
-      expect(counter).toBe(2);
-    });
-    it('strips void return types with rest params', () => {
-      var code = transform(['function foo(param1, ...rest): void {', '  param1();', '}', '', 'var bar = function(param1, ...rest): void {', '  param1();', '}'], require("../es6-rest-param-visitors").visitorList);
-      eval(code);
-      var counter = 0;
-      function testFn() {
-        counter++;
-      }
-      foo(testFn);
-      expect(counter).toBe(1);
-      bar(testFn);
-      expect(counter).toBe(2);
-    });
-    it('strips object return types', () => {
-      var code = transform(['function foo(param1:number): {num: number} {', '  return {num: param1};', '}', '', 'var bar = function(param1:number): {num: number} {', '  return {num: param1};', '}']);
-      eval(code);
-      expect(foo(42)).toEqual({num: 42});
-      expect(bar(42)).toEqual({num: 42});
-    });
-  });
-  describe('parametric type annotation', () => {
-    it('strips parametric type annotations', () => {
-      var code = transform(['function foo<T>(param1) {', '  return param1;', '}', '', 'var bar = function<T>(param1) {', '  return param1;', '}']);
-      eval(code);
-      expect(foo(42)).toBe(42);
-      expect(bar(42)).toBe(42);
-    });
-    it('strips multi-parameter type annotations', () => {
-      var restParamVisitors = require("../es6-rest-param-visitors").visitorList;
-      var code = transform(['function foo<T, S>(param1) {', '  return param1;', '}', '', 'var bar = function<T,S>(param1) {', '  return param1;', '}'], restParamVisitors);
-      eval(code);
-      expect(foo(42)).toBe(42);
-      expect(bar(42)).toBe(42);
-    });
-  });
-  describe('arrow functions', () => {});
-});

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/type-interface-syntax-test.js

@@ -1,29 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('static type interface syntax', function() {
-  var flowSyntaxVisitors;
-  var jstransform;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    flowSyntaxVisitors = require("../type-syntax").visitorList;
-    jstransform = require("../../src/jstransform");
-  });
-  function transform(code, visitors) {
-    code = jstransform.transform(flowSyntaxVisitors, code.join('\n')).code;
-    if (visitors) {
-      code = jstransform.transform(visitors, code).code;
-    }
-    return code;
-  }
-  describe('Interface Declaration', () => {
-    it('strips interface declarations', () => {
-      var code = transform(['var interface = 42;', 'interface A { foo: () => number; }', 'if (true) interface += 42;', 'interface A<T> extends B, C<T> { foo: () => number; }', 'interface += 42;']);
-      eval(code);
-      expect(interface).toBe(126);
-    });
-    it('catches up correctly', () => {
-      var code = transform(["var X = require('X');", 'interface A { foo: () => number; }']);
-      expect(code).toBe(["var X = require('X');", '                                  '].join('\n'));
-    });
-  });
-});

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/type-object-method-syntax-test.js

@@ -1,65 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('static type object-method syntax', function() {
-  var flowSyntaxVisitors;
-  var jstransform;
-  var visitorList;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    flowSyntaxVisitors = require("../type-syntax").visitorList;
-    jstransform = require("../../src/jstransform");
-    objMethodVisitors = require("../es6-object-concise-method-visitors");
-    visitorList = objMethodVisitors.visitorList;
-  });
-  function transform(code, visitors) {
-    visitors = visitors ? visitorList.concat(visitors) : visitorList;
-    code = jstransform.transform(flowSyntaxVisitors, code.join('\n')).code;
-    code = jstransform.transform(visitors, code).code;
-    return code;
-  }
-  describe('param type annotations', () => {
-    it('strips single param annotation', () => {
-      var code = transform(['var foo = {', '  bar(param1: bool) {', '    return param1;', '  }', '};']);
-      eval(code);
-      expect(foo.bar(42)).toBe(42);
-    });
-    it('strips multiple param annotations', () => {
-      var code = transform(['var foo = {', '  bar(param1: bool, param2: number) {', '    return [param1, param2];', '  }', '};']);
-      eval(code);
-      expect(foo.bar(true, 42)).toEqual([true, 42]);
-    });
-    it('strips higher-order param annotations', () => {
-      var code = transform(['var foo = {', '  bar(param1: (_:bool) => number) {', '    return param1;', '  }', '};']);
-      eval(code);
-      var callback = function(param) {
-        return param ? 42 : 0;
-      };
-      expect(foo.bar(callback)).toBe(callback);
-    });
-    it('strips annotated params next to non-annotated params', () => {
-      var code = transform(['var foo = {', '  bar(param1, param2: number) {', '    return [param1, param2];', '  }', '}']);
-      eval(code);
-      expect(foo.bar('p1', 42)).toEqual(['p1', 42]);
-    });
-    it('strips annotated params before a rest parameter', () => {
-      var restParamVisitors = require("../es6-rest-param-visitors").visitorList;
-      var code = transform(['var foo = {', '  bar(param1: number, ...args) {', '    return [param1, args];', '  }', '}'], restParamVisitors);
-      eval(code);
-      expect(foo.bar(42, 43, 44)).toEqual([42, [43, 44]]);
-    });
-    it('strips annotated rest parameter', () => {
-      var restParamVisitors = require("../es6-rest-param-visitors").visitorList;
-      var code = transform(['var foo = {', '  bar(param1: number, ...args: Array<number>): Array<any> {', '    return [param1, args];', '  }', '}'], restParamVisitors);
-      eval(code);
-      expect(foo.bar(42, 43, 44)).toEqual([42, [43, 44]]);
-    });
-  });
-  describe('return type annotations', () => {
-    it('strips function return types', () => {
-      var code = transform(['var foo = {', '  bar(param1:number): () => number {', '    return function() { return param1; };', '  }', '}']);
-      eval(code);
-      expect(foo.bar(42)()).toBe(42);
-    });
-  });
-  describe('parametric type annotation', () => {});
-});

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/type-pattern-syntax-test.js

@@ -1,45 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('static type pattern syntax', function() {
-  var flowSyntaxVisitors;
-  var jstransform;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    flowSyntaxVisitors = require("../type-syntax").visitorList;
-    jstransform = require("../../src/jstransform");
-    destructuringVisitors = require("../es6-destructuring-visitors");
-    visitorList = destructuringVisitors.visitorList;
-  });
-  function transform(code, visitors) {
-    visitors = visitors ? visitorList.concat(visitors) : visitorList;
-    code = jstransform.transform(flowSyntaxVisitors, code.join('\n')).code;
-    code = jstransform.transform(visitors, code).code;
-    return code;
-  }
-  describe('Object Pattern', () => {
-    it('strips function argument type annotation', () => {
-      var code = transform(['function foo({x, y}: {x: number; y: number}) { return x+y; }', 'var thirty = foo({x: 10, y: 20});']);
-      eval(code);
-      expect(thirty).toBe(30);
-    });
-    it('strips var declaration type annotation', () => {
-      var code = transform(['var {x, y}: {x: number; y: string} = { x: 42, y: "hello" };']);
-      eval(code);
-      expect(x).toBe(42);
-      expect(y).toBe("hello");
-    });
-  });
-  describe('Array Pattern', () => {
-    it('strips function argument type annotation', () => {
-      var code = transform(['function foo([x, y]: Array<number>) { return x+y; }', 'var thirty = foo([10, 20]);']);
-      eval(code);
-      expect(thirty).toBe(30);
-    });
-    it('strips var declaration type annotation', () => {
-      var code = transform(['var [x, y]: Array<number> = [42, "hello"];']);
-      eval(code);
-      expect(x).toBe(42);
-      expect(y).toBe("hello");
-    });
-  });
-});

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/type-syntax-test.js

@@ -1,46 +0,0 @@
-/* */ 
-if (!!module.parent) {
-  module.exports = {
-    'TypeAnnotations': ['function foo(numVal: any){}', 'function foo(numVal: number){}', 'function foo(numVal: number, strVal: string){}', 'function foo(numVal: number, untypedVal){}', 'function foo(untypedVal, numVal: number){}', 'function foo(nullableNum: ?number){}', 'function foo(callback: () => void){}', 'function foo(callback: () => number){}', 'function foo(callback: (_:bool) => number){}', 'function foo(callback: (_1:bool, _2:string) => number){}', 'function foo(callback: (_1:bool, ...foo:Array<number>) => number){}', 'function foo():number{}', 'function foo():() => void{}', 'function foo():(_:bool) => number{}', 'function foo():(_?:bool) => number{}', 'function foo(): {} {}', 'function foo<T>() {}', 'function foo<T: Foo>() {}', 'function foo<T,S>() {}', 'a=function<T,S>() {}', 'a={set fooProp(value:number){}}', 'a={set fooProp(value:number): void{}}', 'a={get fooProp(): number {}}', 'class Foo {set fooProp(value:number){}}', 'class Foo {set fooProp(value:number): void{}}', 'class Foo {get fooProp(): number{}}', 'var numVal:number;', 'var numVal:number = otherNumVal;', 'var a: {numVal: number};', 'var a: {numVal: number;};', 'var a: {numVal: number; [indexer: string]: number};', 'var a: ?{numVal: number};', 'var a: {numVal: number; strVal: string}', 'var a: {subObj: {strVal: string}}', 'var a: {subObj: ?{strVal: string}}', 'var a: {param1: number; param2: string}', 'var a: {param1: number; param2?: string}', 'var a: {add(x:number, ...y:Array<string>): void}', 'var a: { id<T>(x: T): T; }', 'var a:Array<number> = [1, 2, 3]', 'a = class Foo<T> { }', 'a = class Foo<T> extends Bar<T> { }', 'class Foo<T> {}', 'class Foo<T: Bar> {}', 'class Foo<T> extends Bar<T> { }', 'class Foo<T> extends mixin(Bar) { }', 'class Foo<T> { bar<U>():number { return 42; }}', 'class Foo { "bar"<T>() { } }', 'function foo(requiredParam, optParam?) {}', 'class Foo { prop1:string; prop2:number; }', 'var x : number | string = 4;', 'class Array { concat(items:number | string) {}; }', 'var x : () => number | () => string = fn;', 'var x: typeof Y = Y;', 'var x: typeof Y | number = Y;', 'var {x}: {x: string; } = { x: "hello" };', 'var {x}: {x: string } = { x: "hello" };', 'var [x]: Array<string> = [ "hello" ];', 'function foo({x}: { x: string; }) {}', 'function foo([x]: Array<string>) {}', 'function foo(...rest: Array<number>) {}', '(function (...rest: Array<number>) {})', '((...rest: Array<number>) => rest)', 'var a: Map<string, Array<string> >', 'var a: Map<string, Array<string>>', 'var a: number[]', 'var a: ?string[]', 'var a: Promise<bool>[]', 'var a:(...rest:Array<number>) => number'],
-    'Type Alias': ['type FBID = number;', 'type Foo<T> = Bar<T>'],
-    'Interfaces': ['interface A {}', 'interface A extends B {}', 'interface A<T> extends B<T>, C<T> {}', 'interface A { foo: () => number; }', 'interface Dictionary { [index: string]: string; length: number; }', 'class Foo implements Bar {}', 'class Foo extends Bar implements Bat, Man<number> {}', 'class Foo extends class Bar implements Bat {} {}', 'class Foo extends class Bar implements Bat {} implements Man {}'],
-    'Type Grouping': ['var a: (number)', 'var a: (() => number) | () => string', 'var a: number & (string | bool)', 'var a: (typeof A)'],
-    'XJS': ['<a />', '<n:a n:v />', '<a n:foo="bar"> {value} <b><c /></b></a>', '<a b={" "} c=" " d="&amp;" e="id=1&group=2" f="&#123456789" g="&#123*;" h="&#x;" />', '<a\n/>', '<日本語></日本語>', '<AbC-def\n  test="&#x0026;&#38;">\nbar\nbaz\r\n</AbC-def>', '<a b={x ? <c /> : <d />} />', '<a>{}</a>', '<a>{/* this is a comment */}</a>', '<div>@test content</div>', '<div><br />7x invalid-js-identifier</div>', '<LeftRight left=<a /> right=<b>monkeys</b> />', '<a.b></a.b>', '<a.b.c></a.b.c>', '(<div />) < x;', '<div {...props} />', '<div {...props} post="attribute" />', '<div pre="leading" pre2="attribute" {...props}></div>', '<a>    </a>'],
-    'Call Properties': ['var a : { (): number }', 'var a : { (): number; }', 'var a : { (): number; y: string; (x: string): string }', 'var a : { <T>(x: T): number; }', 'interface A { (): number; }'],
-    'String Literal Types': ['function createElement(tagName: "div"): HTMLDivElement {}', 'function createElement(tagName: \'div\'): HTMLDivElement {}'],
-    'Qualified Generic Type': ['var a : A.B', 'var a : A.B.C', 'var a : A.B<T>', 'var a : typeof A.B<T>'],
-    'Declare Statements': ['declare var foo', 'declare var foo;', 'declare function foo(): void', 'declare function foo(): void;', 'declare function foo<T>(): void;', 'declare function foo(x: number, y: string): void;', 'declare class A {}', 'declare class A<T> extends B<T> { x: number }', 'declare class A { static foo(): number; static x : string }', 'declare class A { static [ indexer: number]: string }', 'declare class A { static () : number }'],
-    'Declare Module': ['declare module A {}', 'declare module "./a/b.js" {}', 'declare module A { declare var x: number; }', 'declare module A { declare function foo(): number; }', 'declare module A { declare class B { foo(): number; } }'],
-    'Typecasts': ['(xxx: number)', '({xxx: 0, yyy: "hey"}: {xxx: number; yyy: string})', '((xxx) => xxx + 1: (xxx: number) => number)', '((xxx: number), (yyy: string))', '((xxx: any): number)']
-  };
-} else {
-  require("mock-modules").autoMockOff();
-  var tests = require("./gen/type-syntax-test.rec");
-  var jstransform = require("../../src/jstransform");
-  var visitors = require("../type-syntax").visitorList;
-  describe('transforms match expectations', function() {
-    for (var section in tests) {
-      for (var test in tests[section]) {
-        it('transforms "' + test + '"', function(section, test) {
-          return function() {
-            var transformed = jstransform.transform(visitors, test).code;
-            expect(transformed).toBe(tests[section][test].transformed);
-          };
-        }(section, test));
-        it('evals "' + test + '"', function(section, test) {
-          return function() {
-            var evalResult;
-            var transformed = jstransform.transform(visitors, test).code;
-            try {
-              eval(transformed);
-              evalResult = "No error";
-            } catch (e) {
-              evalResult = e.message;
-            }
-            expect(evalResult).toBe(tests[section][test].eval);
-          };
-        }(section, test));
-      }
-    }
-  });
-}

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/type-variable-declaration-syntax-test.js

@@ -1,102 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('static type variable declaration syntax', function() {
-  var flowSyntaxVisitors;
-  var jstransform;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    flowSyntaxVisitors = require("../type-syntax").visitorList;
-    jstransform = require("../../src/jstransform");
-  });
-  function transform(code, visitors) {
-    code = code.join('\n');
-    code = jstransform.transform(flowSyntaxVisitors, code).code;
-    if (visitors) {
-      code = jstransform.transform(visitors, code).code;
-    }
-    return code;
-  }
-  describe('basic annotations', () => {
-    it('strips single annotated declarator without initializer', () => {
-      var code = transform(['var myNum = 42;', 'function foo() {', '  var myNum:number;', '  return myNum;', '}']);
-      eval(code);
-      expect(foo()).toBe(undefined);
-    });
-    it('strips single annotated declarator with initializer', () => {
-      var code = transform(['var myNum:number = 42;']);
-      eval(code);
-      expect(myNum).toBe(42);
-    });
-    it('strips single annotated nullable declarator with initializer', () => {
-      var code = transform(['var myNum:?number = 42;']);
-      eval(code);
-      expect(myNum).toBe(42);
-    });
-    it('strips single annotated nullable declarator without initializer', () => {
-      var code = transform(['var myNum:?number;', 'myNum = null;']);
-      eval(code);
-      expect(myNum).toBe(null);
-    });
-    it('strips multiple annotation declarations without initializers', () => {
-      var code = transform(['var num1 = 42;', 'var num2 = 43;', 'function foo() {', '  var num1:number, num2:number;', '  return [num1, num2];', '}']);
-      eval(code);
-      expect(foo()).toEqual([undefined, undefined]);
-    });
-    it('strips multiple annotation declarations without initializers', () => {
-      var code = transform(['var num1:number = 42, num2:number = 43;']);
-      eval(code);
-      expect(num1).toBe(42);
-      expect(num2).toBe(43);
-    });
-  });
-  describe('function type annotations', () => {
-    it('strips function type annotations without initializer', () => {
-      var code = transform(['var myFunc = function() { return "NOPE"; };', 'function foo() {', '  var myFunc:(_:bool) => number;', '  return myFunc;', '}']);
-      eval(code);
-      expect(foo()).toBe(undefined);
-    });
-    it('strips function type annotations with initializer', () => {
-      var code = transform(['var myFunc:(_:bool) => number = function(p1) {', '  return 42;', '};']);
-      eval(code);
-      expect(myFunc()).toBe(42);
-    });
-  });
-  describe('object type annotations', () => {
-    it('strips empty object type annotations without initializer', () => {
-      var code = transform(['var myObj = "NOPE";', 'function foo() {', '  var myObj:{};', '  return myObj;', '}']);
-      eval(code);
-      expect(foo()).toBe(undefined);
-    });
-    it('strips empty object type annotations with initializer', () => {
-      var code = transform(['var myObj:{} = {YEP: true};']);
-      eval(code);
-      expect(myObj.YEP).toBe(true);
-    });
-    it('strips empty nullable object type annotations with initializer', () => {
-      var code = transform(['var myObj:?{} = {YEP: true};']);
-      eval(code);
-      expect(myObj.YEP).toBe(true);
-    });
-    it('strips object type with basic property annotation', () => {
-      var code = transform(['var myObj:{arrProp:Array} = {YEP: [true]};']);
-      eval(code);
-      expect(myObj.YEP).toEqual([true]);
-    });
-    it('strips object type with multiple property annotations', () => {
-      var code = transform(['var myObj:{numProp: number; strProp: string} = {', '  numProp: 42,', '  strProp: "YEP"', '};']);
-      eval(code);
-      expect(myObj.numProp).toBe(42);
-      expect(myObj.strProp).toBe("YEP");
-    });
-    it('strips object type with parametric property annotation', () => {
-      var code = transform(['var myObj:{arrProp:Array<bool>} = {YEP: [true]};']);
-      eval(code);
-      expect(myObj.YEP).toEqual([true]);
-    });
-    it('strips object type with function property annotation', () => {
-      var code = transform(['var myObj:{myMethod:() => void} = {', '  myMethod: function() {', '    return 42;', '  }', '};']);
-      eval(code);
-      expect(myObj.myMethod()).toBe(42);
-    });
-  });
-});