jquery-fileapi-rails 0.0.3

data/vendor/assets/javascripts/jquery-fileapi/jquery.fileapi.js

@@ -0,0 +1,1050 @@
+/**
+ * jQuery plugin for FileAPI v2+
+ * @auhtor	RubaXa	<trash@rubaxa.org>
+ */
+
+/*jslint evil: true */
+/*global jQuery, FileAPI*/
+(function ($, api){
+	"use strict";
+
+	var
+		  noop = $.noop
+		, oldJQ = !$.fn.prop
+		, propFn = oldJQ ? 'attr' : 'prop'
+
+		, _dataAttr = 'data-fileapi'
+		, _dataFileId = 'data-fileapi-id'
+		, _slice	= [].slice
+		, _bind		= function (ctx, fn) {
+			var args = _slice.call(arguments, 2);
+			return	fn.bind ? fn.bind.apply(fn, [ctx].concat(args)) : function (){
+				return fn.apply(ctx, args.concat(_slice.call(arguments)));
+			};
+		}
+	;
+
+
+
+	var Plugin = function (el, options){
+		this.$el = el = $(el).on('change.fileapi', _bind(this, this._onSelect));
+		this.el  = el[0];
+
+		this._options = {}; // previous options
+		this.options  = options = $.extend({
+			url: 0,
+			data: {}, // additional POST-data
+			accept: 0, // accept mime types, "*" — unlimited
+			multiple: false, // single or multiple mode upload mode
+			paramName: 0, // POST-parameter name
+			dataType: 'json',
+			duplicate: false, // ignore duplicate
+			chunkSize: 0, // or chunk size in bytes, eg: .5 * FileAPI.MB
+			chunkUploadRetry: 3, // number of retries during upload chunks (html5)
+
+			maxSize: 0, // max file size, 0 — unlimited
+			maxFiles: 0, // @todo: max uploaded files
+			imageSize: 0, // { minWidth: 320, minHeight: 240, maxWidth: 3840, maxHeight: 2160 }
+
+			sortFn: 0,
+			filterFn: 0,
+			autoUpload: false,
+			resetOnSelect: void 0,
+
+			lang: {
+				  B:	'bytes'
+				, KB:	'KB'
+				, MB:	'MB'
+				, GB:	'GB'
+				, TB:	'TB'
+			},
+			sizeFormat: '0.00',
+
+			imageTransform: 0,
+			imageAutoOrientation: !!FileAPI.support.exif,
+
+			elements: {
+				ctrl: {
+					upload: '[data-fileapi="ctrl.upload"]',
+					reset: '[data-fileapi="ctrl.reset"]',
+					abort: '[data-fileapi="ctrl.abort"]'
+				},
+				empty: {
+					show: '[data-fileapi="empty.show"]',
+					hide: '[data-fileapi="empty.hide"]'
+				},
+				emptyQueue: {
+					show: '[data-fileapi="emptyQueue.show"]',
+					hide: '[data-fileapi="emptyQueue.hide"]'
+				},
+				active: {
+					show: '[data-fileapi="active.show"]',
+					hide: '[data-fileapi="active.hide"]'
+				},
+				size: '[data-fileapi="size"]',
+				name: '[data-fileapi="name"]',
+				progress: '[data-fileapi="progress"]',
+				file: {
+					tpl: '[data-fileapi="file.tpl"]',
+					progress: '[data-fileapi="file.progress"]',
+					active: {
+						show: '[data-fileapi="active.show"]',
+						hide: '[data-fileapi="active.hide"]'
+					},
+					preview: {
+						el: 0,
+						get: 0,
+						width: 0,
+						height: 0,
+						processing: 0
+					}
+				},
+				dnd: {
+					el: '[data-fileapi="dnd"]',
+					hover: 'dnd_hover'
+				}
+			},
+
+			onDrop: noop,
+			onDropHover: noop,
+
+			onSelect: noop,
+
+			onUpload: noop,
+			onProgress: noop,
+			onComplete: noop,
+
+			onFileUpload: noop,
+			onFileProgress: noop,
+			onFileComplete: noop
+		}, options);
+
+
+		if( !options.url ){
+			var url = this.$el.attr('action') || this.$el.find('form').attr('action');
+			if( url ){
+				options.url = url;
+			} else {
+				this._throw('url — is not defined');
+			}
+		}
+
+
+		this.$files = this.elem('list');
+		this.itemTplFn = $.fn.fileapi.tpl( $('<div/>').append( this.elem('file.tpl')).html() );
+
+
+		api.each(options, function (value, option){
+			this._setOption(option, value);
+		}, this);
+
+
+		this.$el
+			.on('reset.fileapi', _bind(this, this._onReset))
+			.on('submit.fileapi', _bind(this, this._onSubmit))
+			.on('upload.fileapi progress.fileapi complete.fileapi', _bind(this, this._onUploadEvent))
+			.on('fileupload.fileapi fileprogress.fileapi filecomplete.fileapi', _bind(this, this._onFileUploadEvent))
+			.on('click', '['+_dataAttr+']', _bind(this, this._onActionClick))
+		;
+
+
+		// Controls
+		var ctrl = options.elements.ctrl;
+		if( ctrl ){
+			if( ctrl.reset ){
+				this.$el.on('click.fileapi', ctrl.reset, _bind(this, this._onReset));
+			}
+			if( ctrl.upload ){
+				this.$el.on('click.fileapi', ctrl.upload, _bind(this, this._onSubmit));
+			}
+		}
+
+		this.elem('dnd.el', true).dnd(_bind(this, this._onDropHover), _bind(this, this._onDrop));
+		this.$progress = this.elem('progress');
+
+		this._crop		= {};
+		this._rotate	= {}; // rotate deg
+
+		this.files		= []; // all files
+		this.uploaded	= []; // uploaded files
+
+		if( options.resetOnSelect === void 0 ){
+			options.resetOnSelect = !options.multiple;
+		}
+
+		this.clear();
+	};
+
+
+	Plugin.prototype = {
+		constructor: Plugin,
+
+		_throw: function (msg){
+			throw "jquery.fileapi: " + msg;
+		},
+
+		_getFiles: function (evt, fn){
+			var
+				  opts = this.options
+				, maxSize = opts.maxSize
+				, filterFn = opts.filterFn
+				, files = api.getFiles(evt)
+				, data = {
+					  all: files
+					, files: []
+					, other: []
+					, duplicate: opts.duplicate ? [] : this._extractDuplicateFiles(files)
+				}
+				, imageSize = opts.imageSize
+				, _this = this
+			;
+
+			if( imageSize || filterFn ){
+				api.filterFiles(files, function (file, info){
+					var ok = true;
+					if( info && imageSize ){
+						ok =   (!imageSize.minWidth || info.width >= imageSize.minWidth)
+							&& (!imageSize.minHeight || info.height >= imageSize.minHeight)
+							&& (!imageSize.maxWidth || info.height <= imageSize.maxWidth)
+							&& (!imageSize.maxHeight || info.height <= imageSize.maxHeight)
+						;
+					}
+					return	ok && (!maxSize || file.size <= maxSize) && (!filterFn || filterFn(file, info));
+				}, function (succes, other){
+					data.files = succes;
+					data.other = other;
+
+					fn.call(_this, data);
+				});
+			} else {
+				api.each(files, function (file){
+					data[!maxSize || file.size <= maxSize ? 'files' : 'other'].push(file);
+				});
+
+				fn.call(_this, data);
+			}
+		},
+
+		_extractDuplicateFiles: function (list/**Array*/){
+			var duplicates = [], i = list.length, files = this.files, j;
+
+			while( i-- ){
+				j = files.length;
+				while( j-- ){
+					if( this._fileCompare(list[i], files[j]) ){
+						duplicates.push( list.splice(i, 1) );
+						break;
+					}
+				}
+			}
+
+			return	duplicates;
+		},
+
+		_fileCompare: function (A/**File*/, B/**File*/){
+			return (A.size == B.size) && (A.name == B.name);
+		},
+
+		_getFormatedSize: function (size){
+			var opts = this.options, postfix = 'B';
+
+			if( size >= api.TB ){
+				size /= api[postfix = 'TB'];
+			}
+			else if( size >= api.GB ){
+				size /= api[postfix = 'GB'];
+			}
+			else if( size >= api.MB ){
+				size /= api[postfix = 'MB'];
+			}
+			else if( size >= api.KB ){
+				size /= api[postfix = 'KB'];
+			}
+
+			return	opts.sizeFormat.replace(/^\d+([^\d]+)(\d*)/, function (_, separator, fix){
+				size = size.toFixed(fix.length);
+				return	(size + '').replace('.', separator) +' '+ opts.lang[postfix];
+			});
+		},
+
+		_onSelect: function (evt){
+			this._getFiles(evt, _bind(this, function (data){
+				if( data.all.length && this.emit('select', data) !== false ){
+					this.add(data.files, this.options.resetOnSelect);
+				}
+			}));
+		},
+
+		_onActionClick: function (evt){
+			var
+				  el = evt.currentTarget
+				, act = $.attr(el, _dataAttr)
+				, $item = $(el).closest('['+_dataFileId+']', this.$el)
+				, uid = $item.attr(_dataFileId)
+				, prevent = true
+			;
+
+			if( 'remove' == act ){
+				$item.remove();
+				this.queue = api.filter(this.queue, function (file){ return api.uid(file) != uid; });
+				this.files = api.filter(this.files, function (file){ return api.uid(file) != uid; });
+				this._redraw();
+			}
+			else if( /^rotate/.test(act)  ){
+				this.rotate(uid, (/ccw/.test(act) ? '-=90' : '+=90'));
+			}
+			else {
+				prevent = false;
+			}
+
+			if( prevent ){
+				evt.preventDefault();
+			}
+		},
+
+		_onSubmit: function (evt){
+			this.upload();
+			evt.preventDefault();
+		},
+
+		_onReset: function (evt){
+			this.clear();
+			evt.preventDefault();
+		},
+
+		_onDrop: function (files){
+			this._getFiles(files, function (data){
+				if( this.emit('drop', data) !== false ){
+					this.add(data.files);
+				}
+			});
+		},
+
+		_onDropHover: function (state, evt){
+			if( this.emit('dropHover', { state: state, event: evt }) !== false ){
+				var hover = this.option('elements.dnd.hover');
+				if( hover ){
+					$(evt.currentTarget).toggleClass(hover, state);
+				}
+			}
+		},
+
+		_getUploadEvent: function (extra){
+			var xhr = this.xhr, evt = {
+				  xhr: xhr
+				, file: xhr.currentFile
+				, files: xhr.files
+				, widget: this
+			};
+			return	$.extend(evt, extra);
+		},
+
+		_emitUploadEvent: function (prefix){
+			var evt = this._getUploadEvent();
+			this.emit(prefix+'upload', evt);
+		},
+
+		_emitProgressEvent: function (prefix, event){
+			var evt = this._getUploadEvent(event);
+			this.emit(prefix+'progress', evt);
+		},
+
+		_emitCompleteEvent: function (prefix, err){
+			var
+				  xhr = this.xhr
+				, evt = this._getUploadEvent({
+					  error: err
+					, status: xhr.status
+					, statusText: xhr.statusText
+					, result: xhr.responseText
+				})
+			;
+
+			if( this.options.dataType == 'json' ){
+				evt.result = $.parseJSON(evt.result);
+			}
+
+			this.emit(prefix+'complete', evt);
+		},
+
+		_onUploadEvent: function (evt, ui){
+			var _this = this, $progress = this.$progress, type = evt.type;
+
+			if( type == 'progress' ){
+				$progress.stop().animate({ width: ui.loaded/ui.total*100 + '%' }, 300);
+			}
+			else if( type == 'upload' ){
+				$progress.width(0);
+			}
+			else {
+				var fn = function (){
+					$progress.dequeue();
+					_this.clear();
+				};
+
+				this.xhr = null;
+				this.active = false;
+
+				if( $progress.length ){
+					$progress.queue(fn);
+				} else {
+					fn();
+				}
+			}
+		},
+
+		_onFileUploadPrepare: function (file, opts){
+			var
+				  uid	= api.uid(file)
+				, deg	= this._rotate[uid]
+				, crop	= this._crop[uid]
+			;
+
+			if( deg || crop ){
+				var trans = opts.imageTransform = opts.imageTransform || {};
+				if( $.isEmptyObject(trans) || _isOriginTransform(trans) ){
+					trans.crop		= crop;
+					trans.rotate	= deg;
+				}
+				else {
+					api.each(trans, function (opts){
+						opts.crop	= crop;
+						opts.rotate	= deg;
+					});
+				}
+			}
+		},
+
+		_onFileUploadEvent: function (evt, ui){
+			var
+				  _this = this
+				, type = evt.type.substr(4)
+				, uid = api.uid(ui.file)
+				, $file = this.fileElem(uid)
+				, $progress = this._$fileprogress
+			;
+
+			if( this.__fileId !== uid ){
+				this.__fileId = uid;
+				this._$fileprogress = $progress = $file.find(this.option('elements.file.progress'));
+			}
+
+			if( type == 'progress' ){
+				$progress.stop().animate({ width: ui.loaded/ui.total*100 + '%' }, 300);
+			}
+			else if( type == 'upload' || type == 'complete' ){
+				var fn = function (){
+					var elem = 'elements.file.'+ type;
+
+					if( type == 'upload' ){
+						$file.find('['+_dataAttr+'="remove"]').hide();
+						$progress.width(0);
+					}
+
+					$progress.dequeue();
+
+					$file.find(_this.option(elem + '.show')).show();
+					$file.find(_this.option(elem + '.hide')).hide();
+				};
+
+				if( $progress.length ){
+					$progress.queue(fn);
+				} else {
+					fn();
+				}
+
+				if( type == 'complete' ){
+					this.uploaded.push(ui.file);
+					delete this._rotate[uid];
+				}
+			}
+		},
+
+		_redraw: function (){
+			var
+				  active = !!this.active
+				, files = this.files
+				, empty = !files.length && !active
+				, emptyQueue = !this.queue.length && !active
+				, name = []
+				, size = 0
+				, $files = this.$files
+				, offset = $files.children().length
+				, preview = this.option('elements.file.preview')
+			;
+
+
+			api.each(files, function (file, i){
+				var uid = api.uid(file);
+
+				name.push(file.name);
+				size += file.size;
+
+				if( $files.length && !this.fileElem(uid).length ){
+					var html = this.itemTplFn({
+						  $idx: offset + i
+						, uid:  file.uid
+						, name: file.name
+						, type: file.type
+						, size: file.size
+						, sizeText: this._getFormatedSize(file.size)
+					});
+
+					$files.append( $(html).attr(_dataFileId, uid) );
+
+					if( preview.el ){
+						this._makeFilePreview(uid, file, preview);
+					}
+				}
+			}, this);
+
+
+			this.elem('name').text( name.join(', ') );
+			this.elem('size').text( this._getFormatedSize(size) );
+
+
+			if( this.__empty !== empty ){
+				this.__empty = empty;
+
+				this.elem('empty.show').toggle( empty );
+				this.elem('empty.hide').toggle( !empty );
+			}
+
+
+			if( this.__emptyQueue !== emptyQueue ){
+				this.__emptyQueue = empty;
+
+				this.elem('emptyQueue.show').toggle( emptyQueue );
+				this.elem('emptyQueue.hide').toggle( !emptyQueue );
+			}
+
+
+			if( this.__active !== active ){
+				this.__active = active;
+
+				this.elem('active.show').toggle( active );
+				this.elem('active.hide').toggle( !active );
+
+				this.$('.js-fileapi-wrapper,:file')
+					[active ? 'attr' : 'removeAttr']('aria-disabled', active)
+					[propFn]('disabled', active)
+				;
+			}
+
+
+			// Upload & reset control
+			this.elem('ctrl.upload')
+				.add( this.elem('ctrl.reset') )
+				[empty || active ? 'attr' : 'removeAttr']('aria-disabled', empty || active)
+				[propFn]('disabled', empty || active)
+			;
+		},
+
+		_makeFilePreview: function (uid, file, opts, global){
+			var
+				  _this = this
+				, $el = global ? _this.$(opts.el) : _this.fileElem(uid).find(opts.el)
+			;
+
+			if( /^image/.test(file.type) ){
+				api.log('_makeFilePreview:', uid, file);
+
+				var
+					  image = api.Image(file)
+					, doneFn = function (){
+						image.get(function (err, img){
+							if( !_this._crop[uid] ){
+								if( err ){
+									opts.get && opts.get($el, file);
+									_this.emit('filePreviewError', { error: err, file: file });
+								} else {
+									$el.html(img);
+								}
+							}
+						});
+					}
+				;
+
+				if( opts.width ){
+					image.preview(opts.width, opts.height);
+				}
+
+				if( opts.rotate ){
+					image.rotate(opts.rotate);
+				}
+
+				if( opts.processing ){
+					opts.processing(file, image, doneFn);
+				} else {
+					doneFn();
+				}
+			}
+			else {
+				opts.get && opts.get($el, file);
+			}
+		},
+
+		emit: function (name, arg){
+			var opts = this.options, evt = $.Event(name), res;
+			evt.widget = this;
+			name = $.camelCase('on-'+name.replace(/(file)(upload)/, '$1-$2'));
+			if( $.isFunction(opts[name]) ){
+				res = opts[name].call(this.el, evt, arg);
+			}
+			return	(res !== false) && this.$el.triggerHandler(evt, arg);
+		},
+
+		/**
+		 * Add files to queue
+		 * @param  {Array}    files
+		 * @param  {Boolean}  [reset]
+		 */
+		add: function (files, reset){
+			files = [].concat(files);
+
+			if( files.length ){
+				var
+					  opts = this.options
+					, sortFn = opts.sortFn
+					, preview = opts.elements.preview
+				;
+
+				if( sortFn ){
+					files.sort(sortFn);
+				}
+
+				if( preview && preview.el ){
+					api.each(files, function (file){
+						this._makeFilePreview(api.uid(file), file, preview, true);
+					}, this);
+				}
+
+				if( this.xhr ){
+					this.xhr.append(files);
+				}
+
+				this.queue = reset ? files : this.queue.concat(files);
+				this.files = reset ? files : this.files.concat(files);
+
+				if( this.options.autoUpload ){
+					this.upload();
+				} else {
+					this._redraw();
+				}
+			}
+		},
+
+		/**
+		 * Find element
+		 * @param	{String}	sel
+		 * @param	{jQuery}	[ctx]
+		 * @return	{jQuery}
+		 */
+		$: function (sel, ctx){
+			if( typeof sel === 'string' ){
+				sel	= /^#/.test(sel) ? sel : (ctx ? $(ctx) : this.$el).find(sel);
+			}
+			return	$(sel);
+		},
+
+		/**
+		 * @param  {String}   name
+		 * @param  {Boolean}  [up]
+		 * @return {jQuery}
+		 */
+		elem: function (name, up){
+			var sel = this.option('elements.'+name);
+			if( sel === void 0 && up ){
+				sel = this.option('elements.'+name.substr(0, name.lastIndexOf('.')));
+			}
+			return	this.$($.type(sel) != 'string' && $.isEmptyObject(sel) ? [] : sel);
+		},
+
+		/**
+		 * @param  {String}  uid
+		 * @return {jQuery}
+		 */
+		fileElem: function (uid){
+			return	this.$('['+_dataFileId+'="'+uid+'"]');
+		},
+
+		/**
+		 * Get/set options
+		 * @param {String} name
+		 * @param {*} [value]
+		 * @return {*}
+		 */
+		option: function (name, value){
+			if( value !== void 0 && $.isPlainObject(value) ){
+				api.each(value, function (val, key){
+					this.option(name+'.'+key, val);
+				}, this);
+
+				return	this;
+			}
+
+			var opts = this.options, val = opts[name], i = 0, len, part;
+
+			if( name.indexOf('.') != -1 ){
+				val  = opts;
+				name = name.split('.');
+				len  = name.length;
+
+				for( ; i < len; i++ ){
+					part = name[i];
+
+					if( (value !== void 0) && (len - i === 1) ){
+						val[part] = value;
+						break;
+					}
+					else if( val[part] === void 0 ){
+						val[part] = {};
+					}
+
+					val = val[part];
+				}
+			}
+			else if( value !== void 0 ){
+				opts[name] = value;
+			}
+
+			if( value !== void 0 ){
+				this._setOption(name, value, this._options[name]);
+				this._options[name] = value;
+			}
+
+			return	value !== void 0 ? value : val;
+		},
+
+		_setOption: function (name, nVal){
+			switch( name ){
+				case 'accept':
+				case 'multiple':
+				case 'paramName':
+						if( name == 'paramName' ){ name = 'name'; }
+						if( nVal ){
+							this.$(':file')[propFn](name, nVal);
+						}
+					break;
+			}
+		},
+
+		serialize: function (){
+			var obj = {}, val;
+
+			this.$el.find(':input').each(function(name, node){
+				if(
+					   (name = node.name) && !node.disabled
+					&& (node.checked || /select|textarea|input/i.test(node.nodeName) && /checkbox|radio/i.test(node.type))
+				){
+					val	= $(node).val();
+					if( obj[name] !== void 0 ){
+						if( !obj[name].push ){
+							obj[name] = [obj[name]];
+						}
+
+						obj[name].push(val);
+					} else {
+						obj[name] = val;
+					}
+				}
+			});
+
+			return	obj;
+		},
+
+		upload: function (){
+			if( !this.active ){
+				this.active = true;
+
+				var
+					  $el = this.$el
+					, opts = this.options
+					, files = {}
+					, uploadOpts = {
+						  url:   opts.url
+						, data:  $.extend({}, this.serialize(), opts.data)
+						, files: files
+						, chunkSize: opts.chunkSize|0
+						, chunkUploadRetry: opts.chunkUploadRetry|0
+						, prepare: _bind(this, this._onFileUploadPrepare)
+						, imageTransform: opts.imageTransform
+					}
+				;
+
+				// Set files
+				files[$el.find(':file').attr('name') || 'files[]'] = this.queue;
+
+				// Add event listeners
+				api.each(['upload', 'progress', 'complete'], function (name){
+					uploadOpts[name] = _bind(this, this[$.camelCase('_emit-'+name+'Event')], '');
+					uploadOpts['file'+name] = _bind(this, this[$.camelCase('_emit-'+name+'Event')], 'file');
+				}, this);
+
+				// Start uploading
+				this.xhr = api.upload(uploadOpts);
+				this._redraw();
+			}
+		},
+
+		crop: function (file, coords){
+			var
+				  uid = api.uid(file)
+				, opts = this.options
+				, preview = opts.multiple ? this.option('elements.file.preview') : opts.elements.preview
+				, $el = (opts.multiple ? this.fileElem(uid) : this.$el).find(preview && preview.el)
+			;
+
+			if( $el.length ){
+				api.getInfo(file, _bind(this, function (err, info){
+					if( !err ){
+						// @todo error emit
+						if( !$el.find('div>div').length ){
+							$el.html(
+								$('<div><div></div></div>')
+									.css(preview)
+									.css('overflow', 'hidden')
+							);
+						}
+
+						if( this.__cropFile !== file ){
+							this.__cropFile = file;
+							api.Image(file).rotate(opts.imageAutoOrientation ? 'auto' : 0).get(function (err, img){
+								$el.find('>div>div').html($(img).width('100%').height('100%'));
+							}, 'exactFit');
+						}
+
+
+						var rx = preview.width/coords.w, ry = preview.height/coords.h;
+
+						$el.find('>div>div').css({
+							  width:	Math.round(rx * info.width)
+							, height:	Math.round(ry * info.height)
+							, marginLeft:	-Math.round(rx * coords.x)
+							, marginTop:	-Math.round(ry * coords.y)
+						});
+					}
+				}));
+			}
+
+			this._crop[uid] = coords;
+		},
+
+		rotate: function (file, deg){
+			var
+				  uid = typeof file == 'object' ? api.uid(file) : file
+				, opts = this.options
+				, preview = opts.multiple ? this.option('elements.file.preview') : opts.elements.preview
+				, $el = (opts.multiple ? this.fileElem(uid) : this.$el).find(preview && preview.el)
+				, _rotate = this._rotate
+			;
+
+			if( /([+-])=/.test(deg) ){
+				deg = _rotate[uid] = (_rotate[uid] || 0) + (RegExp.$1 == '+' ? 1 : -1) * deg.substr(2);
+			} else {
+				_rotate[uid] = deg;
+			}
+
+			$el.css({
+				  '-webkit-transform': 'rotate('+deg+'deg)'
+				, '-moz-transform': 'rotate('+deg+'deg)'
+				, 'transform': 'rotate('+deg+'deg)'
+			});
+		},
+
+		clear: function (){
+			this.queue = [];
+			this._redraw();
+		},
+
+		widget: function (){
+			return	this;
+		},
+
+		destroy: function (){
+			this.$el
+				.off('.fileapi')
+				.removeData('fileapi')
+			;
+		}
+	};
+
+
+	function _isOriginTransform(trans){
+		var key;
+		for( key in trans ){
+			if( trans.hasOwnProperty(key) ){
+				if( !(trans[key] instanceof Object || key === 'overlay') ){
+					return	true;
+				}
+			}
+		}
+		return	false;
+	}
+
+
+
+
+
+	/**
+	 * @export
+	 * @param	{Object}	options
+	 * @param	{String}	[value]
+	 */
+	$.fn.fileapi = function (options, value){
+		var plugin = this.data('fileapi');
+
+		if( plugin ){
+			if( options === 'widget' ){
+				return	plugin;
+			}
+
+			if( typeof options == 'string' ){
+				var fn = plugin[options], res;
+				if( $.isFunction(fn) ){
+					res = fn.call(plugin, value, arguments[2]);
+				}
+				else if( fn === void 0 ){
+					res = this.option(options, value);
+				}
+				return	res === void 0 ? this : res;
+			}
+		} else {
+			this.data('fileapi', new Plugin(this, options));
+		}
+
+		return	this;
+	};
+
+
+	$.fn.fileapi.version = '0.1.2';
+	$.fn.fileapi.tpl = function (text){
+		var index = 0;
+		var source = "__b+='";
+
+		text.replace(/(?:&lt;|<)%([-=])?([\s\S]+?)%(?:&gt;|>)|$/g, function (match, mode, expr, offset){
+			source += text.slice(index, offset).replace(/[\r\n"']/g, function (match){ return '\\'+match; });
+
+			if( expr ){
+				if( mode ){
+					source	+= "'+\n((__x=("+ expr +"))==null?'':" + (mode == "-" ? "__esc(__x)" : "__x")+")\n+'";
+				} else {
+					source	+= "';\n"+ expr +"\n__b+='";
+				}
+			}
+
+			index = offset + match.length;
+			return match;
+		});
+
+		return new Function("ctx", "var __x,__b=''," +
+			"__esc=function(val){return typeof val=='string'?val.replace(/</g,'&lt;').replace(/\"/g,'&quot;'):val;};" +
+			"with(ctx||{}){\n"+ source +"';\n}return __b;");
+	};
+
+
+	/**
+	 * FileAPI.Camera wrapper
+	 * @param  {Object|String}  options
+	 * @returns {jQuery}
+	 */
+	$.fn.webcam = function (options){
+		var el = this, ret = el, $el = $(el), key = 'fileapi-camera', inst = $el.data(key);
+
+		if( inst === true ){
+			api.log("[webcam.warn] not ready.");
+			ret = null;
+		}
+		else if( options === 'widget' ){
+			ret	= inst;
+		}
+		else if( options === 'destroy' ){
+			inst.stop();
+			$el.empty();
+		}
+		else if( inst ){
+			ret	= inst[options]();
+		}
+		else if( inst === false ){
+			api.log("[webcam.error] вoes not work.");
+			ret = null;
+		}
+		else {
+			$el.data(key, true);
+			options = $.extend({ success: noop, error: noop }, options);
+
+			FileAPI.Camera.publish($el, options, function (err, cam){
+				$el.data(key, err ? false : cam);
+				options[err ? 'error' : 'success'].call(el, err || cam);
+			});
+		}
+
+		return	ret;
+	};
+
+
+	/**
+	 * Wrapper for JCrop
+	 */
+	$.fn.cropper = function (opts){
+		var $el = this, file = opts.file;
+
+		if( typeof opts === 'string' ){
+			$el.first().Jcrop.apply($el, arguments);
+		}
+		else {
+			api.getInfo(file, function (err, info){
+				var Image = api.Image(file);
+
+				if( opts.maxSize ){
+					Image.resize(opts.maxSize[0], opts.maxSize[1], 'max');
+				}
+
+				Image.rotate('auto').get(function (err, img){
+					var
+						  selection = opts.selection
+						, minSide = Math.min(img.width, img.height)
+
+						, selWidth = minSide
+						, selHeight = minSide / (opts.aspectRatio || 1)
+					;
+
+					if( selection ){
+						if( /%/.test(selection) || (selection > 0 && selection < 1) ){
+							selection	 = parseFloat(selection, 10) / (selection > 0 ? 1 : 100);
+							selWidth	*= selection;
+							selHeight	*= selection;
+						}
+
+						var
+							  selLeft = (img.width - selWidth)/2
+							, selTop = (img.height - selHeight)/2
+						;
+
+						opts.setSelect = [selLeft|0, selTop|0, (selLeft + selWidth)|0, (selTop + selHeight)|0];
+					}
+
+					api.each(['onSelect', 'onChange'], function (name, fn){
+						if( fn = opts[name] ){
+							opts[name] = function (coords){
+								var fw = info.width/img.width, fh = info.height/img.height;
+								fn({
+									  x: (coords.x * fw + 0.5)|0
+									, y: (coords.y * fh + 0.5)|0
+									, w: (coords.w * fw + 0.5)|0
+									, h: (coords.h * fh + 0.5)|0
+								});
+							};
+						}
+					});
+
+					var $inner = $('<div/>').css('lineHeight', 0).append( $(img).css('margin', 0) );
+					$el.html($inner);
+					$inner.Jcrop(opts).trigger('resize');
+				});
+			});
+		}
+
+		return	$el;
+	};
+})(jQuery, FileAPI);