├── .babelrc
├── .github
    ├── CODEOWNERS
    ├── ISSUE_TEMPLATE
    │   ├── bug_report.md
    │   └── feature_request.md
    └── pull_request_template.md
├── .gitignore
├── .npmignore
├── .prettierrc
├── CHANGE_LOG.md
├── CONTRIBUTE.md
├── LICENSE
├── README.md
├── dist
    └── iterize.umd.js
├── lib
    ├── commons
    │   ├── ErrorModels.d.ts
    │   ├── ErrorModels.js
    │   ├── Iterators.d.ts
    │   ├── Iterators.js
    │   ├── types.d.ts
    │   ├── types.js
    │   ├── utility.d.ts
    │   └── utility.js
    ├── cycle.d.ts
    ├── cycle.js
    ├── index.d.ts
    ├── index.js
    ├── range.d.ts
    ├── range.js
    ├── repeat.d.ts
    ├── repeat.js
    ├── replicate.js
    ├── take.d.ts
    └── take.js
├── package.json
├── src
    ├── commons
    │   ├── ErrorModels.ts
    │   ├── Iterators.ts
    │   ├── types.ts
    │   └── utility.ts
    ├── cycle.ts
    ├── index.ts
    ├── range.ts
    ├── repeat.ts
    └── take.ts
├── test
    ├── cycle.test.ts
    ├── range.test.ts
    ├── repeat.test.ts
    ├── take.test.ts
    └── utility.ts
├── tsconfig.json
└── webpack.config.js


/.babelrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "presets": [
 3 |     ["@babel/env",{
 4 |       "targets": {
 5 |         "chrome": "58",
 6 |         "ie": "11"
 7 |       }
 8 |     }],
 9 |     "@babel/preset-typescript"
10 |   ],
11 |   "plugins": [
12 |     ["@babel/plugin-transform-modules-umd", {
13 |       "globals": {
14 |         "iterize": "Iterize"
15 |       },
16 |       "exactGlobals": true
17 |     }],
18 |     "@babel/plugin-transform-runtime",
19 |     "@babel/plugin-proposal-class-properties"
20 |   ],
21 |   "env": {
22 |     "production": {
23 |       "presets": [
24 |         "minify"
25 |       ]
26 |     }
27 |   }
28 | }
29 | 


--------------------------------------------------------------------------------
/.github/CODEOWNERS:
--------------------------------------------------------------------------------
 1 | # Lines starting with '#' are comments.
 2 | # Each line is a file pattern followed by one or more owners.
 3 | 
 4 | # These owners will be the default owners for everything in the repo.
 5 | *       @hg-pyun @SungJinYoo
 6 | 
 7 | # Order is important. The last matching pattern has the most precedence.
 8 | # So if a pull request only touches javascript files, only these owners
 9 | # will be requested to review.
