Rename bundle.ts to index.ts

emonkak · Nov 24, 2016 · dd5664f · dd5664f
1 parent 2643803
commit dd5664f
Show file tree

Hide file tree

Showing 71 changed files with 141 additions and 140 deletions.
diff --git a/src/Enumerable.ts b/src/Enumerable.ts
@@ -0,0 +1,4 @@
+import { Enumerable } from './internal/Enumerable';
+
+export default Enumerable;
+
diff --git a/src/bundle.ts b/src/bundle.ts
diff --git a/src/index.ts b/src/index.ts
@@ -1,3 +1,72 @@
 import { Enumerable } from './internal/Enumerable';
 
+import './extensions/aggregate';
+import './extensions/all';
+import './extensions/any';
+import './extensions/average';
+import './extensions/buffer';
+import './extensions/catch';
+import './extensions/concat';
+import './extensions/count';
+import './extensions/defaultIfEmpty';
+import './extensions/distinct';
+import './extensions/distinctUntilChanged';
+import './extensions/do';
+import './extensions/doWhile';
+import './extensions/elementAt';
+import './extensions/elementAtOrDefault';
+import './extensions/except';
+import './extensions/finally';
+import './extensions/first';
+import './extensions/firstOrDefault';
+import './extensions/forEach';
+import './extensions/groupBy';
+import './extensions/groupJoin';
+import './extensions/ignoreElements';
+import './extensions/intersect';
+import './extensions/isEmpty';
+import './extensions/join';
+import './extensions/last';
+import './extensions/lastOrDefault';
+import './extensions/max';
+import './extensions/maxBy';
+import './extensions/memoize';
+import './extensions/min';
+import './extensions/minBy';
+import './extensions/onErrorResumeNext';
+import './extensions/orderBy';
+import './extensions/orderByDescending';
+import './extensions/repeat';
+import './extensions/retry';
+import './extensions/reverse';
+import './extensions/scan';
+import './extensions/select';
+import './extensions/selectMany';
+import './extensions/single';
+import './extensions/singleOrDefault';
+import './extensions/skip';
+import './extensions/skipLast';
+import './extensions/skipWhile';
+import './extensions/startWith';
+import './extensions/static/catch';
+import './extensions/static/concat';
+import './extensions/static/defer';
+import './extensions/static/generate';
+import './extensions/static/if';
+import './extensions/static/range';
+import './extensions/static/repeat';
+import './extensions/static/return';
+import './extensions/static/zip';
+import './extensions/sum';
+import './extensions/take';
+import './extensions/takeLast';
+import './extensions/takeWhile';
+import './extensions/toArray';
+import './extensions/toDictionary';
+import './extensions/toLookup';
+import './extensions/union';
+import './extensions/where';
+import './extensions/while';
+import './extensions/zip';
+
 export default Enumerable;
