Merge pull request #40 from hg-pyun/version/1.1.0

Version/1.1.0

Author: hg-pyun

.gitignore

@@ -1,4 +1,4 @@
 # Created by .ignore support plugin (hsz.mobi)
 /package-lock.json
 /node_modules/
-/lib/iterize.dev.js
+.idea

.npmignore

@@ -8,3 +8,4 @@
 # Folders
 /.github/
 /node_modules/
+.idea

.prettierrc

@@ -2,5 +2,5 @@
   "trailingComma": "es5",
   "tabWidth": 4,
   "semi": true,
-  "singleQuote": true,
+  "singleQuote": true
 }

README.md

@@ -1,12 +1,12 @@
 # iterize
 
 [![npm](https://img.shields.io/npm/v/iterize.svg)](https://www.npmjs.com/package/iterize)
-![npm](https://img.shields.io/npm/dm/iterize.svg)
+[![npm](https://img.shields.io/npm/dt/iterize.svg)](https://www.npmjs.com/package/iterize)
 [![GitHub license](https://img.shields.io/github/license/hg-pyun/iterize.svg)](https://github.com/hg-pyun/iterize/blob/master/LICENSE)
 
-> Minimalistic JavaScript Iterators
+> Use JavaScript Iterator, Easily 
 
-A great feature called Iterator was added into JavaScript. However, it's a strange concept to most of the front-end developers.
+**iterize** is a minimalistic creator for the iterator. A great feature called Iterator was added into JavaScript. However, it's a strange concept for most of the front-end developers.
 **iterize** helps you create your code more easily and efficiently using the various attributes of the Iterable Protocol.
 
 ## Why Powerful?
@@ -29,46 +29,58 @@ Most functions of **iterize** are implemented as Higher-Order Functions. You can
 $ npm install iterize --save
 ```
 
-# API
-
 You can import **iterize** using ESModule style.
 
 ```js
 import * as iterize from 'iterize';
 ```
-OR
 ```js
 import {range} from 'iterize';
 ```
 
+# API
+- [Range](https://github.com/hg-pyun/iterize#range)
+- [Cycle](https://github.com/hg-pyun/iterize#cycle)
+- [Repeat](https://github.com/hg-pyun/iterize#repeat)
+- [Replicate](https://github.com/hg-pyun/iterize#replicate)
+- [Take](https://github.com/hg-pyun/iterize#take)
+
 ## Range
 
 Returns a transmitter that increases with some steps within a certain range.
 
 #### Interface
 
 ```typescript
-range(start: number, end:number, step: number | Function): Iterator
+range(start: number, end?:number, step?: number | Function): Iterator
 ```
 
 #### Example
-
+You can use with `for-of` syntax.
 ```js
 import {range} from 'iterize';
 
-[...range(1, 10, 1)]; // [1, 2, 3 ... 9]
-[...range(1, 10, x => x + 1)]; // [1, 2, 3 ... 9]
-[...range(2, 64, x => x * x)]; // [2, 4, 16]
-```
+for (let number of range(5)) {
+    console.log(number);  // 0, 1, 2, 3, 4
+}
 
-```js
-import {range} from 'iterize';
+for (let number of range(0, 5)) {
+    console.log(number);  // 0, 1, 2, 3, 4
+}
 
-let result = [];
-for (let number of range(1, 3, 1)) {
-    result.push(number);
+for (let number of range(0, 5, 2)) {
+    console.log(number);  // 0, 2, 4
 }
-console.log(result);  // [1, 2, 3]
+```
+With the spread operator.
+```js
+import {range} from 'iterize';
+[...range(5)];  // [0, 1, 2, 3, 4]
+[...range(0, 5)]; // [0, 1, 2, 3, 4]
+[...range(5, 0)]; // [5, 4, 3, 2, 1]
+[...range(1, 10, 1)]; // [1, 2, 3 ... 9]
+[...range(1, 10, x => x + 1)]; // [1, 2, 3 ... 9]
+[...range(2, 64, x => x * x)]; // [2, 4, 16]
 ```
 
 ## Cycle
@@ -95,7 +107,7 @@ iter.next(); // { value: 1, done: false }
 iter.next(); // { value: 2, done: false }
 ...
 ```
-
+`Cycle` can also receive a range iterator.
 ```js
 import {cycle, range} from 'iterize';
 
@@ -118,7 +130,7 @@ Returns a number or a string infinitely.
 #### Interface
 
 ```typescript
-repeat(item: number | string): Iterator
+repeat(item: number | string| Function): Iterator
 ```
 
 #### Example
@@ -150,28 +162,24 @@ Returns the N copies of the input(number, string, or iterator).
 #### Interface
 
 ```typescript
-replicate(count: number, item: number | string | Iterator): Iterator
+replicate(count: number, item: number | string | Function | Iterator): Iterator
 ```
 
 #### Example
-
 ```js
 import {replicate} from 'iterize';
 
-[...replicate(5, 0)]   // [0, 0, 0, 0, 0]
-[...replicate(5, 'a')] // ['a', 'a', 'a', 'a', 'a']
+for (let number of replicate(3, 1)) {
+    console.log(number);  // [1, 1, 1]
+}
 ```
-
+With the spread operator.
 ```js
 import {replicate} from 'iterize';
 
-let result = [];
-for (let number of replicate(3, 0)) {
-    result.push(number);
-}
-console.log(result);  // [0, 0, 0]
+[...replicate(5, 0)]   // [0, 0, 0, 0, 0]
+[...replicate(5, 'a')] // ['a', 'a', 'a', 'a', 'a']
 ```
-
 ```js
 import {replicate, range} from 'iterize';
 
@@ -186,27 +194,24 @@ Returns the first N items of the iterator sequentially.
 #### Interface
 
 ```typescript
-take(count: Number, iter: Iterator): Iterator
+take(count: number, iter: Iterator): Iterator
 ```
 
 #### Example
-
 ```js
 import {take, cycle} from 'iterize';
 
 const cycleIterator = cycle([1, 2, 3]);
-[...take(5, cycleIterator)]; // [1, 2, 3, 1, 2]
+for (let number of take(5, cycleIterator)) {
+    console.log(number);  // 1, 2, 3, 1, 2
+}
 ```
-
+With the spread operator.
 ```js
 import {take, cycle} from 'iterize';
 
 const cycleIterator = cycle([1, 2, 3]);
-let result = [];
-for (let number of take(2, cycleIterator)) {
-    result.push(number);
-}
-console.log(result);  // [1, 2]
+[...take(5, cycleIterator)]; // [1, 2, 3, 1, 2]
 ```
 
 # CONTRIBUTING

package.json

@@ -1,6 +1,6 @@
 {
   "name": "iterize",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Minimalistic Javascript Iterators",
   "main": "./lib/index.js",
   "repository": {
@@ -19,9 +19,13 @@
     "generator",
     "es6",
     "helper",
+    "iterable",
     "iterable protocol",
     "lazy evaluation",
-    "reuse"
+    "reuse",
+    "effective",
+    "productive",
+    "tool"
   ],
   "devDependencies": {
     "@babel/cli": "^7.1.2",
@@ -39,6 +43,7 @@
     "husky": "^1.1.2",
     "lint-staged": "^7.3.0",
     "mocha": "^5.2.0",
+    "precise-commits": "^1.0.2",
     "prettier": "1.14.3",
     "ts-node": "^7.0.1",
     "typescript": "^3.1.1"
@@ -48,15 +53,9 @@
   },
   "husky": {
     "hooks": {
-      "pre-commit": "lint-staged"
+      "pre-commit": "precise-commits"
     }
   },
-  "lint-staged": {
-    "*.{ts,css}": [
-      "prettier --write",
-      "git add"
-    ]
-  },
   "scripts": {
     "build": "cross-env BABEL_ENV=production babel ./src --out-dir lib --extensions '.ts'",
     "test": "mocha --recursive ./test/*.ts --require ts-node/register",

src/commons/ErrorModels.ts

@@ -1,34 +1,15 @@
-class EmptyArrayError extends Error {
-    constructor() {
-        super('Array is Empty.');
-        this.name = 'Array Error';
-    }
-}
-
-class InputTypeError extends Error {
-    constructor() {
-        super('Input parameter type is wrong.');
-        this.name = 'InputType Error';
-    }
-}
-
-class IllegalArgumentError extends Error {
+class ArgumentError extends Error {
     constructor(message: string) {
-        super('Argument is illegal\n' + message);
-        this.name = 'IllegalArgument Error';
+        super(message);
+        this.name = 'Argument Error';
     }
 }
 
-class IllegalIteratorBehaviorError extends Error {
+class BehaviorError extends Error {
     constructor(message: string) {
-        super('Behavior of iterator is illegal\n' + message);
-        this.name = 'IllegalIteratorBehavior Error';
+        super(message);
+        this.name = 'IteratorBehavior Error';
     }
 }
 
-export {
-    EmptyArrayError,
-    InputTypeError,
-    IllegalArgumentError,
-    IllegalIteratorBehaviorError,
-};
+export { ArgumentError, BehaviorError };

src/commons/Iterators.ts

@@ -1,15 +1,15 @@
-import { IllegalIteratorBehaviorError } from './ErrorModels';
+import { BehaviorError } from './ErrorModels';
 
 export interface IterableProtocol extends IterableIterator<any> {
     // this method should clone the initial state of iterator
     clone(): IterableProtocol;
 }
 
 export class PrimitiveIterator implements IterableProtocol {
-    value: number | string;
+    value: number | string | Function;
     done: boolean = false;
 
-    constructor(value: number | string) {
+    constructor(value: number | string | Function) {
         this.value = value;
     }
 
@@ -86,9 +86,7 @@ export class RepeatIterator implements IterableProtocol {
         this.iterator = this.iterator.clone();
         next = this.iterator.next();
         if (next.done) {
-            throw new IllegalIteratorBehaviorError(
-                'iterator should iterable more than once'
-            );
+            throw new BehaviorError('Iterator should iterable more than once.');
         }
         this.repeatCount++;
         return next;

src/commons/utility.ts

@@ -1,6 +1,10 @@
-import { IterableProtocol } from './Iterators';
+import {IterableProtocol, RepeatIterator} from './Iterators';
 function isIterator(value: any): value is IterableProtocol {
     return value.next !== undefined && value.clone !== undefined;
 }
 
-export { isIterator };
+function isRepeatIterator(iterator: IterableProtocol) {
+    return iterator instanceof RepeatIterator;
+}
+
+export { isIterator, isRepeatIterator };

src/cycle.ts

@@ -1,17 +1,23 @@
-import { InputTypeError, EmptyArrayError } from './commons/ErrorModels';
+import { ArgumentError } from './commons/ErrorModels';
 import {
     IterableProtocol,
     ArrayIterator,
     RepeatIterator,
 } from './commons/Iterators';
-import { isIterator } from './commons/utility';
+import { isIterator, isRepeatIterator } from './commons/utility';
 
 function cycle(item: Array<any> | IterableProtocol): IterableProtocol {
-    if (!Array.isArray(item) && !isIterator(item)) {
-        throw new InputTypeError();
+
+    if (validateInputTypes(item)) {
+        throw new ArgumentError('Please check arguments type.');
     }
+
+    // todo refactoring
     if (Array.isArray(item) && (item as Array<any>).length === 0) {
-        throw new EmptyArrayError();
+        throw new ArgumentError('Array is empty.');
+    }
+    else if(isRepeatIterator(item as IterableProtocol)) {
+        throw new ArgumentError('Do not use infinite type iterator.');
     }
 
     let iterator: IterableProtocol;
@@ -24,4 +30,8 @@ function cycle(item: Array<any> | IterableProtocol): IterableProtocol {
     return new RepeatIterator(iterator, RepeatIterator.FOREVER);
 }
 
+function validateInputTypes(item: any) {
+    return !Array.isArray(item) && !isIterator(item);
+}
+
 export default cycle;