10 | *.ts    @hg-pyun @SungJinYoo
11 | 
12 | # You can also use email addresses if you prefer.
13 | src/*  phg2491@gmail.com


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | 
 5 | ---
 6 | 
 7 | **Describe the bug**
 8 | A clear and concise description of what the bug is.
 9 | 
10 | **To Reproduce**
11 | Steps to reproduce the behavior:
12 | 1. Go to '...'
13 | 2. Click on '....'
14 | 3. Scroll down to '....'
15 | 4. See error
16 | 
17 | **Expected behavior**
18 | A clear and concise description of what you expected to happen.
19 | 
20 | **Screenshots**
21 | If applicable, add screenshots to help explain your problem.
22 | 
23 | **Environment (please complete the following information):**
24 |  - OS: [e.g. iOS]
25 |  - Browser: [e.g. chrome, safari]
26 |  - Iterize Version: [e.g. 22]
27 | 
28 | **Additional context**
29 | Add any other context about the problem here.
30 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Suggest an idea for this project
 4 | 
 5 | ---
 6 | 
 7 | **Is your feature request related to a problem? Please describe.**
 8 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 9 | 
10 | **Describe the solution you'd like**
11 | A clear and concise description of what you want to happen.
12 | 
13 | **Describe alternatives you've considered**
14 | A clear and concise description of any alternative solutions or features you've considered.
15 | 
16 | **Additional context**
17 | Add any other context or screenshots about the feature request here.
18 | 


--------------------------------------------------------------------------------
/.github/pull_request_template.md:
--------------------------------------------------------------------------------
1 | ## Summary
2 | Fixes #.
3 | 
4 | ## Changes List
5 | -
6 | -
7 | -
8 | 
9 | ## Reference


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Created by .ignore support plugin (hsz.mobi)
2 | /package-lock.json
3 | /node_modules/
4 | .idea
5 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
 1 | # Config
 2 | /.gitignore
 3 | /.babelrc
 4 | /package-lock.json
 5 | /.prettierrc
 6 | /tsconfig.json
 7 | 
 8 | # Folders
 9 | /.github/
10 | /node_modules/
11 | .idea
12 | 


--------------------------------------------------------------------------------
/.prettierrc:
--------------------------------------------------------------------------------
1 | {
2 |   "trailingComma": "es5",
3 |   "tabWidth": 4,
4 |   "semi": true,
5 |   "singleQuote": true
6 | }


--------------------------------------------------------------------------------
/CHANGE_LOG.md:
--------------------------------------------------------------------------------
 1 | # Change Log
 2 | 
 3 | ## 1.5.0
 4 | - Fix `@ts-ignore` to<any> 
 5 | - Add `takeWhile` API
 6 | - Replace `eslint` to `prettier`
 7 | 
 8 | ## 1.4.0
 9 | - Add `*.d.ts` Files
10 | - Extract interfaces on `types.ts` file.
11 | 
12 | ## 1.3.0
13 | - Add change log and pull request templates
14 | - Add Eslint
15 | - Update babel version to 7.2.x
16 | - Support Universal Module Define
17 | - Reformatting codes
18 | 
19 | ## 1.2.0
20 | - Add Higher-API Functions.
21 |   - Support string type on cycle.
22 |   - Combine repeat and replicate API.
23 |   - Support take method for function predicate.
24 | 
25 | ## 1.1.0
26 | - Exception handling when using infinite type on cycle, repeat, replicate method.
27 | - Support function type on all method.
28 | - Refactoring.
29 |   - Error models.
30 |   - Test cases.
31 | - Default parameter on range.
32 | 
33 | ## 1.0.1
34 | - Release regular version.


--------------------------------------------------------------------------------
/CONTRIBUTE.md:
--------------------------------------------------------------------------------
 1 | # Contributing
 2 | 
 3 | Basically, if you send me pull request of the issues, I will review and merge.
 4 | 
 5 | # How to Dev
 6 | 
 7 | #### Build
 8 | 
 9 | ```bash
10 | $ npm run build
11 | ```
12 | 
13 | #### Test
14 | 
15 | You can test your source code before merge.
16 | 
17 | ```bash
18 | $ npm test
19 | ```
20 | 
21 | For develop TDD, using watch script.
22 | 
23 | ```bash
24 | $ npm run test:watch
25 | ```
26 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Haegul Pyun
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # iterize
  2 | 
  3 | [![npm](https://img.shields.io/npm/v/iterize.svg)](https://www.npmjs.com/package/iterize)
  4 | [![npm](https://img.shields.io/npm/dt/iterize.svg)](https://www.npmjs.com/package/iterize)
  5 | [![GitHub license](https://img.shields.io/github/license/hg-pyun/iterize.svg)](https://github.com/hg-pyun/iterize/blob/master/LICENSE)
  6 | ![Build Status](https://codebuild.ap-northeast-2.amazonaws.com/badges?uuid=eyJlbmNyeXB0ZWREYXRhIjoibC9MTUdiTUlIUkFGZzB3SThHMWc1WlI0N2I2TnhFT0RxcXozUVlrU1V6dk1iZzlyWHJvelRIMDJCMHowRE56cDc0N3NUcFIxQ0owSWlqektFR1JJaGI0PSIsIml2UGFyYW1ldGVyU3BlYyI6IkNnMUdYU01GTVpFbFpUNE0iLCJtYXRlcmlhbFNldFNlcmlhbCI6MX0%3D&branch=master)
  7 | 
  8 | > Use JavaScript Iterator, Easily 
  9 | 
 10 | **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.
 11 | **iterize** helps you create your code more easily and efficiently using the various attributes of the Iterable Protocol.
 12 | 
 13 | ## Why Powerful?
 14 | 
 15 | #### Lazy Evaluation
 16 | 
 17 | An array does not need to be allocated to memory on compile-time, nor does it need to be declared explicitly. You can let it be calculated on run-time, or any time you want it to be used.
 18 | 
 19 | #### Expressing Infinity
 20 | 
 21 | It was not easy to express the concept of infinity using the conventional syntax of JavaScript. **iterize** can help you express this concept effectively.
 22 | 
 23 | #### Reuse
 24 | 
 25 | Most functions of **iterize** are implemented as Higher-Order Functions. You can improve your productivity by reusing the functions you have already implemented before.
 26 | 
 27 | # Install
 28 | 
 29 | ```bash
 30 | $ npm install iterize --save
 31 | ```
 32 | 
 33 | You can import **iterize** using ESModule style.
 34 | 
 35 | ```js
 36 | import * as iterize from 'iterize';
 37 | ```
 38 | ```js
 39 | import {range} from 'iterize';
 40 | ```
 41 | If you want to use [UMD](https://github.com/umdjs/umd), please import `dist/iterize.umd.js` on your html file.
 42 | ```html
 43 | <script src="iterize.umd.js" />
 44 | ```
 45 | 
 46 | # API
 47 | - [Range](https://github.com/hg-pyun/iterize#range)
 48 | - [Cycle](https://github.com/hg-pyun/iterize#cycle)
 49 | - [Repeat](https://github.com/hg-pyun/iterize#repeat)
 50 | - [Take](https://github.com/hg-pyun/iterize#take)
 51 | 
 52 | ## Range
 53 | 
 54 | Returns a transmitter that increases with some steps within a certain range.
 55 | 
 56 | #### Interface
 57 | 
 58 | ```typescript
 59 | range(start: number, end?: number, step?: number | Function): Iterator
 60 | ```
 61 | 
 62 | #### Example
 63 | You can use with `for-of` syntax.
 64 | ```js
 65 | import {range} from 'iterize';
 66 | 
 67 | for (let number of range(5)) {
 68 |     console.log(number);  // 0, 1, 2, 3, 4
 69 | }
 70 | 
 71 | for (let number of range(0, 5)) {
 72 |     console.log(number);  // 0, 1, 2, 3, 4
 73 | }
 74 | 
 75 | for (let number of range(0, 5, 2)) {
 76 |     console.log(number);  // 0, 2, 4
 77 | }
 78 | ```
 79 | With the spread operator.
 80 | ```js
 81 | import {range} from 'iterize';
 82 | [...range(5)];  // [0, 1, 2, 3, 4]
 83 | [...range(0, 5)]; // [0, 1, 2, 3, 4]
 84 | [...range(5, 0)]; // [5, 4, 3, 2, 1]
 85 | [...range(1, 10, 1)]; // [1, 2, 3 ... 9]
 86 | [...range(1, 10, x => x + 1)]; // [1, 2, 3 ... 9]
 87 | [...range(2, 64, x => x * x)]; // [2, 4, 16]
 88 | ```
 89 | 
 90 | ## Cycle
 91 | 
 92 | #### Interface
 93 | 
 94 | Receives a string, an array or an iterator and returns an emitter that repeats infinitely.
 95 | 
 96 | ```typescript
 97 | cycle(item: string | Array<any> | Iterator): Iterator
 98 | ```
 99 | 
100 | #### Example
101 | ```js
102 | import {cycle} from 'iterize';
103 | 
104 | const iter = cycle('ABCD');
105 | iter.next(); // { value: 'A', done: false }
106 | iter.next(); // { value: 'B', done: false }
107 | iter.next(); // { value: 'C', done: false }
108 | iter.next(); // { value: 'D', done: false }
109 | iter.next(); // { value: 'A', done: false }
110 | iter.next(); // { value: 'B', done: false }
111 | ...
112 | ```
113 | 
114 | ```js
115 | import {cycle} from 'iterize';
116 | 
117 | const iter = cycle([0, 1, 2]);
118 | iter.next(); // { value: 0, done: false }
119 | iter.next(); // { value: 1, done: false }
120 | iter.next(); // { value: 2, done: false }
121 | iter.next(); // { value: 0, done: false }
122 | iter.next(); // { value: 1, done: false }
123 | iter.next(); // { value: 2, done: false }
124 | ...
125 | ```
126 | `Cycle` can also receive a range iterator.
127 | ```js
128 | import {cycle, range} from 'iterize';
129 | 
130 | const rangeIterator = range(0, 5, 2);
131 | const iter = cycle(rangeIterator);
132 | iter.next(); // { value: 0, done: false }
133 | iter.next(); // { value: 2, done: false }
134 | iter.next(); // { value: 4, done: false }
135 | iter.next(); // { value: 0, done: false }
136 | iter.next(); // { value: 2, done: false }
137 | iter.next(); // { value: 4, done: false }
138 | iter.next(); // { value: 0, done: false }
139 | ...
140 | ```
141 | 
142 | ## Repeat
143 | Returns the N copies of the input(number, string, or iterator).
144 | 
145 | #### Interface
146 | 
147 | ```typescript
148 | repeat(item: number | string | Function | Iterator, count: number): Iterator
149 | ```
150 | 
151 | #### Example
152 | ```js
153 | import {repeat} from 'iterize';
154 | 
155 | for (let number of repeat(1, 3)) {
156 |     console.log(number);  // [1, 1, 1]
157 | }
158 | ```
159 | With the spread operator.
160 | ```js
161 | import {repeat} from 'iterize';
162 | 
163 | [...repeat(0, 5)];   // [0, 0, 0, 0, 0]
164 | [...repeat('a', 5)]; // ['a', 'a', 'a', 'a', 'a']
165 | ```
166 | ```js
167 | import {repeat, range} from 'iterize';
168 | 
169 | const rangeIterator = range(1, 5, 1);
170 | [...repeat(rangeIterator, 2)]; // [1, 2, 3, 4, 1, 2, 3, 4]
171 | ```
172 | 
173 | ## Take
174 | 
175 | Returns the first N items of the iterator sequentially.
176 | 
177 | #### Interface
178 | 
179 | ```typescript
180 | take(predicate: number, iter: Iterator): Iterator
181 | ```
182 | 
183 | #### Example
184 | ```js
185 | import {take, cycle} from 'iterize';
186 | 
187 | const cycleIterator = cycle([1, 2, 3]);
188 | for (let number of take(5, cycleIterator)) {
189 |     console.log(number);  // 1, 2, 3, 1, 2
190 | }
191 | ```
192 | #### Interface
193 | 
194 | ```typescript
195 | takeWhile(predicate: Function, iter: Iterator): Iterator
196 | ```
197 | 
198 | #### Example
199 | ```js
200 | import {takeWhile, range} from 'iterize';
201 | 
202 | for (let number of takeWhile(x => x < 3, range(5))) {
203 |     console.log(number);  // 0, 1, 2
204 | }
205 | ```
206 | 
207 | # CONTRIBUTING
208 | 
209 | ### [Contributing Guide](https://github.com/hg-pyun/iterize/blob/master/CONTRIBUTE.md)
210 | 
211 | Read contributing guide to learn about our development process, how to propose bugfixes and improvements, and how to build and test your changes to **iterize**.
212 | 
213 | # LICENSE
214 | 
215 | **iterize** is [MIT licensed](https://github.com/hg-pyun/iterize/blob/master/LICENSE).
216 | 


--------------------------------------------------------------------------------
/dist/iterize.umd.js:
--------------------------------------------------------------------------------
1 | !function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.Iterize=e():t.Iterize=e()}(window,function(){return function(t){var e={};function r(n){if(e[n])return e[n].exports;var o=e[n]={i:n,l:!1,exports:{}};return t[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}return r.m=t,r.c=e,r.d=function(t,e,n){r.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:n})},r.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},r.t=function(t,e){if(1&e&&(t=r(t)),8&e)return t;if(4&e&&"object"==typeof t&&t&&t.__esModule)return t;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:t}),2&e&&"string"!=typeof t)for(var o in t)r.d(n,o,function(e){return t[e]}.bind(null,o));return n},r.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return r.d(e,"a",e),e},r.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},r.p="",r(r.s=7)}([function(t,e,r){var n,o,i;o=[e,r(5),r(9),r(6),r(12),r(13)],void 0===(i="function"==typeof(n=function(t,e,n,o,i,u){"use strict";var a=r(1);Object.defineProperty(t,"__esModule",{value:!0}),t.BehaviorError=t.ArgumentError=void 0,e=a(e),n=a(n),o=a(o),i=a(i);var f=function(t){function r(t){var i;return(0,e.default)(this,r),(i=(0,n.default)(this,(0,o.default)(r).call(this,t))).name="Argument Error",i}return(0,i.default)(r,t),r}((0,(u=a(u)).default)(Error));t.ArgumentError=f;var c=function(t){function r(t){var i;return(0,e.default)(this,r),(i=(0,n.default)(this,(0,o.default)(r).call(this,t))).name="IteratorBehavior Error",i}return(0,i.default)(r,t),r}((0,u.default)(Error));t.BehaviorError=c})?n.apply(e,o):n)||(t.exports=i)},function(t,e){t.exports=function(t){return t&&t.__esModule?t:{default:t}}},function(t,e,r){var n,o,i;o=[e,r(5),r(16),r(17),r(0)],void 0===(i="function"==typeof(n=function(t,e,n,o,i){"use strict";var u=r(1);Object.defineProperty(t,"__esModule",{value:!0}),t.RangeIterator=t.RepeatIterator=t.ArrayIterator=t.PrimitiveIterator=void 0,e=u(e),n=u(n),o=u(o);var a=Symbol.iterator,f=function(){function t(r){(0,e.default)(this,t),(0,o.default)(this,"value",void 0),(0,o.default)(this,"done",!1),this.value=r}return(0,n.default)(t,[{key:a,value:function(){return this}},{key:"next",value:function(){return this.done?{value:void 0,done:!0}:(this.done=!0,{value:this.value,done:!1})}},{key:"clone",value:function(){return new t(this.value)}}]),t}();t.PrimitiveIterator=f;var c=Symbol.iterator,s=function(){function t(r){(0,e.default)(this,t),(0,o.default)(this,"arr",void 0),(0,o.default)(this,"arrIterator",void 0),this.arr=r,this.arrIterator=r[Symbol.iterator]()}return(0,n.default)(t,[{key:c,value:function(){return this}},{key:"next",value:function(){return this.arrIterator.next()}},{key:"clone",value:function(){return new t(this.arr)}}]),t}();t.ArrayIterator=s;var l=Symbol.iterator,p=function(){function t(r,n){(0,e.default)(this,t),(0,o.default)(this,"iterator",void 0),(0,o.default)(this,"repeatLimit",void 0),(0,o.default)(this,"repeatCount",1),this.iterator=r,this.repeatLimit=n}return(0,n.default)(t,[{key:l,value:function(){return this}},{key:"next",value:function(){var e=this.iterator.next();if(!e.done)return e;if(this.repeatLimit!==t.FOREVER&&!(this.repeatCount<this.repeatLimit))return{value:void 0,done:!0};if(this.iterator=this.iterator.clone(),(e=this.iterator.next()).done)throw new i.BehaviorError("Iterator should iterable more than once.");return this.repeatCount++,e}},{key:"clone",value:function(){return new t(this.iterator,this.repeatLimit)}}]),t}();t.RepeatIterator=p,(0,o.default)(p,"FOREVER",-1);var h=Symbol.iterator,y=function(){function t(r,n,i){(0,e.default)(this,t),(0,o.default)(this,"start",void 0),(0,o.default)(this,"end",void 0),(0,o.default)(this,"step",void 0),(0,o.default)(this,"current",void 0),this.start=r,this.end=n,this.step=i,this.current=r}return(0,n.default)(t,[{key:h,value:function(){return this}},{key:"next",value:function(){if(this.hasNext()){var t=this.current;return this.current=this.step(this.current),{value:t,done:!1}}return{value:void 0,done:!0}}},{key:"hasNext",value:function(){return this.start<this.end?this.current<this.end:this.current>this.end}},{key:"clone",value:function(){return new t(this.start,this.end,this.step)}}]),t}();t.RangeIterator=y})?n.apply(e,o):n)||(t.exports=i)},function(t,e){function r(e,n){return t.exports=r=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t},r(e,n)}t.exports=r},function(t,e,r){var n,o,i;o=[e,r(2)],void 0===(i="function"==typeof(n=function(t,e){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.isIterator=function(t){return void 0!==t.next&&void 0!==t.clone},t.isRepeatIterator=function(t){return t instanceof e.RepeatIterator}})?n.apply(e,o):n)||(t.exports=i)},function(t,e){t.exports=function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}},function(t,e){function r(e){return t.exports=r=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)},r(e)}t.exports=r},function(t,e,r){var n,o,i;o=[e,r(8),r(18),r(19),r(23)],void 0===(i="function"==typeof(n=function(t,e,n,o,i){"use strict";var u=r(1);Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"range",{enumerable:!0,get:function(){return e.default}}),Object.defineProperty(t,"cycle",{enumerable:!0,get:function(){return n.default}}),Object.defineProperty(t,"take",{enumerable:!0,get:function(){return o.default}}),Object.defineProperty(t,"repeat",{enumerable:!0,get:function(){return i.default}}),e=u(e),n=u(n),o=u(o),i=u(i)})?n.apply(e,o):n)||(t.exports=i)},function(t,e,r){var n,o,i;o=[e,r(0),r(2)],void 0===(i="function"==typeof(n=function(t,e,r){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.default=void 0,t.default=function(t,n,o){if(void 0===n&&(n=t,t=0),void 0===o&&(o=t<n?1:-1),function(t,e){return t===e}(t,n))throw new e.ArgumentError("The range parameter is same.");if(function(t,e,r){return"number"!=typeof t||"number"!=typeof e||"number"!=typeof r&&"function"!=typeof r}(t,n,o))throw new e.ArgumentError("Please check arguments type.");var i=o;if("number"==typeof o){var u=o;i=function(t){return t+u}}return new r.RangeIterator(t,n,i)}})?n.apply(e,o):n)||(t.exports=i)},function(t,e,r){var n=r(10),o=r(11);t.exports=function(t,e){return!e||"object"!==n(e)&&"function"!=typeof e?o(t):e}},function(t,e){function r(t){return(r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function n(e){return"function"==typeof Symbol&&"symbol"===r(Symbol.iterator)?t.exports=n=function(t){return r(t)}:t.exports=n=function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":r(t)},n(e)}t.exports=n},function(t,e){t.exports=function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}},function(t,e,r){var n=r(3);t.exports=function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&n(t,e)}},function(t,e,r){var n=r(6),o=r(3),i=r(14),u=r(15);function a(e){var r="function"==typeof Map?new Map:void 0;return t.exports=a=function(t){if(null===t||!i(t))return t;if("function"!=typeof t)throw new TypeError("Super expression must either be null or a function");if(void 0!==r){if(r.has(t))return r.get(t);r.set(t,e)}function e(){return u(t,arguments,n(this).constructor)}return e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),o(e,t)},a(e)}t.exports=a},function(t,e){t.exports=function(t){return-1!==Function.toString.call(t).indexOf("[native code]")}},function(t,e,r){var n=r(3);function o(e,r,i){return!function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],function(){})),!0}catch(t){return!1}}()?t.exports=o=function(t,e,r){var o=[null];o.push.apply(o,e);var i=new(Function.bind.apply(t,o));return r&&n(i,r.prototype),i}:t.exports=o=Reflect.construct,o.apply(null,arguments)}t.exports=o},function(t,e){function r(t,e){for(var r=0;r<e.length;r++){var n=e[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(t,n.key,n)}}t.exports=function(t,e,n){return e&&r(t.prototype,e),n&&r(t,n),t}},function(t,e){t.exports=function(t,e,r){return e in t?Object.defineProperty(t,e,{value:r,enumerable:!0,configurable:!0,writable:!0}):t[e]=r,t}},function(t,e,r){var n,o,i;o=[e,r(0),r(2),r(4)],void 0===(i="function"==typeof(n=function(t,e,r,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.default=void 0,t.default=function(t){if(function(t){return"string"!=typeof t&&!Array.isArray(t)&&!(0,n.isIterator)(t)}(t))throw new e.ArgumentError("Please check arguments type.");if(Array.isArray(t)&&0===t.length)throw new e.ArgumentError("Array is empty.");if((0,n.isRepeatIterator)(t))throw new e.ArgumentError("Do not use infinite type iterator.");var o;return o=Array.isArray(t)?new r.ArrayIterator(t):"string"==typeof t?new r.ArrayIterator(t.split("")):t,new r.RepeatIterator(o,r.RepeatIterator.FOREVER)}})?n.apply(e,o):n)||(t.exports=i)},function(t,e,r){var n,o,i;o=[e,r(20),r(0),r(4)],void 0===(i="function"==typeof(n=function(t,e,n,o){"use strict";var i=r(1);function u(t,r){var o,i;return e.default.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(!a(t,r)){e.next=2;break}throw new n.ArgumentError("Please check arguments type.");case 2:if("number"!=typeof t){e.next=11;break}o=0;case 4:if(!(o++<t)){e.next=9;break}return e.next=7,r.next().value;case 7:e.next=4;break;case 9:e.next=20;break;case 11:if(!(i=r.next()).done){e.next=15;break}return e.abrupt("break",20);case 15:if(!t(i.value)){e.next=18;break}return e.next=18,i.value;case 18:e.next=11;break;case 20:case"end":return e.stop()}},f,this)}function a(t,e){return"number"!=typeof t&&"function"!=typeof t||!(0,o.isIterator)(e)}Object.defineProperty(t,"__esModule",{value:!0}),t.default=void 0;var f=(e=i(e)).default.mark(u);t.default=u})?n.apply(e,o):n)||(t.exports=i)},function(t,e,r){t.exports=r(21)},function(t,e,r){var n=function(){return this||"object"==typeof self&&self}()||Function("return this")(),o=n.regeneratorRuntime&&Object.getOwnPropertyNames(n).indexOf("regeneratorRuntime")>=0,i=o&&n.regeneratorRuntime;if(n.regeneratorRuntime=void 0,t.exports=r(22),o)n.regeneratorRuntime=i;else try{delete n.regeneratorRuntime}catch(t){n.regeneratorRuntime=void 0}},function(t,e){!function(e){"use strict";var r,n=Object.prototype,o=n.hasOwnProperty,i="function"==typeof Symbol?Symbol:{},u=i.iterator||"@@iterator",a=i.asyncIterator||"@@asyncIterator",f=i.toStringTag||"@@toStringTag",c="object"==typeof t,s=e.regeneratorRuntime;if(s)c&&(t.exports=s);else{(s=e.regeneratorRuntime=c?t.exports:{}).wrap=x;var l="suspendedStart",p="suspendedYield",h="executing",y="completed",d={},v={};v[u]=function(){return this};var m=Object.getPrototypeOf,b=m&&m(m(S([])));b&&b!==n&&o.call(b,u)&&(v=b);var g=_.prototype=E.prototype=Object.create(v);O.prototype=g.constructor=_,_.constructor=O,_[f]=O.displayName="GeneratorFunction",s.isGeneratorFunction=function(t){var e="function"==typeof t&&t.constructor;return!!e&&(e===O||"GeneratorFunction"===(e.displayName||e.name))},s.mark=function(t){return Object.setPrototypeOf?Object.setPrototypeOf(t,_):(t.__proto__=_,f in t||(t[f]="GeneratorFunction")),t.prototype=Object.create(g),t},s.awrap=function(t){return{__await:t}},j(P.prototype),P.prototype[a]=function(){return this},s.AsyncIterator=P,s.async=function(t,e,r,n){var o=new P(x(t,e,r,n));return s.isGeneratorFunction(e)?o:o.next().then(function(t){return t.done?t.value:o.next()})},j(g),g[f]="Generator",g[u]=function(){return this},g.toString=function(){return"[object Generator]"},s.keys=function(t){var e=[];for(var r in t)e.push(r);return e.reverse(),function r(){for(;e.length;){var n=e.pop();if(n in t)return r.value=n,r.done=!1,r}return r.done=!0,r}},s.values=S,L.prototype={constructor:L,reset:function(t){if(this.prev=0,this.next=0,this.sent=this._sent=r,this.done=!1,this.delegate=null,this.method="next",this.arg=r,this.tryEntries.forEach(R),!t)for(var e in this)"t"===e.charAt(0)&&o.call(this,e)&&!isNaN(+e.slice(1))&&(this[e]=r)},stop:function(){this.done=!0;var t=this.tryEntries[0].completion;if("throw"===t.type)throw t.arg;return this.rval},dispatchException:function(t){if(this.done)throw t;var e=this;function n(n,o){return a.type="throw",a.arg=t,e.next=n,o&&(e.method="next",e.arg=r),!!o}for(var i=this.tryEntries.length-1;i>=0;--i){var u=this.tryEntries[i],a=u.completion;if("root"===u.tryLoc)return n("end");if(u.tryLoc<=this.prev){var f=o.call(u,"catchLoc"),c=o.call(u,"finallyLoc");if(f&&c){if(this.prev<u.catchLoc)return n(u.catchLoc,!0);if(this.prev<u.finallyLoc)return n(u.finallyLoc)}else if(f){if(this.prev<u.catchLoc)return n(u.catchLoc,!0)}else{if(!c)throw new Error("try statement without catch or finally");if(this.prev<u.finallyLoc)return n(u.finallyLoc)}}}},abrupt:function(t,e){for(var r=this.tryEntries.length-1;r>=0;--r){var n=this.tryEntries[r];if(n.tryLoc<=this.prev&&o.call(n,"finallyLoc")&&this.prev<n.finallyLoc){var i=n;break}}i&&("break"===t||"continue"===t)&&i.tryLoc<=e&&e<=i.finallyLoc&&(i=null);var u=i?i.completion:{};return u.type=t,u.arg=e,i?(this.method="next",this.next=i.finallyLoc,d):this.complete(u)},complete:function(t,e){if("throw"===t.type)throw t.arg;return"break"===t.type||"continue"===t.type?this.next=t.arg:"return"===t.type?(this.rval=this.arg=t.arg,this.method="return",this.next="end"):"normal"===t.type&&e&&(this.next=e),d},finish:function(t){for(var e=this.tryEntries.length-1;e>=0;--e){var r=this.tryEntries[e];if(r.finallyLoc===t)return this.complete(r.completion,r.afterLoc),R(r),d}},catch:function(t){for(var e=this.tryEntries.length-1;e>=0;--e){var r=this.tryEntries[e];if(r.tryLoc===t){var n=r.completion;if("throw"===n.type){var o=n.arg;R(r)}return o}}throw new Error("illegal catch attempt")},delegateYield:function(t,e,n){return this.delegate={iterator:S(t),resultName:e,nextLoc:n},"next"===this.method&&(this.arg=r),d}}}function x(t,e,r,n){var o=e&&e.prototype instanceof E?e:E,i=Object.create(o.prototype),u=new L(n||[]);return i._invoke=function(t,e,r){var n=l;return function(o,i){if(n===h)throw new Error("Generator is already running");if(n===y){if("throw"===o)throw i;return A()}for(r.method=o,r.arg=i;;){var u=r.delegate;if(u){var a=k(u,r);if(a){if(a===d)continue;return a}}if("next"===r.method)r.sent=r._sent=r.arg;else if("throw"===r.method){if(n===l)throw n=y,r.arg;r.dispatchException(r.arg)}else"return"===r.method&&r.abrupt("return",r.arg);n=h;var f=w(t,e,r);if("normal"===f.type){if(n=r.done?y:p,f.arg===d)continue;return{value:f.arg,done:r.done}}"throw"===f.type&&(n=y,r.method="throw",r.arg=f.arg)}}}(t,r,u),i}function w(t,e,r){try{return{type:"normal",arg:t.call(e,r)}}catch(t){return{type:"throw",arg:t}}}function E(){}function O(){}function _(){}function j(t){["next","throw","return"].forEach(function(e){t[e]=function(t){return this._invoke(e,t)}})}function P(t){var e;this._invoke=function(r,n){function i(){return new Promise(function(e,i){!function e(r,n,i,u){var a=w(t[r],t,n);if("throw"!==a.type){var f=a.arg,c=f.value;return c&&"object"==typeof c&&o.call(c,"__await")?Promise.resolve(c.__await).then(function(t){e("next",t,i,u)},function(t){e("throw",t,i,u)}):Promise.resolve(c).then(function(t){f.value=t,i(f)},function(t){return e("throw",t,i,u)})}u(a.arg)}(r,n,e,i)})}return e=e?e.then(i,i):i()}}function k(t,e){var n=t.iterator[e.method];if(n===r){if(e.delegate=null,"throw"===e.method){if(t.iterator.return&&(e.method="return",e.arg=r,k(t,e),"throw"===e.method))return d;e.method="throw",e.arg=new TypeError("The iterator does not provide a 'throw' method")}return d}var o=w(n,t.iterator,e.arg);if("throw"===o.type)return e.method="throw",e.arg=o.arg,e.delegate=null,d;var i=o.arg;return i?i.done?(e[t.resultName]=i.value,e.next=t.nextLoc,"return"!==e.method&&(e.method="next",e.arg=r),e.delegate=null,d):i:(e.method="throw",e.arg=new TypeError("iterator result is not an object"),e.delegate=null,d)}function I(t){var e={tryLoc:t[0]};1 in t&&(e.catchLoc=t[1]),2 in t&&(e.finallyLoc=t[2],e.afterLoc=t[3]),this.tryEntries.push(e)}function R(t){var e=t.completion||{};e.type="normal",delete e.arg,t.completion=e}function L(t){this.tryEntries=[{tryLoc:"root"}],t.forEach(I,this),this.reset(!0)}function S(t){if(t){var e=t[u];if(e)return e.call(t);if("function"==typeof t.next)return t;if(!isNaN(t.length)){var n=-1,i=function e(){for(;++n<t.length;)if(o.call(t,n))return e.value=t[n],e.done=!1,e;return e.value=r,e.done=!0,e};return i.next=i}}return{next:A}}function A(){return{value:r,done:!0}}}(function(){return this||"object"==typeof self&&self}()||Function("return this")())},function(t,e,r){var n,o,i;o=[e,r(0),r(2),r(4)],void 0===(i="function"==typeof(n=function(t,e,r,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.default=void 0,t.default=function(t,o){if(function(t,e){return"number"!=typeof e||"number"!=typeof t&&"string"!=typeof t&&"function"!=typeof t&&!(0,n.isIterator)(t)}(t,o))throw new e.ArgumentError("Please check arguments type.");if(function(t){return 1>t}(o))throw new e.ArgumentError("Repeat count must be larger than 1.");if((0,n.isRepeatIterator)(t))throw new e.ArgumentError("Do not use infinite type iterator.");var i;return i=(0,n.isIterator)(t)?t:new r.PrimitiveIterator(t),new r.RepeatIterator(i,o)}})?n.apply(e,o):n)||(t.exports=i)}])});


--------------------------------------------------------------------------------
/lib/commons/ErrorModels.d.ts:
--------------------------------------------------------------------------------
1 | declare class ArgumentError extends Error {
2 |     constructor(message: string);
3 | }
4 | declare class BehaviorError extends Error {
5 |     constructor(message: string);
6 | }
7 | export { ArgumentError, BehaviorError };
8 | 


--------------------------------------------------------------------------------
/lib/commons/ErrorModels.js:
--------------------------------------------------------------------------------
1 | (function(a,b){if("function"==typeof define&&define.amd)define(["exports","@babel/runtime/helpers/classCallCheck","@babel/runtime/helpers/possibleConstructorReturn","@babel/runtime/helpers/getPrototypeOf","@babel/runtime/helpers/inherits","@babel/runtime/helpers/wrapNativeSuper"],b);else if("undefined"!=typeof exports)b(exports,require("@babel/runtime/helpers/classCallCheck"),require("@babel/runtime/helpers/possibleConstructorReturn"),require("@babel/runtime/helpers/getPrototypeOf"),require("@babel/runtime/helpers/inherits"),require("@babel/runtime/helpers/wrapNativeSuper"));else{var c={exports:{}};b(c.exports,a.babelRuntimeHelpersClassCallCheck,a.babelRuntimeHelpersPossibleConstructorReturn,a.babelRuntimeHelpersGetPrototypeOf,a.babelRuntimeHelpersInherits,a.babelRuntimeHelpersWrapNativeSuper),a.ErrorModels=c.exports}})(this,function(a,b,c,d,e,f){"use strict";var g=require("@babel/runtime/helpers/interopRequireDefault");Object.defineProperty(a,"__esModule",{value:!0}),a.BehaviorError=a.ArgumentError=void 0,b=g(b),c=g(c),d=g(d),e=g(e),f=g(f);var h=/*#__PURE__*/function(a){function f(a){var e;return(0,b.default)(this,f),e=(0,c.default)(this,(0,d.default)(f).call(this,a)),e.name="Argument Error",e}return(0,e.default)(f,a),f}((0,f.default)(Error));a.ArgumentError=h;var i=/*#__PURE__*/function(a){function f(a){var e;return(0,b.default)(this,f),e=(0,c.default)(this,(0,d.default)(f).call(this,a)),e.name="IteratorBehavior Error",e}return(0,e.default)(f,a),f}((0,f.default)(Error));a.BehaviorError=i});


