qoopido.nucleus/src/component/iterator.js

Lightweight, atomic and modular JavaScript utility library that strongly encourages the creation and usage of small yet flexible, reusable and easily maintainable modules.

/**
 * @use /demand/weakmap
 *
 * @require ../emitter
 * @require ../function/merge
 */

(function() {
	'use strict';

	function definition(Weakmap, Emitter, functionMerge) {
		var storage = new Weakmap();

		function getStorageProperty(context, property) {
			var properties;

			if(properties = storage.get(context)) {
				return properties[property];
			}
		}

		function getDataProperty(context, property) {
			var properties;

			if((properties = storage.get(context)) && properties.data) {
				return properties.data[property];
			}
		}

		function ComponentIterator(data, settings) {
			var self = Emitter.call(this);

			storage.set(self, {
				settings: functionMerge({}, ComponentIterator.settings, settings),
				index:    null,
				data:     null
			});

			data && self.setData(data);

			return self;
		}

		ComponentIterator.prototype = {
			// properties
				// length
					get length() {
						return getDataProperty(this, 'length') || 0;
					},
				// index
					get index() {
						return getStorageProperty(this, 'index');
					},
				// item
					get item() {
						return getDataProperty(this, this.index);
					},
			// methods
				setData: function(data) {
					var self = this,
						properties, settings;

					if(typeof data === 'object' && data.length) {
						properties = storage.get(self);
						settings   = properties.settings;

						properties.data = data;

						if(settings.initial !== null) {
							self.seek(settings.initial);
						}
					}

					return self;
				},
				seek: function(index) {
					var self       = this,
						properties = storage.get(self);

					index = parseInt(index, 10);

					if(index !== properties.index && typeof properties.data[index] !== 'undefined') {
						properties.index = index;
					}

					return self;
				},
				first: function() {
					return this.seek(0);
				},
				last: function() {
					var self = this;

					return self.seek(self.length - 1);
				},
				previous: function() {
					var self       = this,
						settings   = storage.get(self).settings,
						index;

					index = (settings.loop === true) ? (self.index - 1) % self.length : self.index - 1;
					index = (settings.loop === true && index < 0) ? self.length + index : index;

					return self.seek(index);
				},
				next: function() {
					var self       = this,
						settings   = storage.get(self).settings,
						index;

					index = (settings.loop === true) ? (self.index + 1) % self.length : self.index + 1;

					return self.seek(index);
				}
		};

		ComponentIterator.settings = { loop: true, initial: 0 };

		return ComponentIterator.extends(Emitter);
	}

	provide([ '/demand/weakmap', '../emitter', '../function/merge' ], definition);
}());