diff --git a/test/aggregateTest.ts b/test/aggregateTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('aggregate()', () => {
     it('should applies an accumulator function over a sequence', () => {

diff --git a/test/allTest.ts b/test/allTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('all()', () => {
     it('should determines whether all elements of a sequence satisfy a condition', () => {

diff --git a/test/anyTest.ts b/test/anyTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('any()', () => {
     it('should determines whether a sequence contains any elements', () => {

diff --git a/test/averageTest.ts b/test/averageTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('average()', () => {
     it('should computes the average of a sequence of numbers', () => {

diff --git a/test/bufferTest.ts b/test/bufferTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('buffer()', () => {
     it('should generates a sequence of non-overlapping adjacent buffers over the source sequence', () => {

diff --git a/test/catchTest.ts b/test/catchTest.ts
@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('catch()', () => {
     it('should creates a sequence that corresponds to the source sequence', () => {

diff --git a/test/concatTest.ts b/test/concatTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('concat()', () => {
     it('should concatenates two sequences', () => {

diff --git a/test/countTest.ts b/test/countTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('count()', () => {
     it('should returns the number of elements in a sequence', () => {

diff --git a/test/defaultIfEmptyTest.ts b/test/defaultIfEmptyTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('defaultIfEmpty()', () => {
     it('should returns the elements of the specified sequence', () => {

diff --git a/test/distinctTest.ts b/test/distinctTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('distinct()', () => {
     it('should returns distinct elements from a sequence', () => {

diff --git a/test/distinctUntilChangedTest.ts b/test/distinctUntilChangedTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('distinctUntilChanged()', () => {
     it('should returns consecutive distinct elements', () => {

diff --git a/test/doTest.ts b/test/doTest.ts
@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('do()', () => {
     it('should lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination', () => {

diff --git a/test/doWhileTest.ts b/test/doWhileTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('doWhile()', () => {
     it('should generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds', () => {

diff --git a/test/elementAtOrDefaultTest.ts b/test/elementAtOrDefaultTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('elementAtOrDefault()', () => {
     it('should returns the element at a specified index in a sequence', () => {

diff --git a/test/elementAtTest.ts b/test/elementAtTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('elementAt()', () => {
     it('should returns the element at a specified index in a sequence', () => {

diff --git a/test/exceptTest.ts b/test/exceptTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('except()', () => {
     it('should produces the set difference of two sequences', () => {

diff --git a/test/finallyTest.ts b/test/finallyTest.ts
@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('finally()', () => {
     it('should creates a sequence whose termination or disposal of an enumerator causes a finally action to be executed', () => {

diff --git a/test/firstOrDefaultTest.ts b/test/firstOrDefaultTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('firstOrDefault()', () => {
     it('should returns the first element of a sequence', () => {

diff --git a/test/firstTest.ts b/test/firstTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('first()', () => {
     it('should returns the first element of a sequence', () => {

diff --git a/test/forEachTest.ts b/test/forEachTest.ts
@@ -1,5 +1,5 @@
 import * as sinon from 'sinon';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('forEach()', () => {
     it('should enumerates the sequence and invokes the given action for each value in the sequence', () => {

diff --git a/test/groupByTest.ts b/test/groupByTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('groupBy()', () => {
     it('should groups the elements of a sequence according to a specified key selector function', () => {

diff --git a/test/groupJoinTest.ts b/test/groupJoinTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('groupJoin()', () => {
     it('should correlates the elements of two sequences based on equality of keys and groups the results', () => {

diff --git a/test/ignoreElementsTest.ts b/test/ignoreElementsTest.ts
@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('ignoreElements()', () => {
     it('should ignores all elements in the source sequence', () => {

diff --git a/test/intersectTest.ts b/test/intersectTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('intersect()', () => {
     it('should Produces the set intersection of two sequences by using the default equality comparer to compare values', () => {

diff --git a/test/isEmptyTest.ts b/test/isEmptyTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('isEmpty()', () => {
     it('should determines whether an enumerable sequence is empty', () => {

diff --git a/test/joinTest.ts b/test/joinTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('join()', () => {
     it('should correlates the elements of two sequences based on matching keys', () => {

diff --git a/test/lastOrDefaultTest.ts b/test/lastOrDefaultTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('lastOrDefault()', () => {
     it('should returns the last element of a sequence', () => {

diff --git a/test/lastTest.ts b/test/lastTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('last()', () => {
     it('should returns the last element of a sequence', () => {

diff --git a/test/maxByTest.ts b/test/maxByTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('maxBy()', () => {
     it('should returns the elements with the minimum key value by using the default comparer to compare key values', () => {

diff --git a/test/maxTest.ts b/test/maxTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('max()', () => {
     it('should returns the maximum value in a sequence of values', () => {

diff --git a/test/memoizeTest.ts b/test/memoizeTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('memoize()', () => {
     it('should creates a buffer with a view over the source sequence', () => {

diff --git a/test/minByTest.ts b/test/minByTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('minBy()', () => {
     it('should returns the elements with the maximum key value by using the default comparer to compare key values', () => {

diff --git a/test/minTest.ts b/test/minTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('min()', () => {
     it('should returns the minimum value in a sequence of values', () => {

diff --git a/test/onErrorResumeNextTest.ts b/test/onErrorResumeNextTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('onErrorResumeNext()', () => {
     it('should creates a sequence that concatenates both given sequences', () => {

diff --git a/test/orderByDescendingTest.ts b/test/orderByDescendingTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('orderByDescending()', () => {
     it('should sorts the elements of a sequence in ascending order according to a key', () => {