--------------------------------------------------------------------------------
/lib/commons/Iterators.d.ts:
--------------------------------------------------------------------------------
 1 | import { IterableProtocol } from './types';
 2 | export declare class PrimitiveIterator implements IterableProtocol {
 3 |     value: number | string | Function;
 4 |     done: boolean;
 5 |     constructor(value: number | string | Function);
 6 |     [Symbol.iterator](): this;
 7 |     next(value?: any): IteratorResult<any>;
 8 |     clone(): IterableProtocol;
 9 | }
10 | export declare class ArrayIterator implements IterableProtocol {
11 |     arr: Array<any>;
12 |     arrIterator: Iterator<any>;
13 |     constructor(arr: Array<any>);
14 |     [Symbol.iterator](): this;
15 |     next(value?: any): IteratorResult<any>;
16 |     clone(): IterableProtocol;
17 | }
18 | export declare class RepeatIterator implements IterableProtocol {
19 |     static FOREVER: number;
20 |     iterator: IterableProtocol;
21 |     repeatLimit: number;
22 |     repeatCount: number;
23 |     constructor(iterator: IterableProtocol, repeatLimit: number);
24 |     [Symbol.iterator](): this;
25 |     next(value?: any): IteratorResult<any>;
26 |     clone(): IterableProtocol;
27 | }
28 | export declare class RangeIterator implements IterableProtocol {
29 |     start: number;
30 |     end: number;
31 |     step: Function;
32 |     current: number;
33 |     constructor(start: number, end: number, step: Function);
34 |     [Symbol.iterator](): this;
35 |     next(value?: any): IteratorResult<any>;
36 |     hasNext(): boolean;
37 |     clone(): IterableProtocol;
38 | }
39 | 


