pax_global_header00006660000000000000000000000064130622517650014521gustar00rootroot0000000000000052 comment=27ee4f6bd202d0dc53ee578edb081489ad12dfc3 es6-iterator-2.0.1/000077500000000000000000000000001306225176500140455ustar00rootroot00000000000000es6-iterator-2.0.1/#/000077500000000000000000000000001306225176500141675ustar00rootroot00000000000000es6-iterator-2.0.1/#/chain.js000066400000000000000000000021361306225176500156110ustar00rootroot00000000000000'use strict'; var setPrototypeOf = require('es5-ext/object/set-prototype-of') , d = require('d') , Iterator = require('../') , validIterable = require('../valid-iterable') , push = Array.prototype.push , defineProperties = Object.defineProperties , IteratorChain; IteratorChain = function (iterators) { defineProperties(this, { __iterators__: d('', iterators), __current__: d('w', iterators.shift()) }); }; if (setPrototypeOf) setPrototypeOf(IteratorChain, Iterator); IteratorChain.prototype = Object.create(Iterator.prototype, { constructor: d(IteratorChain), next: d(function () { var result; if (!this.__current__) return { done: true, value: undefined }; result = this.__current__.next(); while (result.done) { this.__current__ = this.__iterators__.shift(); if (!this.__current__) return { done: true, value: undefined }; result = this.__current__.next(); } return result; }) }); module.exports = function () { var iterators = [this]; push.apply(iterators, arguments); iterators.forEach(validIterable); return new IteratorChain(iterators); }; es6-iterator-2.0.1/.gitignore000066400000000000000000000000631306225176500160340ustar00rootroot00000000000000.DS_Store /node_modules /npm-debug.log /.lintcache es6-iterator-2.0.1/.lint000066400000000000000000000000741306225176500150150ustar00rootroot00000000000000@root module tabs indent 2 maxlen 100 ass nomen plusplus es6-iterator-2.0.1/.travis.yml000066400000000000000000000003571306225176500161630ustar00rootroot00000000000000sudo: false # http://docs.travis-ci.com/user/workers/container-based-infrastructure/ language: node_js node_js: - 0.12 - 4 - 6 - 7 notifications: email: - medikoo+es6-iterator@medikoo.com script: "npm test && npm run lint" es6-iterator-2.0.1/CHANGES000066400000000000000000000022721306225176500150430ustar00rootroot00000000000000v2.0.1 -- 2017.03.15 * Update dependencies v2.0.0 -- 2015.10.02 * Use es6-symbol at v3 v1.0.0 -- 2015.06.23 * Implement support for arguments object * Drop support for v0.8 node ('^' in package.json dependencies) v0.1.3 -- 2015.02.02 * Update dependencies * Fix spelling of LICENSE v0.1.2 -- 2014.11.19 * Optimise internal `_next` to not verify internal's list length at all times (#2 thanks @RReverser) * Fix documentation examples * Configure lint scripts v0.1.1 -- 2014.04.29 * Fix es6-symbol dependency version v0.1.0 -- 2014.04.29 * Assure strictly npm hosted dependencies * Remove sparse arrays dedicated handling (as per spec) * Add: isIterable, validIterable and chain (method) * Remove toArray, it's addressed by Array.from (polyfil can be found in es5-ext/array/from) * Add break possiblity to 'forOf' via 'doBreak' function argument * Provide dedicated iterator for array-likes (ArrayIterator) and for strings (StringIterator) * Provide @@toStringTag symbol * When available rely on @@iterator symbol * Remove 32bit integer maximum list length restriction * Improve Iterator internals * Update to use latest version of dependencies v0.0.0 -- 2013.10.12 Initial (dev version)es6-iterator-2.0.1/LICENSE000066400000000000000000000021171306225176500150530ustar00rootroot00000000000000The MIT License (MIT) Copyright (C) 2013-2015 Mariusz Nowak (www.medikoo.com) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. es6-iterator-2.0.1/README.md000066400000000000000000000102621306225176500153250ustar00rootroot00000000000000# es6-iterator ## ECMAScript 6 Iterator interface ### Installation $ npm install es6-iterator To port it to Browser or any other (non CJS) environment, use your favorite CJS bundler. No favorite yet? Try: [Browserify](http://browserify.org/), [Webmake](https://github.com/medikoo/modules-webmake) or [Webpack](http://webpack.github.io/) ## API ### Constructors #### Iterator(list) _(es6-iterator)_ Abstract Iterator interface. Meant for extensions and not to be used on its own. Accepts any _list_ object (technically object with numeric _length_ property). _Mind it doesn't iterate strings properly, for that use dedicated [StringIterator](#string-iterator)_ ```javascript var Iterator = require('es6-iterator') var iterator = new Iterator([1, 2, 3]); iterator.next(); // { value: 1, done: false } iterator.next(); // { value: 2, done: false } iterator.next(); // { value: 3, done: false } iterator.next(); // { value: undefined, done: true } ``` #### ArrayIterator(arrayLike[, kind]) _(es6-iterator/array)_ Dedicated for arrays and array-likes. Supports three iteration kinds: * __value__ _(default)_ - Iterates values * __key__ - Iterates indexes * __key+value__ - Iterates keys and indexes, each iteration value is in _[key, value]_ form. ```javascript var ArrayIterator = require('es6-iterator/array') var iterator = new ArrayIterator([1, 2, 3], 'key+value'); iterator.next(); // { value: [0, 1], done: false } iterator.next(); // { value: [1, 2], done: false } iterator.next(); // { value: [2, 3], done: false } iterator.next(); // { value: undefined, done: true } ``` May also be used for _arguments_ objects: ```javascript (function () { var iterator = new ArrayIterator(arguments); iterator.next(); // { value: 1, done: false } iterator.next(); // { value: 2, done: false } iterator.next(); // { value: 3, done: false } iterator.next(); // { value: undefined, done: true } }(1, 2, 3)); ``` #### StringIterator(str) _(es6-iterator/string)_ Assures proper iteration over unicode symbols. See: http://mathiasbynens.be/notes/javascript-unicode ```javascript var StringIterator = require('es6-iterator/string'); var iterator = new StringIterator('f馃檲o馃檳o馃檴'); iterator.next(); // { value: 'f', done: false } iterator.next(); // { value: '馃檲', done: false } iterator.next(); // { value: 'o', done: false } iterator.next(); // { value: '馃檳', done: false } iterator.next(); // { value: 'o', done: false } iterator.next(); // { value: '馃檴', done: false } iterator.next(); // { value: undefined, done: true } ``` ### Function utilities #### forOf(iterable, callback[, thisArg]) _(es6-iterator/for-of)_ Polyfill for ECMAScript 6 [`for...of`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of) statement. ``` var forOf = require('es6-iterator/for-of'); var result = []; forOf('馃檲馃檳馃檴', function (monkey) { result.push(monkey); }); console.log(result); // ['馃檲', '馃檳', '馃檴']; ``` Optionally you can break iteration at any point: ```javascript var result = []; forOf([1,2,3,4]', function (val, doBreak) { result.push(monkey); if (val >= 3) doBreak(); }); console.log(result); // [1, 2, 3]; ``` #### get(obj) _(es6-iterator/get)_ Return iterator for any iterable object. ```javascript var getIterator = require('es6-iterator/get'); var iterator = get([1,2,3]); iterator.next(); // { value: 1, done: false } iterator.next(); // { value: 2, done: false } iterator.next(); // { value: 3, done: false } iterator.next(); // { value: undefined, done: true } ``` #### isIterable(obj) _(es6-iterator/is-iterable)_ Whether _obj_ is iterable ```javascript var isIterable = require('es6-iterator/is-iterable'); isIterable(null); // false isIterable(true); // false isIterable('str'); // true isIterable(['a', 'r', 'r']); // true isIterable(new ArrayIterator([])); // true ``` #### validIterable(obj) _(es6-iterator/valid-iterable)_ If _obj_ is an iterable it is returned. Otherwise _TypeError_ is thrown. ### Method extensions #### iterator.chain(iterator1[, 鈥teratorn]) _(es6-iterator/#/chain)_ Chain multiple iterators into one. ### Tests [![Build Status](https://travis-ci.org/medikoo/es6-iterator.png)](https://travis-ci.org/medikoo/es6-iterator) $ npm test es6-iterator-2.0.1/array.js000066400000000000000000000020201306225176500155130ustar00rootroot00000000000000'use strict'; var setPrototypeOf = require('es5-ext/object/set-prototype-of') , contains = require('es5-ext/string/#/contains') , d = require('d') , Iterator = require('./') , defineProperty = Object.defineProperty , ArrayIterator; ArrayIterator = module.exports = function (arr, kind) { if (!(this instanceof ArrayIterator)) return new ArrayIterator(arr, kind); Iterator.call(this, arr); if (!kind) kind = 'value'; else if (contains.call(kind, 'key+value')) kind = 'key+value'; else if (contains.call(kind, 'key')) kind = 'key'; else kind = 'value'; defineProperty(this, '__kind__', d('', kind)); }; if (setPrototypeOf) setPrototypeOf(ArrayIterator, Iterator); ArrayIterator.prototype = Object.create(Iterator.prototype, { constructor: d(ArrayIterator), _resolve: d(function (i) { if (this.__kind__ === 'value') return this.__list__[i]; if (this.__kind__ === 'key+value') return [i, this.__list__[i]]; return i; }), toString: d(function () { return '[object Array Iterator]'; }) }); es6-iterator-2.0.1/for-of.js000066400000000000000000000023731306225176500156000ustar00rootroot00000000000000'use strict'; var isArguments = require('es5-ext/function/is-arguments') , callable = require('es5-ext/object/valid-callable') , isString = require('es5-ext/string/is-string') , get = require('./get') , isArray = Array.isArray, call = Function.prototype.call , some = Array.prototype.some; module.exports = function (iterable, cb/*, thisArg*/) { var mode, thisArg = arguments[2], result, doBreak, broken, i, l, char, code; if (isArray(iterable) || isArguments(iterable)) mode = 'array'; else if (isString(iterable)) mode = 'string'; else iterable = get(iterable); callable(cb); doBreak = function () { broken = true; }; if (mode === 'array') { some.call(iterable, function (value) { call.call(cb, thisArg, value, doBreak); if (broken) return true; }); return; } if (mode === 'string') { l = iterable.length; for (i = 0; i < l; ++i) { char = iterable[i]; if ((i + 1) < l) { code = char.charCodeAt(0); if ((code >= 0xD800) && (code <= 0xDBFF)) char += iterable[++i]; } call.call(cb, thisArg, char, doBreak); if (broken) break; } return; } result = iterable.next(); while (!result.done) { call.call(cb, thisArg, result.value, doBreak); if (broken) return; result = iterable.next(); } }; es6-iterator-2.0.1/get.js000066400000000000000000000011051306225176500151570ustar00rootroot00000000000000'use strict'; var isArguments = require('es5-ext/function/is-arguments') , isString = require('es5-ext/string/is-string') , ArrayIterator = require('./array') , StringIterator = require('./string') , iterable = require('./valid-iterable') , iteratorSymbol = require('es6-symbol').iterator; module.exports = function (obj) { if (typeof iterable(obj)[iteratorSymbol] === 'function') return obj[iteratorSymbol](); if (isArguments(obj)) return new ArrayIterator(obj); if (isString(obj)) return new StringIterator(obj); return new ArrayIterator(obj); }; es6-iterator-2.0.1/index.js000066400000000000000000000052561306225176500155220ustar00rootroot00000000000000'use strict'; var clear = require('es5-ext/array/#/clear') , assign = require('es5-ext/object/assign') , callable = require('es5-ext/object/valid-callable') , value = require('es5-ext/object/valid-value') , d = require('d') , autoBind = require('d/auto-bind') , Symbol = require('es6-symbol') , defineProperty = Object.defineProperty , defineProperties = Object.defineProperties , Iterator; module.exports = Iterator = function (list, context) { if (!(this instanceof Iterator)) return new Iterator(list, context); defineProperties(this, { __list__: d('w', value(list)), __context__: d('w', context), __nextIndex__: d('w', 0) }); if (!context) return; callable(context.on); context.on('_add', this._onAdd); context.on('_delete', this._onDelete); context.on('_clear', this._onClear); }; defineProperties(Iterator.prototype, assign({ constructor: d(Iterator), _next: d(function () { var i; if (!this.__list__) return; if (this.__redo__) { i = this.__redo__.shift(); if (i !== undefined) return i; } if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++; this._unBind(); }), next: d(function () { return this._createResult(this._next()); }), _createResult: d(function (i) { if (i === undefined) return { done: true, value: undefined }; return { done: false, value: this._resolve(i) }; }), _resolve: d(function (i) { return this.__list__[i]; }), _unBind: d(function () { this.__list__ = null; delete this.__redo__; if (!this.__context__) return; this.__context__.off('_add', this._onAdd); this.__context__.off('_delete', this._onDelete); this.__context__.off('_clear', this._onClear); this.__context__ = null; }), toString: d(function () { return '[object Iterator]'; }) }, autoBind({ _onAdd: d(function (index) { if (index >= this.__nextIndex__) return; ++this.__nextIndex__; if (!this.__redo__) { defineProperty(this, '__redo__', d('c', [index])); return; } this.__redo__.forEach(function (redo, i) { if (redo >= index) this.__redo__[i] = ++redo; }, this); this.__redo__.push(index); }), _onDelete: d(function (index) { var i; if (index >= this.__nextIndex__) return; --this.__nextIndex__; if (!this.__redo__) return; i = this.__redo__.indexOf(index); if (i !== -1) this.__redo__.splice(i, 1); this.__redo__.forEach(function (redo, i) { if (redo > index) this.__redo__[i] = --redo; }, this); }), _onClear: d(function () { if (this.__redo__) clear.call(this.__redo__); this.__nextIndex__ = 0; }) }))); defineProperty(Iterator.prototype, Symbol.iterator, d(function () { return this; })); defineProperty(Iterator.prototype, Symbol.toStringTag, d('', 'Iterator')); es6-iterator-2.0.1/is-iterable.js000066400000000000000000000007041306225176500166040ustar00rootroot00000000000000'use strict'; var isArguments = require('es5-ext/function/is-arguments') , isString = require('es5-ext/string/is-string') , iteratorSymbol = require('es6-symbol').iterator , isArray = Array.isArray; module.exports = function (value) { if (value == null) return false; if (isArray(value)) return true; if (isString(value)) return true; if (isArguments(value)) return true; return (typeof value[iteratorSymbol] === 'function'); }; es6-iterator-2.0.1/package.json000066400000000000000000000016651306225176500163430ustar00rootroot00000000000000{ "name": "es6-iterator", "version": "2.0.1", "description": "Iterator abstraction based on ES6 specification", "author": "Mariusz Nowak (http://www.medikoo.com/)", "keywords": [ "iterator", "array", "list", "set", "map", "generator" ], "repository": { "type": "git", "url": "git://github.com/medikoo/es6-iterator.git" }, "dependencies": { "d": "1", "es5-ext": "^0.10.14", "es6-symbol": "^3.1" }, "devDependencies": { "event-emitter": "^0.3.4", "tad": "^0.2.7", "xlint": "^0.2.2", "xlint-jslint-medikoo": "^0.1.4" }, "scripts": { "lint": "node node_modules/xlint/bin/xlint --linter=node_modules/xlint-jslint-medikoo/index.js --no-cache --no-stream", "lint-console": "node node_modules/xlint/bin/xlint --linter=node_modules/xlint-jslint-medikoo/index.js --watch", "test": "node ./node_modules/tad/bin/tad" }, "license": "MIT" } es6-iterator-2.0.1/string.js000066400000000000000000000022461306225176500157150ustar00rootroot00000000000000// Thanks @mathiasbynens // http://mathiasbynens.be/notes/javascript-unicode#iterating-over-symbols 'use strict'; var setPrototypeOf = require('es5-ext/object/set-prototype-of') , d = require('d') , Iterator = require('./') , defineProperty = Object.defineProperty , StringIterator; StringIterator = module.exports = function (str) { if (!(this instanceof StringIterator)) return new StringIterator(str); str = String(str); Iterator.call(this, str); defineProperty(this, '__length__', d('', str.length)); }; if (setPrototypeOf) setPrototypeOf(StringIterator, Iterator); StringIterator.prototype = Object.create(Iterator.prototype, { constructor: d(StringIterator), _next: d(function () { if (!this.__list__) return; if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++; this._unBind(); }), _resolve: d(function (i) { var char = this.__list__[i], code; if (this.__nextIndex__ === this.__length__) return char; code = char.charCodeAt(0); if ((code >= 0xD800) && (code <= 0xDBFF)) return char + this.__list__[this.__nextIndex__++]; return char; }), toString: d(function () { return '[object String Iterator]'; }) }); es6-iterator-2.0.1/test/000077500000000000000000000000001306225176500150245ustar00rootroot00000000000000es6-iterator-2.0.1/test/#/000077500000000000000000000000001306225176500151465ustar00rootroot00000000000000es6-iterator-2.0.1/test/#/chain.js000066400000000000000000000017731306225176500165760ustar00rootroot00000000000000'use strict'; var Iterator = require('../../'); module.exports = function (t, a) { var i1 = new Iterator(['raz', 'dwa', 'trzy']) , i2 = new Iterator(['cztery', 'pi臋膰', 'sze艣膰']) , i3 = new Iterator(['siedem', 'osiem', 'dziewi臋膰']) , iterator = t.call(i1, i2, i3); a.deep(iterator.next(), { done: false, value: 'raz' }, "#1"); a.deep(iterator.next(), { done: false, value: 'dwa' }, "#2"); a.deep(iterator.next(), { done: false, value: 'trzy' }, "#3"); a.deep(iterator.next(), { done: false, value: 'cztery' }, "#4"); a.deep(iterator.next(), { done: false, value: 'pi臋膰' }, "#5"); a.deep(iterator.next(), { done: false, value: 'sze艣膰' }, "#6"); a.deep(iterator.next(), { done: false, value: 'siedem' }, "#7"); a.deep(iterator.next(), { done: false, value: 'osiem' }, "#8"); a.deep(iterator.next(), { done: false, value: 'dziewi臋膰' }, "#9"); a.deep(iterator.next(), { done: true, value: undefined }, "Done #1"); a.deep(iterator.next(), { done: true, value: undefined }, "Done #2"); }; es6-iterator-2.0.1/test/array.js000066400000000000000000000050251306225176500165020ustar00rootroot00000000000000'use strict'; var iteratorSymbol = require('es6-symbol').iterator; module.exports = function (T) { return { Values: function (a) { var x = ['raz', 'dwa', 'trzy', 'cztery', 'pi臋膰', 'sze艣膰'], it; it = new T(x); a(it[iteratorSymbol](), it, "@@iterator"); a.deep(it.next(), { done: false, value: 'raz' }, "#1"); a.deep(it.next(), { done: false, value: 'dwa' }, "#2"); x.splice(1, 0, 'elo'); a.deep(it.next(), { done: false, value: 'dwa' }, "Insert"); a.deep(it.next(), { done: false, value: 'trzy' }, "#3"); a.deep(it.next(), { done: false, value: 'cztery' }, "#4"); x.pop(); a.deep(it.next(), { done: false, value: 'pi臋膰' }, "#5"); a.deep(it.next(), { done: true, value: undefined }, "End"); }, "Keys & Values": function (a) { var x = ['raz', 'dwa', 'trzy', 'cztery', 'pi臋膰', 'sze艣膰'], it; it = new T(x, 'key+value'); a(it[iteratorSymbol](), it, "@@iterator"); a.deep(it.next(), { done: false, value: [0, 'raz'] }, "#1"); a.deep(it.next(), { done: false, value: [1, 'dwa'] }, "#2"); x.splice(1, 0, 'elo'); a.deep(it.next(), { done: false, value: [2, 'dwa'] }, "Insert"); a.deep(it.next(), { done: false, value: [3, 'trzy'] }, "#3"); a.deep(it.next(), { done: false, value: [4, 'cztery'] }, "#4"); x.pop(); a.deep(it.next(), { done: false, value: [5, 'pi臋膰'] }, "#5"); a.deep(it.next(), { done: true, value: undefined }, "End"); }, Keys: function (a) { var x = ['raz', 'dwa', 'trzy', 'cztery', 'pi臋膰', 'sze艣膰'], it; it = new T(x, 'key'); a(it[iteratorSymbol](), it, "@@iterator"); a.deep(it.next(), { done: false, value: 0 }, "#1"); a.deep(it.next(), { done: false, value: 1 }, "#2"); x.splice(1, 0, 'elo'); a.deep(it.next(), { done: false, value: 2 }, "Insert"); a.deep(it.next(), { done: false, value: 3 }, "#3"); a.deep(it.next(), { done: false, value: 4 }, "#4"); x.pop(); a.deep(it.next(), { done: false, value: 5 }, "#5"); a.deep(it.next(), { done: true, value: undefined }, "End"); }, Sparse: function (a) { var x = new Array(6), it; x[2] = 'raz'; x[4] = 'dwa'; it = new T(x); a.deep(it.next(), { done: false, value: undefined }, "#1"); a.deep(it.next(), { done: false, value: undefined }, "#2"); a.deep(it.next(), { done: false, value: 'raz' }, "#3"); a.deep(it.next(), { done: false, value: undefined }, "#4"); a.deep(it.next(), { done: false, value: 'dwa' }, "#5"); a.deep(it.next(), { done: false, value: undefined }, "#6"); a.deep(it.next(), { done: true, value: undefined }, "End"); } }; }; es6-iterator-2.0.1/test/for-of.js000066400000000000000000000022731306225176500165560ustar00rootroot00000000000000'use strict'; var ArrayIterator = require('../array') , slice = Array.prototype.slice; module.exports = function (t, a) { var i = 0, x = ['raz', 'dwa', 'trzy'], y = {}, called = 0; t(x, function () { a.deep(slice.call(arguments, 0, 1), [x[i]], "Array " + i + "#"); a(this, y, "Array: context: " + (i++) + "#"); }, y); i = 0; t((function () { return arguments; }('raz', 'dwa', 'trzy')), function () { a.deep(slice.call(arguments, 0, 1), [x[i]], "Arguments" + i + "#"); a(this, y, "Arguments: context: " + (i++) + "#"); }, y); i = 0; t(x = 'foo', function () { a.deep(slice.call(arguments, 0, 1), [x[i]], "String " + i + "#"); a(this, y, "Regular String: context: " + (i++) + "#"); }, y); i = 0; x = ['r', '馃挬', 'z']; t('r馃挬z', function () { a.deep(slice.call(arguments, 0, 1), [x[i]], "String " + i + "#"); a(this, y, "Unicode String: context: " + (i++) + "#"); }, y); i = 0; t(new ArrayIterator(x), function () { a.deep(slice.call(arguments, 0, 1), [x[i]], "Iterator " + i + "#"); a(this, y, "Iterator: context: " + (i++) + "#"); }, y); t(x = ['raz', 'dwa', 'trzy'], function (value, doBreak) { ++called; return doBreak(); }); a(called, 1, "Break"); }; es6-iterator-2.0.1/test/get.js000066400000000000000000000012671306225176500161470ustar00rootroot00000000000000'use strict'; var iteratorSymbol = require('es6-symbol').iterator , Iterator = require('../'); module.exports = function (t, a) { var iterator; a.throws(function () { t(); }, TypeError, "Null"); a.throws(function () { t({}); }, TypeError, "Plain object"); a.throws(function () { t({ length: 0 }); }, TypeError, "Array-like"); iterator = {}; iterator[iteratorSymbol] = function () { return new Iterator([]); }; a(t(iterator) instanceof Iterator, true, "Iterator"); a(String(t([])), '[object Array Iterator]', " Array"); a(String(t((function () { return arguments; }()))), '[object Array Iterator]', " Arguments"); a(String(t('foo')), '[object String Iterator]', "String"); }; es6-iterator-2.0.1/test/index.js000066400000000000000000000066631306225176500165040ustar00rootroot00000000000000'use strict'; var ee = require('event-emitter') , iteratorSymbol = require('es6-symbol').iterator; module.exports = function (T) { return { "": function (a) { var x = ['raz', 'dwa', 'trzy', 'cztery', 'pi臋膰'], it, y, z; it = new T(x); a(it[iteratorSymbol](), it, "@@iterator"); y = it.next(); a.deep(y, { done: false, value: 'raz' }, "#1"); z = it.next(); a.not(y, z, "Recreate result"); a.deep(z, { done: false, value: 'dwa' }, "#2"); a.deep(it.next(), { done: false, value: 'trzy' }, "#3"); a.deep(it.next(), { done: false, value: 'cztery' }, "#4"); a.deep(it.next(), { done: false, value: 'pi臋膰' }, "#5"); a.deep(y = it.next(), { done: true, value: undefined }, "End"); a.not(y, it.next(), "Recreate result on dead"); }, Emited: function (a) { var x = ['raz', 'dwa', 'trzy', 'cztery', 'pi臋膰'], y, it; y = ee(); it = new T(x, y); a.deep(it.next(), { done: false, value: 'raz' }, "#1"); a.deep(it.next(), { done: false, value: 'dwa' }, "#2"); y.emit('_add', x.push('sze艣膰') - 1); a.deep(it.next(), { done: false, value: 'trzy' }, "#3"); x.splice(1, 0, 'p贸艂tora'); y.emit('_add', 1); a.deep(it.next(), { done: false, value: 'p贸艂tora' }, "Insert"); x.splice(5, 1); y.emit('_delete', 5); a.deep(it.next(), { done: false, value: 'cztery' }, "#4"); a.deep(it.next(), { done: false, value: 'sze艣膰' }, "#5"); a.deep(it.next(), { done: true, value: undefined }, "End"); }, "Emited #2": function (a) { var x = ['raz', 'dwa', 'trzy', 'cztery', 'pi臋膰', 'sze艣膰'], y, it; y = ee(); it = new T(x, y); a.deep(it.next(), { done: false, value: 'raz' }, "#1"); a.deep(it.next(), { done: false, value: 'dwa' }, "#2"); x.splice(1, 0, 'p贸艂tora'); y.emit('_add', 1); x.splice(1, 0, '1.25'); y.emit('_add', 1); x.splice(0, 1); y.emit('_delete', 0); a.deep(it.next(), { done: false, value: 'p贸艂tora' }, "Insert"); a.deep(it.next(), { done: false, value: '1.25' }, "Insert #2"); a.deep(it.next(), { done: false, value: 'trzy' }, "#3"); a.deep(it.next(), { done: false, value: 'cztery' }, "#4"); x.splice(5, 1); y.emit('_delete', 5); a.deep(it.next(), { done: false, value: 'sze艣膰' }, "#5"); a.deep(it.next(), { done: true, value: undefined }, "End"); }, "Emited: Clear #1": function (a) { var x = ['raz', 'dwa', 'trzy', 'cztery', 'pi臋膰', 'sze艣膰'], y, it; y = ee(); it = new T(x, y); a.deep(it.next(), { done: false, value: 'raz' }, "#1"); a.deep(it.next(), { done: false, value: 'dwa' }, "#2"); x.length = 0; y.emit('_clear'); a.deep(it.next(), { done: true, value: undefined }, "End"); }, "Emited: Clear #2": function (a) { var x = ['raz', 'dwa', 'trzy', 'cztery', 'pi臋膰', 'sze艣膰'], y, it; y = ee(); it = new T(x, y); a.deep(it.next(), { done: false, value: 'raz' }, "#1"); a.deep(it.next(), { done: false, value: 'dwa' }, "#2"); x.length = 0; y.emit('_clear'); x.push('foo'); x.push('bar'); a.deep(it.next(), { done: false, value: 'foo' }, "#3"); a.deep(it.next(), { done: false, value: 'bar' }, "#4"); x.splice(1, 0, 'p贸艂tora'); y.emit('_add', 1); x.splice(1, 0, '1.25'); y.emit('_add', 1); x.splice(0, 1); y.emit('_delete', 0); a.deep(it.next(), { done: false, value: 'p贸艂tora' }, "Insert"); a.deep(it.next(), { done: false, value: '1.25' }, "Insert #2"); a.deep(it.next(), { done: true, value: undefined }, "End"); } }; }; es6-iterator-2.0.1/test/is-iterable.js000066400000000000000000000010701306225176500175600ustar00rootroot00000000000000'use strict'; var iteratorSymbol = require('es6-symbol').iterator , Iterator = require('../'); module.exports = function (t, a) { var iterator; a(t(), false, "Undefined"); a(t(123), false, "Number"); a(t({}), false, "Plain object"); a(t({ length: 0 }), false, "Array-like"); iterator = {}; iterator[iteratorSymbol] = function () { return new Iterator([]); }; a(t(iterator), true, "Iterator"); a(t([]), true, "Array"); a(t('foo'), true, "String"); a(t(''), true, "Empty string"); a(t((function () { return arguments; }())), true, "Arguments"); }; es6-iterator-2.0.1/test/string.js000066400000000000000000000015201306225176500166660ustar00rootroot00000000000000'use strict'; var iteratorSymbol = require('es6-symbol').iterator; module.exports = function (T, a) { var it = new T('foobar'); a(it[iteratorSymbol](), it, "@@iterator"); a.deep(it.next(), { done: false, value: 'f' }, "#1"); a.deep(it.next(), { done: false, value: 'o' }, "#2"); a.deep(it.next(), { done: false, value: 'o' }, "#3"); a.deep(it.next(), { done: false, value: 'b' }, "#4"); a.deep(it.next(), { done: false, value: 'a' }, "#5"); a.deep(it.next(), { done: false, value: 'r' }, "#6"); a.deep(it.next(), { done: true, value: undefined }, "End"); a.h1("Outside of BMP"); it = new T('r馃挬z'); a.deep(it.next(), { done: false, value: 'r' }, "#1"); a.deep(it.next(), { done: false, value: '馃挬' }, "#2"); a.deep(it.next(), { done: false, value: 'z' }, "#3"); a.deep(it.next(), { done: true, value: undefined }, "End"); }; es6-iterator-2.0.1/test/valid-iterable.js000066400000000000000000000010611306225176500202440ustar00rootroot00000000000000'use strict'; var iteratorSymbol = require('es6-symbol').iterator , Iterator = require('../'); module.exports = function (t, a) { var obj; a.throws(function () { t(); }, TypeError, "Undefined"); a.throws(function () { t({}); }, TypeError, "Plain object"); a.throws(function () { t({ length: 0 }); }, TypeError, "Array-like"); obj = {}; obj[iteratorSymbol] = function () { return new Iterator([]); }; a(t(obj), obj, "Iterator"); obj = []; a(t(obj), obj, 'Array'); obj = (function () { return arguments; }()); a(t(obj), obj, "Arguments"); }; es6-iterator-2.0.1/valid-iterable.js000066400000000000000000000002731306225176500172710ustar00rootroot00000000000000'use strict'; var isIterable = require('./is-iterable'); module.exports = function (value) { if (!isIterable(value)) throw new TypeError(value + " is not iterable"); return value; };