--------------------------------------------------------------------------------
/lib/commons/Iterators.js:
--------------------------------------------------------------------------------
1 | (function(a,b){if("function"==typeof define&&define.amd)define(["exports","@babel/runtime/helpers/classCallCheck","@babel/runtime/helpers/createClass","@babel/runtime/helpers/defineProperty","./ErrorModels"],b);else if("undefined"!=typeof exports)b(exports,require("@babel/runtime/helpers/classCallCheck"),require("@babel/runtime/helpers/createClass"),require("@babel/runtime/helpers/defineProperty"),require("./ErrorModels"));else{var c={exports:{}};b(c.exports,a.babelRuntimeHelpersClassCallCheck,a.babelRuntimeHelpersCreateClass,a.babelRuntimeHelpersDefineProperty,a.ErrorModels),a.Iterators=c.exports}})(this,function(a,b,c,d,e){"use strict";var f=require("@babel/runtime/helpers/interopRequireDefault");Object.defineProperty(a,"__esModule",{value:!0}),a.RangeIterator=a.RepeatIterator=a.ArrayIterator=a.PrimitiveIterator=void 0,b=f(b),c=f(c),d=f(d);var g=Symbol.iterator,h=/*#__PURE__*/function(){function a(c){(0,b.default)(this,a),(0,d.default)(this,"value",void 0),(0,d.default)(this,"done",!1),this.value=c}return(0,c.default)(a,[{key:g,value:function a(){return this}},{key:"next",value:function a(){return this.done?{value:void 0,done:!0}:(this.done=!0,{value:this.value,done:!1})}},{key:"clone",value:function b(){return new a(this.value)}}]),a}();a.PrimitiveIterator=h;var i=Symbol.iterator,j=/*#__PURE__*/function(){// parameter array should be immutable
2 | function a(c){(0,b.default)(this,a),(0,d.default)(this,"arr",void 0),(0,d.default)(this,"arrIterator",void 0),this.arr=c,this.arrIterator=c[Symbol.iterator]()}return(0,c.default)(a,[{key:i,value:function a(){return this}},{key:"next",value:function a(){return this.arrIterator.next()}},{key:"clone",value:function b(){return new a(this.arr)}}]),a}();a.ArrayIterator=j;var k=Symbol.iterator,l=/*#__PURE__*/function(){function a(c,e){(0,b.default)(this,a),(0,d.default)(this,"iterator",void 0),(0,d.default)(this,"repeatLimit",void 0),(0,d.default)(this,"repeatCount",1),this.iterator=c,this.repeatLimit=e}return(0,c.default)(a,[{key:k,value:function a(){return this}},{key:"next",value:function(){var b=this.iterator.next();if(!b.done)return b;if(this.repeatLimit!==a.FOREVER&&!(this.repeatCount<this.repeatLimit))return{value:void 0,done:!0};if(this.iterator=this.iterator.clone(),b=this.iterator.next(),b.done)throw new e.BehaviorError("Iterator should iterable more than once.");return this.repeatCount++,b}},{key:"clone",value:function b(){return new a(this.iterator,this.repeatLimit)}}]),a}();a.RepeatIterator=l,(0,d.default)(l,"FOREVER",-1);var m=Symbol.iterator,n=/*#__PURE__*/function(){function a(c,e,f){(0,b.default)(this,a),(0,d.default)(this,"start",void 0),(0,d.default)(this,"end",void 0),(0,d.default)(this,"step",void 0),(0,d.default)(this,"current",void 0),this.start=c,this.end=e,this.step=f,this.current=c}return(0,c.default)(a,[{key:m,value:function a(){return this}},{key:"next",value:function a(){if(this.hasNext()){var b=this.current;return this.current=this.step(this.current),{value:b,done:!1}}return{value:void 0,done:!0}}},{key:"hasNext",value:function a(){return this.start<this.end?this.current<this.end:this.current>this.end}},{key:"clone",value:function b(){return new a(this.start,this.end,this.step)}}]),a}();a.RangeIterator=n});


--------------------------------------------------------------------------------
/lib/commons/types.d.ts:
--------------------------------------------------------------------------------
1 | export interface IterableProtocol extends IterableIterator<any> {
2 |     clone(): IterableProtocol;
3 | }
4 | 


--------------------------------------------------------------------------------
/lib/commons/types.js:
--------------------------------------------------------------------------------
1 | (function(a,b){if("function"==typeof define&&define.amd)define([],b);else if("undefined"!=typeof exports)b();else{b(),a.types={exports:{}}.exports}})(this,function(){"use strict"});


--------------------------------------------------------------------------------
/lib/commons/utility.d.ts:
--------------------------------------------------------------------------------
1 | import { IterableProtocol } from './types';
2 | declare function isIterator(value: any): value is IterableProtocol;
3 | declare function isRepeatIterator(iterator: IterableProtocol): boolean;
4 | export { isIterator, isRepeatIterator };
5 | 


--------------------------------------------------------------------------------
/lib/commons/utility.js:
--------------------------------------------------------------------------------
1 | (function(a,b){if("function"==typeof define&&define.amd)define(["exports","./Iterators"],b);else if("undefined"!=typeof exports)b(exports,require("./Iterators"));else{var c={exports:{}};b(c.exports,a.Iterators),a.utility=c.exports}})(this,function(a,b){"use strict";Object.defineProperty(a,"__esModule",{value:!0}),a.isIterator=function(a){return a.next!==void 0&&a.clone!==void 0},a.isRepeatIterator=function(a){return a instanceof b.RepeatIterator}});


--------------------------------------------------------------------------------
/lib/cycle.d.ts:
--------------------------------------------------------------------------------
1 | import { IterableProtocol } from './commons/types';
2 | declare function cycle(seq: string | Array<any> | IterableProtocol): IterableProtocol;
3 | export default cycle;
4 | 


--------------------------------------------------------------------------------
/lib/cycle.js:
--------------------------------------------------------------------------------
1 | (function(a,b){if("function"==typeof define&&define.amd)define(["exports","./commons/ErrorModels","./commons/Iterators","./commons/utility"],b);else if("undefined"!=typeof exports)b(exports,require("./commons/ErrorModels"),require("./commons/Iterators"),require("./commons/utility"));else{var c={exports:{}};b(c.exports,a.commonsErrorModels,a.commonsIterators,a.commonsUtility),a.cycle=c.exports}})(this,function(a,b,c,d){"use strict";function e(a){return"string"!=typeof a&&!Array.isArray(a)&&!(0,d.isIterator)(a)}Object.defineProperty(a,"__esModule",{value:!0}),a.default=void 0;a.default=function(a){if(e(a))throw new b.ArgumentError("Please check arguments type.");// todo refactoring
2 | if(Array.isArray(a)&&0===a.length)throw new b.ArgumentError("Array is empty.");else if((0,d.isRepeatIterator)(a))throw new b.ArgumentError("Do not use infinite type iterator.");var f;return f=Array.isArray(a)?new c.ArrayIterator(a):"string"==typeof a?new c.ArrayIterator(a.split("")):a,new c.RepeatIterator(f,c.RepeatIterator.FOREVER)}});


--------------------------------------------------------------------------------
/lib/index.d.ts:
--------------------------------------------------------------------------------
1 | import range from './range';
2 | import cycle from './cycle';
3 | import take from './take';
4 | import repeat from './repeat';
5 | export { range, cycle, take, repeat };
6 | 


--------------------------------------------------------------------------------
/lib/index.js:
--------------------------------------------------------------------------------
1 | (function(a,b){if("function"==typeof define&&define.amd)define(["exports","./range","./cycle","./take","./repeat"],b);else if("undefined"!=typeof exports)b(exports,require("./range"),require("./cycle"),require("./take"),require("./repeat"));else{var c={exports:{}};b(c.exports,a.range,a.cycle,a.take,a.repeat),a.index=c.exports}})(this,function(a,b,c,d,e){"use strict";var f=require("@babel/runtime/helpers/interopRequireDefault");Object.defineProperty(a,"__esModule",{value:!0}),Object.defineProperty(a,"range",{enumerable:!0,get:function a(){return b.default}}),Object.defineProperty(a,"cycle",{enumerable:!0,get:function a(){return c.default}}),Object.defineProperty(a,"take",{enumerable:!0,get:function a(){return d.default}}),Object.defineProperty(a,"repeat",{enumerable:!0,get:function a(){return e.default}}),b=f(b),c=f(c),d=f(d),e=f(e)});


--------------------------------------------------------------------------------
/lib/range.d.ts:
--------------------------------------------------------------------------------
1 | import { IterableProtocol } from './commons/types';
2 | declare function range(start: number, end?: number, step?: number | Function): IterableProtocol;
3 | export default range;
4 | 


--------------------------------------------------------------------------------
/lib/range.js:
--------------------------------------------------------------------------------
1 | (function(a,b){if("function"==typeof define&&define.amd)define(["exports","./commons/ErrorModels","./commons/Iterators"],b);else if("undefined"!=typeof exports)b(exports,require("./commons/ErrorModels"),require("./commons/Iterators"));else{var c={exports:{}};b(c.exports,a.commonsErrorModels,a.commonsIterators),a.range=c.exports}})(this,function(a,b,c){"use strict";function d(a,b){return a===b}function e(a,b,c){return"number"!=typeof a||"number"!=typeof b||"number"!=typeof c&&"function"!=typeof c}Object.defineProperty(a,"__esModule",{value:!0}),a.default=void 0;a.default=function(a,f,g){if("undefined"==typeof f&&(f=a,a=0),"undefined"==typeof g&&(a<f?g=1:g=-1),d(a,f))throw new b.ArgumentError("The range parameter is same.");else if(e(a,f,g))throw new b.ArgumentError("Please check arguments type.");var h=g;if("number"==typeof g){var i=g;h=function(a){return a+i}}return new c.RangeIterator(a,f,h)}});


--------------------------------------------------------------------------------
/lib/repeat.d.ts:
--------------------------------------------------------------------------------
1 | import { IterableProtocol } from './commons/types';
2 | declare function repeat(seq: number | string | Function | IterableProtocol, count: number): IterableProtocol;
3 | export default repeat;
4 | 


--------------------------------------------------------------------------------
/lib/repeat.js:
--------------------------------------------------------------------------------
1 | (function(a,b){if("function"==typeof define&&define.amd)define(["exports","./commons/ErrorModels","./commons/Iterators","./commons/utility"],b);else if("undefined"!=typeof exports)b(exports,require("./commons/ErrorModels"),require("./commons/Iterators"),require("./commons/utility"));else{var c={exports:{}};b(c.exports,a.commonsErrorModels,a.commonsIterators,a.commonsUtility),a.repeat=c.exports}})(this,function(a,b,c,d){"use strict";function e(a,b){return"number"!=typeof b||"number"!=typeof a&&"string"!=typeof a&&"function"!=typeof a&&!(0,d.isIterator)(a)}function f(a){return 1>a}Object.defineProperty(a,"__esModule",{value:!0}),a.default=void 0;a.default=function(a,g){if(e(a,g))throw new b.ArgumentError("Please check arguments type.");if(f(g))throw new b.ArgumentError("Repeat count must be larger than 1.");if((0,d.isRepeatIterator)(a))throw new b.ArgumentError("Do not use infinite type iterator.");var h;return h=(0,d.isIterator)(a)?a:new c.PrimitiveIterator(a),new c.RepeatIterator(h,g)}});


--------------------------------------------------------------------------------
/lib/replicate.js:
--------------------------------------------------------------------------------
1 | (function(a,b){if("function"==typeof define&&define.amd)define(["exports","./commons/ErrorModels","./commons/Iterators","./commons/utility"],b);else if("undefined"!=typeof exports)b(exports,require("./commons/ErrorModels"),require("./commons/Iterators"),require("./commons/utility"));else{var c={exports:{}};b(c.exports,a.commonsErrorModels,a.commonsIterators,a.commonsUtility),a.replicate=c.exports}})(this,function(a,b,c,d){"use strict";function e(a,b){return"number"!=typeof a||"number"!=typeof b&&"string"!=typeof b&&"function"!=typeof b&&!(0,d.isIterator)(b)}function f(a){return 1>a}Object.defineProperty(a,"__esModule",{value:!0}),a.default=void 0;a.default=function(a,g){if(e(a,g))throw new b.ArgumentError("Please check arguments type.");if(f(a))throw new b.ArgumentError("Replicate count must be larger than 1.");if((0,d.isRepeatIterator)(g))throw new b.ArgumentError("Do not use infinite type iterator.");var h=g;return(0,d.isIterator)(g)||(h=new c.PrimitiveIterator(g)),new c.RepeatIterator(h,a)}});


--------------------------------------------------------------------------------
/lib/take.d.ts:
--------------------------------------------------------------------------------
1 | import { IterableProtocol } from './commons/types';
2 | declare function take(predicate: number | Function, iter: IterableProtocol): IterableIterator<any>;
3 | export default take;
4 | 


--------------------------------------------------------------------------------
/lib/take.js:
--------------------------------------------------------------------------------
1 | (function(a,b){if("function"==typeof define&&define.amd)define(["exports","@babel/runtime/regenerator","./commons/ErrorModels","./commons/utility"],b);else if("undefined"!=typeof exports)b(exports,require("@babel/runtime/regenerator"),require("./commons/ErrorModels"),require("./commons/utility"));else{var c={exports:{}};b(c.exports,a.babelRuntimeRegenerator,a.commonsErrorModels,a.commonsUtility),a.take=c.exports}})(this,function(a,b,c,d){"use strict";var g=require("@babel/runtime/helpers/interopRequireDefault");function e(a,d){var e,g;return b.default.wrap(function(b){for(;;)switch(b.prev=b.next){case 0:if(!f(a,d)){b.next=2;break}throw new c.ArgumentError("Please check arguments type.");case 2:if("number"!=typeof a){b.next=11;break}e=0;case 4:if(!(e++<a)){b.next=9;break}return b.next=7,d.next().value;case 7:b.next=4;break;case 9:b.next=20;break;case 11:if(g=d.next(),!g.done){b.next=15;break}return b.abrupt("break",20);case 15:if(!a(g.value)){b.next=18;break}return b.next=18,g.value;case 18:b.next=11;break;case 20:case"end":return b.stop();}},h,this)}function f(a,b){return"number"!=typeof a&&"function"!=typeof a||!(0,d.isIterator)(b)}Object.defineProperty(a,"__esModule",{value:!0}),a.default=void 0,b=g(b);var h=/*#__PURE__*/b.default.mark(e);a.default=e});


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "iterize",
 3 |   "version": "1.5.0",
 4 |   "description": "Use JavaScript Iterator, Easily",
 5 |   "main": "./lib/index.js",
 6 |   "repository": {
 7 |     "type": "git",
 8 |     "url": "git+https://github.com/hg-pyun/iterize.git"
 9 |   },
10 |   "author": "Haegul Pyun",
11 |   "license": "MIT",
12 |   "bugs": {
13 |     "url": "https://github.com/hg-pyun/iterize/issues"
14 |   },
15 |   "homepage": "https://github.com/hg-pyun/iterize#readme",
16 |   "keywords": [
17 |     "library",
18 |     "iterator",
19 |     "generator",
20 |     "es6",
21 |     "helper",
22 |     "iterable",
23 |     "iterable protocol",
24 |     "lazy evaluation",
25 |     "reuse",
26 |     "effective",
27 |     "productive",
28 |     "tool",
29 |     "functional",
30 |     "higher-order-function"
31 |   ],
32 |   "devDependencies": {
33 |     "@babel/cli": "^7.2.3",
34 |     "@babel/core": "^7.2.2",
35 |     "@babel/plugin-proposal-class-properties": "^7.2.3",
36 |     "@babel/plugin-transform-modules-umd": "^7.2.0",
37 |     "@babel/plugin-transform-runtime": "^7.2.0",
38 |     "@babel/preset-env": "^7.2.3",
39 |     "@babel/preset-typescript": "^7.1.0",
40 |     "@types/chai": "^4.1.6",
41 |     "@types/mocha": "^5.2.5",
42 |     "babel-loader": "^8.0.4",
43 |     "babel-preset-minify": "^0.5.0",
44 |     "chai": "^4.2.0",
45 |     "cross-env": "^5.2.0",
46 |     "husky": "^2.4.1",
47 |     "lint-staged": "^8.2.1",
48 |     "mocha": "^5.2.0",
49 |     "ts-node": "^7.0.1",
50 |     "typescript": "^3.3.3333",
51 |     "webpack": "^4.28.3",
52 |     "webpack-cli": "^3.1.2"
53 |   },
54 |   "dependencies": {
55 |     "@babel/runtime": "^7.2.0"
56 |   },
57 |   "scripts": {
58 |     "deploy": "npm test && npm run build && npm publish",
59 |     "build": "npm run build:types && npm run build:lib && npm run build:umd",
60 |     "build:types": "tsc --emitDeclarationOnly",
61 |     "build:lib": "cross-env BABEL_ENV=production babel src --out-dir lib --extensions '.ts'",
62 |     "build:umd": "cross-env BABEL_ENV=production webpack",
63 |     "test": "mocha --recursive ./test/*.ts --require ts-node/register",
64 |     "test:watch": "mocha --recursive --watch-extensions ts --watch ./test/*.ts --require ts-node/register"
65 |   },
66 |   "husky": {
67 |     "hooks": {
68 |       "pre-commit": "lint-staged"
69 |     }
70 |   },
71 |   "lint-staged": {
72 |     "*.js": [
73 |       "eslint --fix",
74 |       "git add"
75 |     ]
76 |   }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/commons/ErrorModels.ts:
--------------------------------------------------------------------------------
 1 | class ArgumentError extends Error {
 2 |     constructor(message: string) {
 3 |         super(message);
 4 |         this.name = 'Argument Error';
 5 |     }
 6 | }
 7 | 
 8 | class BehaviorError extends Error {
 9 |     constructor(message: string) {
10 |         super(message);
11 |         this.name = 'IteratorBehavior Error';
12 |     }
13 | }
14 | 
15 | export {ArgumentError, BehaviorError};
16 | 


--------------------------------------------------------------------------------
/src/commons/Iterators.ts:
--------------------------------------------------------------------------------
  1 | import {BehaviorError} from './ErrorModels';
  2 | import { IterableProtocol } from './types';
  3 | 
  4 | export class PrimitiveIterator implements IterableProtocol {
  5 |     value: number | string | Function;
  6 |     done: boolean = false;
  7 | 
  8 |     constructor(value: number | string | Function) {
  9 |         this.value = value;
 10 |     }
 11 | 
 12 |     [Symbol.iterator]() {
 13 |         return this;
 14 |     }
 15 | 
 16 |     public next(value?: any): IteratorResult<any> {
 17 |         if (this.done) {
 18 |             return {value: undefined, done: true};
 19 |         }
 20 |         this.done = true;
 21 |         return {value: this.value, done: false};
 22 |     }
 23 | 
 24 |     public clone(): IterableProtocol {
 25 |         return new PrimitiveIterator(this.value);
 26 |     }
 27 | }
 28 | 
 29 | export class ArrayIterator implements IterableProtocol {
 30 |     arr: Array<any>;
 31 | 
 32 |     arrIterator: Iterator<any>;
 33 | 
 34 |     // parameter array should be immutable
 35 |     constructor(arr: Array<any>) {
 36 |         this.arr = arr;
 37 |         this.arrIterator = arr[Symbol.iterator]();
 38 |     }
 39 | 
 40 |     [Symbol.iterator]() {
 41 |         return this;
 42 |     }
 43 | 
 44 |     public next(value?: any): IteratorResult<any> {
 45 |         return this.arrIterator.next();
 46 |     }
 47 | 
 48 |     public clone(): IterableProtocol {
 49 |         return new ArrayIterator(this.arr);
 50 |     }
 51 | }
 52 | 
 53 | export class RepeatIterator implements IterableProtocol {
 54 |     static FOREVER: number = -1;
 55 | 
 56 |     iterator: IterableProtocol;
 57 |     repeatLimit: number;
 58 |     repeatCount: number = 1;
 59 | 
 60 |     constructor(iterator: IterableProtocol, repeatLimit: number) {
 61 |         this.iterator = iterator;
 62 |         this.repeatLimit = repeatLimit;
 63 |     }
 64 | 
 65 |     [Symbol.iterator]() {
 66 |         return this;
 67 |     }
 68 | 
 69 |     public next(value?: any): IteratorResult<any> {
 70 |         let next: IteratorResult<any> = this.iterator.next();
 71 |         if (!next.done) {
 72 |             return next;
 73 |         }
 74 | 
 75 |         if (
 76 |             this.repeatLimit !== RepeatIterator.FOREVER &&
 77 |             !(this.repeatCount < this.repeatLimit)
 78 |         ) {
 79 |             return {value: undefined, done: true};
 80 |         }
 81 | 
 82 |         this.iterator = this.iterator.clone();
 83 |         next = this.iterator.next();
 84 |         if (next.done) {
 85 |             throw new BehaviorError('Iterator should iterable more than once.');
 86 |         }
 87 |         this.repeatCount++;
 88 |         return next;
 89 |     }
 90 | 
 91 |     public clone(): IterableProtocol {
 92 |         return new RepeatIterator(this.iterator, this.repeatLimit);
 93 |     }
 94 | }
 95 | 
 96 | export class RangeIterator implements IterableProtocol {
 97 |     start: number;
 98 |     end: number;
 99 |     step: Function;
100 | 
101 |     current: number;
102 | 
103 |     constructor(start: number, end: number, step: Function) {
104 |         this.start = start;
105 |         this.end = end;
106 |         this.step = step;
107 |         this.current = start;
108 |     }
109 | 
110 |     [Symbol.iterator]() {
111 |         return this;
112 |     }
113 | 
114 |     public next(value?: any): IteratorResult<any> {
115 |         if (this.hasNext()) {
116 |             let value = this.current;
117 |             this.current = this.step(this.current);
118 |             return {value: value, done: false};
119 |         }
120 |         return {value: undefined, done: true};
121 |     }
122 | 
123 |     hasNext() {
124 |         if (this.start < this.end) {
125 |             return this.current < this.end;
126 |         } else {
127 |             return this.current > this.end;
128 |         }
129 |     }
130 | 
131 |     public clone(): IterableProtocol {
132 |         return new RangeIterator(this.start, this.end, this.step);
133 |     }
134 | }
135 | 


--------------------------------------------------------------------------------
/src/commons/types.ts:
--------------------------------------------------------------------------------
1 | export interface IterableProtocol extends IterableIterator<any> {
2 |     // this method should clone the initial state of iterator
3 |     clone(): IterableProtocol;
4 | }


--------------------------------------------------------------------------------
/src/commons/utility.ts:
--------------------------------------------------------------------------------
 1 | import {RepeatIterator} from './Iterators';
 2 | import { IterableProtocol } from './types';
 3 | 
 4 | function isIterator(value: any): value is IterableProtocol {
 5 |     return value.next !== undefined && value.clone !== undefined;
 6 | }
 7 | 
 8 | function isRepeatIterator(iterator: IterableProtocol) {
 9 |     return iterator instanceof RepeatIterator;
10 | }
11 | 
12 | export {isIterator, isRepeatIterator};
13 | 


--------------------------------------------------------------------------------
/src/cycle.ts:
--------------------------------------------------------------------------------
 1 | import { ArgumentError } from './commons/ErrorModels';
 2 | import {
 3 |     ArrayIterator,
 4 |     RepeatIterator,
 5 | } from './commons/Iterators';
 6 | import { isIterator, isRepeatIterator } from './commons/utility';
 7 | import { IterableProtocol } from './commons/types';
 8 | 
 9 | function cycle (seq: string | Array<any> | IterableProtocol): IterableProtocol {
10 |     if (validateInputTypes(seq)) {
11 |         throw new ArgumentError('Please check arguments type.');
12 |     }
13 | 
14 |     // todo refactoring
15 |     if (Array.isArray(seq) && (seq as Array<any>).length === 0) {
16 |         throw new ArgumentError('Array is empty.');
17 |     } else if (isRepeatIterator(seq as IterableProtocol)) {
18 |         throw new ArgumentError('Do not use infinite type iterator.');
19 |     }
20 | 
21 |     let iterator: IterableProtocol;
22 |     if (Array.isArray(seq)) {
23 |         iterator = new ArrayIterator(seq);
24 |     } else if (typeof seq === 'string') {
25 |         iterator = new ArrayIterator(seq.split(''));
26 |     } else {
27 |         iterator = seq;
28 |     }
29 | 
30 |     return new RepeatIterator(iterator, RepeatIterator.FOREVER);
31 | }
32 | 
33 | function validateInputTypes (seq: any) {
34 |     return typeof seq !== 'string' && !Array.isArray(seq) && !isIterator(seq);
35 | }
36 | 
37 | export default cycle;
38 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
1 | import range from './range';
2 | import cycle from './cycle';
3 | import {take, takeWhile} from './take';
4 | import repeat from './repeat';
5 | 
6 | export { range, cycle, take, takeWhile, repeat };
7 | 


--------------------------------------------------------------------------------
/src/range.ts:
--------------------------------------------------------------------------------
 1 | import { ArgumentError } from './commons/ErrorModels';
 2 | import { RangeIterator } from './commons/Iterators';
 3 | import { IterableProtocol } from './commons/types';
 4 | 
 5 | function range (
 6 |     start: number,
 7 |     end?: number,
 8 |     step?: number | Function,
 9 | ): IterableProtocol {
10 |     if (typeof end === 'undefined') {
11 |         end = start;
12 |         start = 0;
13 |     }
14 | 
15 |     if (typeof step === 'undefined') {
16 |         if (start < end) {
17 |             step = 1;
18 |         } else {
19 |             step = -1;
20 |         }
21 |     }
22 | 
23 |     if (validateSameRage(start, end)) {
24 |         throw new ArgumentError('The range parameter is same.');
25 |     } else if (validateInputTypes(start, end, step)) {
26 |         throw new ArgumentError('Please check arguments type.');
27 |     }
28 | 
29 |     let stepFunction: any = step;
30 | 
31 |     if (typeof step === 'number') {
32 |         let stepValue: number = step;
33 |         stepFunction = (value: number) => {
34 |             return value + stepValue;
35 |         };
36 |     }
37 |     return new RangeIterator(start, end, stepFunction);
38 | }
39 | 
40 | function validateSameRage (start: number, end: number): boolean {
41 |     return start === end;
42 | }
43 | 
44 | function validateInputTypes (
45 |     start: number,
46 |     end?: number,
47 |     step?: number | Function,
48 | ) {
49 |     return (
50 |         typeof start !== 'number' ||
51 |         typeof end !== 'number' ||
52 |         (typeof step !== 'number' && typeof step !== 'function')
53 |     );
54 | }
55 | 
56 | export default range;
57 | 


--------------------------------------------------------------------------------
/src/repeat.ts:
--------------------------------------------------------------------------------
 1 | import { ArgumentError } from './commons/ErrorModels';
 2 | import {
 3 |     PrimitiveIterator,
 4 |     RepeatIterator,
 5 | } from './commons/Iterators';
 6 | import { isIterator, isRepeatIterator } from './commons/utility';
 7 | import { IterableProtocol } from './commons/types';
 8 | 
 9 | function repeat (
10 |     seq: number | string | Function | IterableProtocol,
11 |     count: number,
12 | ): IterableProtocol {
13 |     if (validateInputTypes(seq, count)) {
14 |         throw new ArgumentError('Please check arguments type.');
15 |     }
16 | 
17 |     if (validateCountNumber(count)) {
18 |         throw new ArgumentError('Repeat count must be larger than 1.');
19 |     }
20 | 
21 |     if (isRepeatIterator(seq as IterableProtocol)) {
22 |         throw new ArgumentError('Do not use infinite type iterator.');
23 |     }
24 | 
25 |     let iterator: IterableProtocol;
26 |     if (!isIterator(seq)) {
27 |         iterator = new PrimitiveIterator(seq);
28 |     } else {
29 |         iterator = seq;
30 |     }
31 |     return new RepeatIterator(iterator, count);
32 | }
33 | 
34 | function validateInputTypes (seq: any, count: number) {
35 |     return (
36 |         typeof count !== 'number' ||
37 |         (typeof seq !== 'number' &&
38 |             typeof seq !== 'string' &&
39 |             typeof seq !== 'function' &&
40 |             !isIterator(seq))
41 |     );
42 | }
43 | 
44 | function validateCountNumber (count: number) {
45 |     return count < 1;
46 | }
47 | 
48 | export default repeat;
49 | 


--------------------------------------------------------------------------------
/src/take.ts:
--------------------------------------------------------------------------------
 1 | import { ArgumentError } from './commons/ErrorModels';
 2 | import { isIterator } from './commons/utility';
 3 | import { IterableProtocol } from './commons/types';
 4 | 
 5 | function * take (predicate: number, iter: IterableProtocol) {
 6 |     if (validateTakeInputTypes(predicate, iter)) {
 7 |         throw new ArgumentError('Please check arguments type.');
 8 |     }
 9 |     let index = 0;
10 |     while (index++ < predicate) {
11 |         yield iter.next().value;
12 |     }
13 | }
14 | 
15 | function * takeWhile(predicate: Function, iter: IterableProtocol) {
16 |     if (validateTakeWhileInputTypes(predicate, iter)) {
17 |         throw new ArgumentError('Please check arguments type.');
18 |     }
19 | 
20 |     while (true) {
21 |         const result = iter.next();
22 | 
23 |         if (result.done) {
24 |             break;
25 |         }
26 | 
27 |         if (predicate(result.value)) {
28 |             yield result.value;
29 |         }
30 |     }
31 | }
32 | 
33 | function validateTakeInputTypes (predicate: number | Function, iter: IterableProtocol) {
34 |     return typeof predicate !== 'number' || !isIterator(iter);
35 | }
36 | 
37 | function validateTakeWhileInputTypes (predicate: number | Function, iter: IterableProtocol) {
38 |     return typeof predicate !== 'function' || !isIterator(iter);
39 | }
40 | 
41 | export {take, takeWhile};
42 | 


--------------------------------------------------------------------------------
/test/cycle.test.ts:
--------------------------------------------------------------------------------
  1 | import {assert, expect} from 'chai';
  2 | import {cycle, range} from '../src';
  3 | import {iterResult} from './utility';
  4 | import repeat from '../src/repeat';
  5 | 
  6 | describe('Test Cycle API', () => {
  7 |     describe('Default case', () => {
  8 | 
  9 |         it('string type', () => {
 10 |             const iter = cycle('ABCD');
 11 |             expect(iter.next()).to.deep.equal(iterResult('A'));
 12 |             expect(iter.next()).to.deep.equal(iterResult('B'));
 13 |             expect(iter.next()).to.deep.equal(iterResult('C'));
 14 |             expect(iter.next()).to.deep.equal(iterResult('D'));
 15 |             expect(iter.next()).to.deep.equal(iterResult('A'));
 16 |             expect(iter.next()).to.deep.equal(iterResult('B'));
 17 |         });
 18 | 
 19 |         it('array type (integer)', () => {
 20 |             const iter = cycle([0, 1, 2]);
 21 |             expect(iter.next()).to.deep.equal(iterResult(0));
 22 |             expect(iter.next()).to.deep.equal(iterResult(1));
 23 |             expect(iter.next()).to.deep.equal(iterResult(2));
 24 |             expect(iter.next()).to.deep.equal(iterResult(0));
 25 |             expect(iter.next()).to.deep.equal(iterResult(1));
 26 |             expect(iter.next()).to.deep.equal(iterResult(2));
 27 |         });
 28 | 
 29 |         it("array type (string)", () => {
 30 |             const iter = cycle(['a', 'b', 'c']);
 31 |             expect(iter.next()).to.deep.equal(iterResult('a'));
 32 |             expect(iter.next()).to.deep.equal(iterResult('b'));
 33 |             expect(iter.next()).to.deep.equal(iterResult('c'));
 34 |             expect(iter.next()).to.deep.equal(iterResult('a'));
 35 |             expect(iter.next()).to.deep.equal(iterResult('b'));
 36 |             expect(iter.next()).to.deep.equal(iterResult('c'));
 37 |         });
 38 | 
 39 |         it('function Type', () => {
 40 |             const iter = cycle([
 41 |                 () => {
 42 |                     return 1;
 43 |                 },
 44 |                 () => {
 45 |                     return 2;
 46 |                 },
 47 |                 () => {
 48 |                     return 3;
 49 |                 },
 50 |             ]);
 51 | 
 52 |             // Check iter.next().value equals function.
 53 |             for (let i = 0; i < 5; i++) {
 54 |                 assert.isFunction(iter.next().value);
 55 |             }
 56 |         });
 57 | 
 58 |         it('iterator type [0, 1, 2, 3, 4] ', () => {
 59 |             const rangeIterator = range(0, 5, 1);
 60 |             const iter = cycle(rangeIterator);
 61 |             expect(iter.next()).to.deep.equal(iterResult(0));
 62 |             expect(iter.next()).to.deep.equal(iterResult(1));
 63 |             expect(iter.next()).to.deep.equal(iterResult(2));
 64 |             expect(iter.next()).to.deep.equal(iterResult(3));
 65 |             expect(iter.next()).to.deep.equal(iterResult(4));
 66 |             expect(iter.next()).to.deep.equal(iterResult(0));
 67 |             expect(iter.next()).to.deep.equal(iterResult(1));
 68 |         });
 69 | 
 70 |         it('iterator type [0, 2, 4] ', () => {
 71 |             const rangeIterator = range(0, 5, 2);
 72 |             const iter = cycle(rangeIterator);
 73 |             expect(iter.next()).to.deep.equal(iterResult(0));
 74 |             expect(iter.next()).to.deep.equal(iterResult(2));
 75 |             expect(iter.next()).to.deep.equal(iterResult(4));
 76 |             expect(iter.next()).to.deep.equal(iterResult(0));
 77 |         });
 78 |     });
 79 | 
 80 |     describe('Default case: Compatibility with language specifications', () => {
 81 |         it('for - of (default)', () => {
 82 |             let count = 0;
 83 |             const tobe = [0, 1, 2, 0, 1, 2];
 84 |             const result = [];
 85 |             for (let n of cycle([0, 1, 2])) {
 86 |                 if (count === 6) {
 87 |                     break;
 88 |                 }
 89 |                 result.push(n);
 90 |                 count++;
 91 |             }
 92 |             expect(result).to.deep.equal(tobe);
 93 |         });
 94 | 
 95 |         it('for - of (generator)', () => {
 96 |             let count = 0;
 97 |             const tobe = [0, 1, 2, 3, 4, 0, 1, 2, 3, 4];
 98 |             const result = [];
 99 |             const rangeIterator = range(0, 5, 1);
100 |             for (let n of cycle(rangeIterator)) {
101 |                 if (count === 10) {
102 |                     break;
103 |                 }
104 |                 result.push(n);
105 |                 count++;
106 |             }
107 |             expect(result).to.deep.equal(tobe);
108 |         });
109 |     });
110 | 
111 |     describe('Edge case', () => {
112 |         it('illegal input parameter', () => {
113 |             expect(() => cycle(<any>1).next()).to.throw();
114 |             expect(() => cycle([]).next()).to.throw();
115 |         });
116 | 
117 |         it('illegal input repeatIterator', () => {
118 |             expect(() => cycle(cycle([1, 2, 3]))).to.throw();
119 |             expect(() => cycle(repeat(1, 5))).to.throw();
120 |         });
121 |     });
122 | });
123 | 


--------------------------------------------------------------------------------
/test/range.test.ts:
--------------------------------------------------------------------------------
  1 | import {expect} from 'chai';
  2 | import {range} from '../src';
  3 | import {iterResult, iterDone} from './utility';
  4 | 
  5 | function increaseTester(start: number, end: number, step: any, iter: any) {
  6 |     let stepFunc = step;
  7 |     if (typeof step === 'number') {
  8 |         stepFunc = function (value: number) {
  9 |             return step + value;
 10 |         };
 11 |     }
 12 | 
 13 |     let cIter;
 14 |     for (let i = start; i < end; i = stepFunc(cIter.value)) {
 15 |         cIter = iter.next();
 16 |         expect(cIter).to.deep.equal(iterResult(i));
 17 |     }
 18 |     cIter = iter.next();
 19 |     expect(cIter).to.deep.equal(iterDone());
 20 | }
 21 | 
 22 | function decreaseTester(start: number, end: number, step: any, iter: any) {
 23 |     let stepFunc = step;
 24 |     if (typeof step === 'number') {
 25 |         stepFunc = function (value: number) {
 26 |             return step + value;
 27 |         };
 28 |     }
 29 | 
 30 |     let cIter;
 31 |     for (let i = start; i > end; i = stepFunc(cIter.value)) {
 32 |         cIter = iter.next();
 33 |         expect(cIter).to.deep.equal(iterResult(i));
 34 |     }
 35 | 
 36 |     cIter = iter.next();
 37 |     expect(cIter).to.deep.equal(iterDone());
 38 | }
 39 | 
 40 | describe('Test Range API', () => {
 41 |     describe('Default case: Step is number type', () => {
 42 |         it('increase number', () => {
 43 |             const start = 0;
 44 |             const end = 5;
 45 |             const increaseNumberOne = range(start, end, 1);
 46 |             const increaseNumberTwo = range(start, end, 2);
 47 |             const increaseNumberFour = range(start, end, 4);
 48 |             increaseTester(start, end, 1, increaseNumberOne);
 49 |             increaseTester(start, end, 2, increaseNumberTwo);
 50 |             increaseTester(start, end, 4, increaseNumberFour);
 51 |         });
 52 | 
 53 |         it('decrease number ', () => {
 54 |             const start = 5;
 55 |             const end = 0;
 56 |             const decreaseNumberOne = range(start, end, -1);
 57 |             const decreaseNumberTwo = range(start, end, -2);
 58 |             const decreaseNumberFour = range(start, end, -4);
 59 |             decreaseTester(start, end, -1, decreaseNumberOne);
 60 |             decreaseTester(start, end, -2, decreaseNumberTwo);
 61 |             decreaseTester(start, end, -4, decreaseNumberFour);
 62 |         });
 63 |     });
 64 | 
 65 |     describe('Default case: Step is function type', () => {
 66 |         it('increase number', () => {
 67 |             const start = 0;
 68 |             const end = 5;
 69 |             const increaseNumberOne = range(start, end, (x: number) => x + 1);
 70 |             const increaseNumberTwo = range(start, end, (x: number) => x + 2);
 71 |             const increaseNumberFour = range(start, end, (x: number) => x + 4);
 72 |             increaseTester(start, end, (x: number) => x + 1, increaseNumberOne);
 73 |             increaseTester(start, end, (x: number) => x + 2, increaseNumberTwo);
 74 |             increaseTester(
 75 |                 start,
 76 |                 end,
 77 |                 (x: number) => x + 4,
 78 |                 increaseNumberFour
 79 |             );
 80 |         });
 81 | 
 82 |         it('decrease number', () => {
 83 |             const start = 5;
 84 |             const end = 0;
 85 |             const decreaseNumberOne = range(start, end, (x: number) => x - 1);
 86 |             const decreaseNumberTwo = range(start, end, (x: number) => x - 2);
 87 |             const decreaseNumberFour = range(start, end, (x: number) => x - 4);
 88 |             decreaseTester(start, end, (x: number) => x - 1, decreaseNumberOne);
 89 |             decreaseTester(start, end, (x: number) => x - 2, decreaseNumberTwo);
 90 |             decreaseTester(
 91 |                 start,
 92 |                 end,
 93 |                 (x: number) => x - 4,
 94 |                 decreaseNumberFour
 95 |             );
 96 |         });
 97 | 
 98 |         it('square x^2', () => {
 99 |             const iter = range(2, 64, (x: number) => x * x);
100 |             expect(iter.next()).to.deep.equal(iterResult(2));
101 |             expect(iter.next()).to.deep.equal(iterResult(4));
102 |             expect(iter.next()).to.deep.equal(iterResult(16));
103 |             expect(iter.next()).to.deep.equal(iterDone());
104 |         });
105 |     });
106 | 
107 |     describe('Default case: overloading', () => {
108 |         it('one parameter', () => {
109 |             const increaseNumberOne = range(5);
110 |             increaseTester(0, 5, 1, increaseNumberOne);
111 |         });
112 | 
113 |         it('two parameter', () => {
114 |             const increaseNumberOne = range(0, 5);
115 |             const decreaseNumberOne = range(5, 0);
116 |             increaseTester(0, 5, 1, increaseNumberOne);
117 |             decreaseTester(5, 0, -1, decreaseNumberOne);
118 |         });
119 |     });
120 | 
121 |     describe('Default case: Compatibility with language specifications', () => {
122 |         it('for - of', () => {
123 |             let number = 0;
124 |             for (let n of range(0, 2, 1)) {
125 |                 expect(n).equal(number++);
126 |             }
127 |             expect(number).equal(2);
128 |         });
129 | 
130 |         it('[...iterator]', () => {
131 |             let numbers = [...range(0, 2, 1)];
132 |             expect(numbers).to.deep.equal([0, 1]);
133 |         });
134 |     });
135 | 
136 |     describe('Edge case', () => {
137 |         it('illegal input parameter', () => {
138 |             expect(() => range(<any>'a', 2, 3).next()).to.throw();
139 |             expect(() => range(1, <any>'b', 3).next()).to.throw();
140 |             expect(() => range(1, 2, <any>'1').next()).to.throw();
141 |         });
142 | 
143 |         it('start === end', () => {
144 |             expect(() => range(1, 1).next()).to.throw();
145 |             expect(() => range(1, 1, 3).next()).to.throw();
146 |         });
147 |     });
148 | });
149 | 


--------------------------------------------------------------------------------
/test/repeat.test.ts:
--------------------------------------------------------------------------------
 1 | import {assert, expect} from 'chai';
 2 | import {repeat, cycle} from '../src';
 3 | import {iterDone, iterResult} from './utility';
 4 | import range from "../src/range";
 5 | 
 6 | describe('Test Repeat API', () => {
 7 |     describe('Default case', () => {
 8 |         it('number type', () => {
 9 |             const iter = repeat(0, 5);
10 |             expect(iter.next()).to.deep.equal(iterResult(0));
11 |             expect(iter.next()).to.deep.equal(iterResult(0));
12 |             expect(iter.next()).to.deep.equal(iterResult(0));
13 |             expect(iter.next()).to.deep.equal(iterResult(0));
14 |             expect(iter.next()).to.deep.equal(iterResult(0));
15 |             expect(iter.next()).to.deep.equal(iterDone());
16 |         });
17 | 
18 |         it('string type', () => {
19 |             const iter = repeat('a', 5);
20 |             expect(iter.next()).to.deep.equal(iterResult('a'));
21 |             expect(iter.next()).to.deep.equal(iterResult('a'));
22 |             expect(iter.next()).to.deep.equal(iterResult('a'));
23 |             expect(iter.next()).to.deep.equal(iterResult('a'));
24 |             expect(iter.next()).to.deep.equal(iterResult('a'));
25 |             expect(iter.next()).to.deep.equal(iterDone());
26 |         });
27 | 
28 |         it('function Type', () => {
29 |             const iter = repeat(() => {
30 |                 return 1;
31 |             }, 5);
32 | 
33 |             // Check iter.next().value equals function.
34 |             for (let i = 0; i < 5; i++) {
35 |                 assert.isFunction(iter.next().value);
36 |             }
37 |         });
38 | 
39 |         it('iterator type', () => {
40 |             const rangeIterator = range(1, 5, 1);
41 |             const iter = repeat(rangeIterator, 2);
42 | 
43 |             expect(iter.next()).to.deep.equal(iterResult(1));
44 |             expect(iter.next()).to.deep.equal(iterResult(2));
45 |             expect(iter.next()).to.deep.equal(iterResult(3));
46 |             expect(iter.next()).to.deep.equal(iterResult(4));
47 |             expect(iter.next()).to.deep.equal(iterResult(1));
48 |             expect(iter.next()).to.deep.equal(iterResult(2));
49 |             expect(iter.next()).to.deep.equal(iterResult(3));
50 |             expect(iter.next()).to.deep.equal(iterResult(4));
51 |             expect(iter.next()).to.deep.equal(iterDone());
52 |         });
53 |     });
54 | 
55 |     describe('Default case: Compatibility with language specifications', () => {
56 |         it('for - of(default)', () => {
57 |             for (let n of repeat(0, 5)) {
58 |                 expect(n).equal(0);
59 |             }
60 |         });
61 | 
62 |         it('for - of(iterator)', () => {
63 |             const tobe = [1, 2, 3, 4, 1, 2, 3, 4];
64 |             const result = [];
65 |             const rangeIterator = range(1, 5, 1);
66 |             for (let n of repeat(rangeIterator, 2)) {
67 |                 result.push(n);
68 |             }
69 |             expect(result).to.deep.equal(tobe);
70 |         });
71 | 
72 |         it('[...iterator]', () => {
73 |             let str = [...repeat('a', 5)];
74 |             expect(str).to.deep.equal(['a', 'a', 'a', 'a', 'a']);
75 |         });
76 |     });
77 | 
78 | 
79 |     describe('Edge case', () => {
80 |         it('illegal input parameter', () => {
81 |             expect(() => repeat(5, <any>['a']).next()).to.throw();
82 |             expect(() => repeat(5, <any>'a').next()).to.throw();
83 |             expect(() => repeat(5, <any>undefined).next()).to.throw();
84 |             expect(() => repeat(5, <any>null).next()).to.throw();
85 |         });
86 | 
87 |         it('illegal input repeatIterator', () => {
88 |             expect(() => repeat(cycle([1, 2, 3]), 3)).to.throw();
89 |             expect(() => repeat(repeat(1, 5), 3)).to.throw();
90 |         });
91 |     });
92 | });
93 | 


--------------------------------------------------------------------------------
/test/take.test.ts:
--------------------------------------------------------------------------------
 1 | import {expect} from 'chai';
 2 | import { range, take, cycle, repeat, takeWhile } from '../src';
 3 | import {iterDone, iterResult} from './utility';
 4 | 
 5 | describe('Test Take API', () => {
 6 |     describe('Default case', () => {
 7 |         it('range type', () => {
 8 |             const rangeIterator = range(0, 5, 2);
 9 |             const iter = take(2, rangeIterator);
10 |             expect(iter.next()).to.deep.equal(iterResult(0));
11 |             expect(iter.next()).to.deep.equal(iterResult(2));
12 |             expect(iter.next()).to.deep.equal(iterDone());
13 |         });
14 | 
15 |         it('cycle type', () => {
16 |             const cycleIterator = cycle([1, 2, 3]);
17 |             const iter = take(5, cycleIterator);
18 |             expect(iter.next()).to.deep.equal(iterResult(1));
19 |             expect(iter.next()).to.deep.equal(iterResult(2));
20 |             expect(iter.next()).to.deep.equal(iterResult(3));
21 |             expect(iter.next()).to.deep.equal(iterResult(1));
22 |             expect(iter.next()).to.deep.equal(iterResult(2));
23 |             expect(iter.next()).to.deep.equal(iterDone());
24 |         });
25 | 
26 |         it('repeat type', () => {
27 |             const repeatIterator = repeat(0, 2);
28 |             const iter = take(2, repeatIterator);
29 |             expect(iter.next()).to.deep.equal(iterResult(0));
30 |             expect(iter.next()).to.deep.equal(iterResult(0));
31 |             expect(iter.next()).to.deep.equal(iterDone());
32 |         });
33 |     });
34 | 
35 |     describe('takewhile', () => {
36 |         it('range type', () => {
37 |             const rangeIterator = range(5);
38 |             const iter = takeWhile((x: any) => x < 3, rangeIterator);
39 |             expect(iter.next()).to.deep.equal(iterResult(0));
40 |             expect(iter.next()).to.deep.equal(iterResult(1));
41 |             expect(iter.next()).to.deep.equal(iterResult(2));
42 |             expect(iter.next()).to.deep.equal(iterDone());
43 |         });
44 | 
45 |         it('cycle type', () => {
46 |             const cycleIterator = cycle([1, 2, 3]);
47 |             const iter = takeWhile((x: any) => x === 1, cycleIterator);
48 |             expect(iter.next()).to.deep.equal(iterResult(1));
49 |             expect(iter.next()).to.deep.equal(iterResult(1));
50 |             expect(iter.next()).to.deep.equal(iterResult(1));
51 |             expect(iter.next()).to.deep.equal(iterResult(1));
52 |         });
53 |     });
54 | 
55 |     describe('Default case: Compatibility with language specifications', () => {
56 |         it('for - of', () => {
57 |             const cycleIterator = cycle([1, 2, 3]);
58 |             const tobe = [1, 2, 3, 1, 2];
59 |             const result = [];
60 |             for (let n of take(5, cycleIterator)) {
61 |                 result.push(n);
62 |             }
63 |             expect(result).to.deep.equal(tobe);
64 |         });
65 | 
66 |         it('[...iterator]', () => {
67 |             const tobe = [1, 2, 3, 1, 2];
68 |             const cycleIterator = cycle([1, 2, 3]);
69 |             let numbers = [...take(5, cycleIterator)];
70 |             expect(numbers).to.deep.equal(tobe);
71 |         });
72 |     });
73 | 
74 |     describe('Edge case', () => {
75 |         it('illegal input parameter', () => {
76 |             expect(() => take(5, <any>5).next()).to.throw();
77 |             expect(() => take(<any>'a', cycle([1, 2, 3])).next()).to.throw();
78 |             expect(() => takeWhile(<any>5, cycle([1, 2, 3])).next()).to.throw();
79 |             expect(() => takeWhile(<any>'a', cycle([1, 2, 3])).next()).to.throw();
80 |         });
81 |     });
82 | });
83 | 


--------------------------------------------------------------------------------
/test/utility.ts:
--------------------------------------------------------------------------------
 1 | export function iterResult(value: any) {
 2 |     return {
 3 |         value: value,
 4 |         done: false,
 5 |     };
 6 | }
 7 | 
 8 | export function iterDone() {
 9 |     return {
10 |         value: undefined,
11 |         done: true,
12 |     };
13 | }
14 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     /* Basic Options */
 4 |     "target": "esnext",                       /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017','ES2018' or 'ESNEXT'. */
 5 |     "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
 6 |     // "lib": [],                             /* Specify library files to be included in the compilation. */
 7 |     // "allowJs": true,                       /* Allow javascript files to be compiled. */
 8 |     // "checkJs": true,                       /* Report errors in .js files. */
 9 |     // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
10 |     "declaration": true,                      /* Generates corresponding '.d.ts' file. */
11 |     // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
12 |     // "sourceMap": true,                     /* Generates corresponding '.map' file. */
13 |     // "outFile": "./",                       /* Concatenate and emit output to single file. */
14 |     "outDir": "lib",                          /* Redirect output structure to the directory. */
15 |     // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
16 |     // "composite": true,                     /* Enable project compilation */
17 |     // "removeComments": true,                /* Do not emit comments to output. */
18 |     // "noEmit": true,                        /* Do not emit outputs. */
19 |     // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
20 |     // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
21 |     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
22 | 
23 |     /* Strict Type-Checking Options */
24 |     "strict": true,                           /* Enable all strict type-checking options. */
25 |     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
26 |     // "strictNullChecks": true,              /* Enable strict null checks. */
27 |     // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
28 |     // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
29 |     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
30 |     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
31 | 
32 |     /* Additional Checks */
33 |     // "noUnusedLocals": true,                /* Report errors on unused locals. */
34 |     // "noUnusedParameters": true,            /* Report errors on unused parameters. */
35 |     // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
36 |     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
37 | 
38 |     /* Module Resolution Options */
39 |     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
40 |     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
41 |     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
42 |     // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
43 |     // "typeRoots": [],                       /* List of folders to include type definitions from. */
44 |     // "types": [],                           /* Type declaration files to be included in compilation. */
45 |     "allowSyntheticDefaultImports": true,     /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
46 |     "esModuleInterop": true,                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
47 |     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
48 | 
49 |     /* Source Map Options */
50 |     // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
51 |     // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
52 |     // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
53 |     // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
54 | 
55 |     /* Experimental Options */
56 |     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
57 |     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
58 | 
59 |     /* Advanced Options */
60 | //     "declarationDir": "lib"                /* Output directory for generated declaration files. */
61 |   },
62 |   "exclude": ["node_modules", "lib", "test"]
63 | }
64 | 


--------------------------------------------------------------------------------
/webpack.config.js:
--------------------------------------------------------------------------------
 1 | const path = require('path');
 2 | 
 3 | module.exports = {
 4 |     mode: 'production',
 5 |     entry: path.resolve(__dirname, './src/index.ts'),
 6 |     output: {
 7 |         filename: 'iterize.umd.js',
 8 |         path: path.resolve(__dirname, 'dist'),
 9 |         library: 'Iterize',
10 |         libraryTarget: 'umd'
11 |     },
12 |     module: {
13 |         rules: [
14 |             {
15 |                 test: /\.ts$/,
16 |                 resolve: {extensions: ['.ts', '.js']},
17 |                 exclude: /(node_modules|bower_components)/,
18 |                 use: {
19 |                     loader: 'babel-loader',
20 |                     options: {
21 |                         presets: ['@babel/preset-env', '@babel/preset-typescript'],
22 |                         plugins: [
23 |                             "@babel/plugin-transform-runtime",
24 |                             "@babel/plugin-proposal-class-properties"
25 |                         ]
26 |                     }
27 |                 }
28 |             }
29 |         ]
30 |     }
31 | };


--------------------------------------------------------------------------------