diff --git a/application/dashboard.class.inc.php b/application/dashboard.class.inc.php index f480bbde2..90b1faeb8 100644 --- a/application/dashboard.class.inc.php +++ b/application/dashboard.class.inc.php @@ -1118,8 +1118,8 @@ JS */ protected function RenderEditionTools(WebPage $oPage, DashboardLayoutUIBlock $oDashboard, $aExtraParams) { - $oPage->add_linked_script(utils::GetAbsoluteUrlAppRoot().'js/jquery.iframe-transport.js'); - $oPage->add_linked_script(utils::GetAbsoluteUrlAppRoot().'js/jquery.fileupload.js'); + $oPage->add_linked_script(utils::GetAbsoluteUrlAppRoot().'node_modules/blueimp-file-upload/js/jquery.iframe-transport.js'); + $oPage->add_linked_script(utils::GetAbsoluteUrlAppRoot().'node_modules/blueimp-file-upload/js/jquery.fileupload.js'); $sId = utils::Sanitize($this->GetId(), '', 'element_identifier'); $sMenuTogglerId = "ibo-dashboard-menu-toggler-{$sId}"; diff --git a/datamodels/2.x/itop-attachments/renderers.itop-attachments.php b/datamodels/2.x/itop-attachments/renderers.itop-attachments.php index 5ca66bd74..0b7079d7a 100644 --- a/datamodels/2.x/itop-attachments/renderers.itop-attachments.php +++ b/datamodels/2.x/itop-attachments/renderers.itop-attachments.php @@ -202,8 +202,8 @@ abstract class AbstractAttachmentsRenderer $this->oPage->add(Dict::S('UI:Attachments:DropYourFileHint').''); - $this->oPage->add_linked_script(utils::GetAbsoluteUrlAppRoot().'js/jquery.iframe-transport.js'); - $this->oPage->add_linked_script(utils::GetAbsoluteUrlAppRoot().'js/jquery.fileupload.js'); + $this->oPage->add_linked_script(utils::GetAbsoluteUrlAppRoot().'node_modules/blueimp-file-upload/js/jquery.iframe-transport.js'); + $this->oPage->add_linked_script(utils::GetAbsoluteUrlAppRoot().'node_modules/blueimp-file-upload/js/jquery.fileupload.js'); $this->oPage->add_ready_script( << - - + + diff --git a/js/jquery.fileupload.js b/js/jquery.fileupload.js index bed76d03a..89914a8fb 100644 --- a/js/jquery.fileupload.js +++ b/js/jquery.fileupload.js @@ -1,3 +1,7 @@ +/** + * @deprecated 3.2.0 N°5621 Moved to NPM + */ + /* * jQuery File Upload Plugin * https://github.com/blueimp/jQuery-File-Upload diff --git a/js/jquery.iframe-transport.js b/js/jquery.iframe-transport.js index 8d64b591b..f52682884 100644 --- a/js/jquery.iframe-transport.js +++ b/js/jquery.iframe-transport.js @@ -1,3 +1,7 @@ +/** + * @deprecated 3.2.0 N°5621 Moved to NPM + */ + /* * jQuery Iframe Transport Plugin 1.8.2 * https://github.com/blueimp/jQuery-File-Upload diff --git a/node_modules/.bin/tmpl.js b/node_modules/.bin/tmpl.js new file mode 100644 index 000000000..ccf5d7640 --- /dev/null +++ b/node_modules/.bin/tmpl.js @@ -0,0 +1,16 @@ +#!/bin/sh +basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") + +case `uname` in + *CYGWIN*|*MINGW*|*MSYS*) + if command -v cygpath > /dev/null 2>&1; then + basedir=`cygpath -w "$basedir"` + fi + ;; +esac + +if [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir/../blueimp-tmpl/js/compile.js" "$@" +else + exec node "$basedir/../blueimp-tmpl/js/compile.js" "$@" +fi diff --git a/node_modules/.bin/tmpl.js.cmd b/node_modules/.bin/tmpl.js.cmd new file mode 100644 index 000000000..9aa6d082e --- /dev/null +++ b/node_modules/.bin/tmpl.js.cmd @@ -0,0 +1,17 @@ +@ECHO off +GOTO start +:find_dp0 +SET dp0=%~dp0 +EXIT /b +:start +SETLOCAL +CALL :find_dp0 + +IF EXIST "%dp0%\node.exe" ( + SET "_prog=%dp0%\node.exe" +) ELSE ( + SET "_prog=node" + SET PATHEXT=%PATHEXT:;.JS;=;% +) + +endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\blueimp-tmpl\js\compile.js" %* diff --git a/node_modules/.bin/tmpl.js.ps1 b/node_modules/.bin/tmpl.js.ps1 new file mode 100644 index 000000000..ba3656366 --- /dev/null +++ b/node_modules/.bin/tmpl.js.ps1 @@ -0,0 +1,28 @@ +#!/usr/bin/env pwsh +$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent + +$exe="" +if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { + # Fix case when both the Windows and Linux builds of Node + # are installed in the same directory + $exe=".exe" +} +$ret=0 +if (Test-Path "$basedir/node$exe") { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "$basedir/node$exe" "$basedir/../blueimp-tmpl/js/compile.js" $args + } else { + & "$basedir/node$exe" "$basedir/../blueimp-tmpl/js/compile.js" $args + } + $ret=$LASTEXITCODE +} else { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "node$exe" "$basedir/../blueimp-tmpl/js/compile.js" $args + } else { + & "node$exe" "$basedir/../blueimp-tmpl/js/compile.js" $args + } + $ret=$LASTEXITCODE +} +exit $ret diff --git a/node_modules/.package-lock.json b/node_modules/.package-lock.json index 6bd5e0b24..ed523844a 100644 --- a/node_modules/.package-lock.json +++ b/node_modules/.package-lock.json @@ -21,6 +21,37 @@ "resolved": "https://registry.npmjs.org/ace-builds/-/ace-builds-1.2.8.tgz", "integrity": "sha512-L4m91PcWa1Zj4PA+/JflGAlz86mtoZP96vJmfByUmuNgS+b7odNPBfWRY2gOFhy1kh4J9lresLeINN0yQec8hA==" }, + "node_modules/blueimp-canvas-to-blob": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/blueimp-canvas-to-blob/-/blueimp-canvas-to-blob-3.5.0.tgz", + "integrity": "sha512-1Aq2Yn6SUsOERT4Ng7GUWRy6oRvqeNU2Iwhcq5ZH7aoejFkLEKjRx/XcpepfU7IMmj3sONSmiLmSgzj9umGUPw==", + "optional": true + }, + "node_modules/blueimp-file-upload": { + "version": "9.22.1", + "resolved": "https://registry.npmjs.org/blueimp-file-upload/-/blueimp-file-upload-9.22.1.tgz", + "integrity": "sha512-ezGkn/agWUWZOw8mYa5yYC9LvUlrT5bN3zk2fPlpLWgyhbBMz8BSGKO3M48BWlXWAeR+lVtEhy9xiG8FLnHEVw==", + "optionalDependencies": { + "blueimp-canvas-to-blob": "3.5.0", + "blueimp-load-image": "2.12.2", + "blueimp-tmpl": "3.6.0" + } + }, + "node_modules/blueimp-load-image": { + "version": "2.12.2", + "resolved": "https://registry.npmjs.org/blueimp-load-image/-/blueimp-load-image-2.12.2.tgz", + "integrity": "sha512-o6YeeBo0e6g3/T7mPZtED/y/66VdhMxYVEqE5Owl+9Ew0MpLFgFh6humePBAh0JVRfCtK7CHQ7K84S4GIfaZtg==", + "optional": true + }, + "node_modules/blueimp-tmpl": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/blueimp-tmpl/-/blueimp-tmpl-3.6.0.tgz", + "integrity": "sha512-FPbl2VMophcudvT2Li+y10RtKT4l7wBto1NZycXoVQb1JVlo8QbjDgEqL9Ph41/rUl4dTOv3mqWPoxqCHA1b7A==", + "optional": true, + "bin": { + "tmpl.js": "js/compile.js" + } + }, "node_modules/bulma-scss": { "version": "0.9.4", "resolved": "https://registry.npmjs.org/bulma-scss/-/bulma-scss-0.9.4.tgz", diff --git a/node_modules/blueimp-canvas-to-blob/README.md b/node_modules/blueimp-canvas-to-blob/README.md new file mode 100644 index 000000000..b6af2c2c2 --- /dev/null +++ b/node_modules/blueimp-canvas-to-blob/README.md @@ -0,0 +1,84 @@ +# JavaScript Canvas to Blob + +## Description +Canvas to Blob is a polyfill for the standard JavaScript +[canvas.toBlob](http://www.w3.org/TR/html5/scripting-1.html#dom-canvas-toblob) +method. + +It can be used to create +[Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob) +objects from an HTML +[canvas](https://developer.mozilla.org/en-US/docs/HTML/Canvas) element. + +## Usage +Include the (minified) JavaScript Canvas to Blob script in your HTML markup: + +```html + +``` + +Then use the *canvas.toBlob()* method in the same way as the native +implementation: + +```js +var canvas = document.createElement('canvas'); +/* ... your canvas manipulations ... */ +if (canvas.toBlob) { + canvas.toBlob( + function (blob) { + // Do something with the blob object, + // e.g. creating a multipart form for file uploads: + var formData = new FormData(); + formData.append('file', blob, fileName); + /* ... */ + }, + 'image/jpeg' + ); +} +``` + +## Requirements +The JavaScript Canvas to Blob function has zero dependencies. + +However, Canvas to Blob is a very suitable complement to the +[JavaScript Load Image](https://github.com/blueimp/JavaScript-Load-Image) +function. + +## API +In addition to the **canvas.toBlob** polyfill, the JavaScript Canvas to Blob +script provides one additional function called **dataURLtoBlob**, which is added +to the global window object, unless the library is loaded via a module loader +like RequireJS, Browserify or webpack: + +```js +// 80x60px GIF image (color black, base64 data): +var b64Data = 'R0lGODdhUAA8AIABAAAAAP///ywAAAAAUAA8AAACS4SPqcvtD6' + + 'OctNqLs968+w+G4kiW5omm6sq27gvH8kzX9o3n+s73/g8MCofE' + + 'ovGITCqXzKbzCY1Kp9Sq9YrNarfcrvcLDovH5PKsAAA7', + imageUrl = 'data:image/gif;base64,' + b64Data, + blob = window.dataURLtoBlob && window.dataURLtoBlob(imageUrl); +``` + +## Browsers +The following browsers support either the native or the polyfill +*canvas.toBlob()* method: + +### Desktop browsers + +* Google Chrome (see [Chromium issue #67587](https://code.google.com/p/chromium/issues/detail?id=67587)) +* Apple Safari 6.0+ (see [Mozilla issue #648610](https://bugzilla.mozilla.org/show_bug.cgi?id=648610)) +* Mozilla Firefox 4.0+ +* Microsoft Internet Explorer 10.0+ + +### Mobile browsers + +* Apple Safari Mobile on iOS 6.0+ +* Google Chrome on iOS 6.0+ +* Google Chrome on Android 4.0+ + +## Test +[JavaScript Canvas to Blob Test](https://blueimp.github.io/JavaScript-Canvas-to-Blob/test/) + +## License +The JavaScript Canvas to Blob script is released under the +[MIT license](http://www.opensource.org/licenses/MIT). diff --git a/node_modules/blueimp-canvas-to-blob/js/canvas-to-blob.js b/node_modules/blueimp-canvas-to-blob/js/canvas-to-blob.js new file mode 100644 index 000000000..32913667b --- /dev/null +++ b/node_modules/blueimp-canvas-to-blob/js/canvas-to-blob.js @@ -0,0 +1,111 @@ +/* + * JavaScript Canvas to Blob + * https://github.com/blueimp/JavaScript-Canvas-to-Blob + * + * Copyright 2012, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * http://www.opensource.org/licenses/MIT + * + * Based on stackoverflow user Stoive's code snippet: + * http://stackoverflow.com/q/4998908 + */ + +/* global atob, Blob, define */ + +;(function (window) { + 'use strict' + + var CanvasPrototype = window.HTMLCanvasElement && + window.HTMLCanvasElement.prototype + var hasBlobConstructor = window.Blob && (function () { + try { + return Boolean(new Blob()) + } catch (e) { + return false + } + }()) + var hasArrayBufferViewSupport = hasBlobConstructor && window.Uint8Array && + (function () { + try { + return new Blob([new Uint8Array(100)]).size === 100 + } catch (e) { + return false + } + }()) + var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || + window.MozBlobBuilder || window.MSBlobBuilder + var dataURIPattern = /^data:((.*?)(;charset=.*?)?)(;base64)?,/ + var dataURLtoBlob = (hasBlobConstructor || BlobBuilder) && window.atob && + window.ArrayBuffer && window.Uint8Array && + function (dataURI) { + var matches, + mediaType, + isBase64, + dataString, + byteString, + arrayBuffer, + intArray, + i, + bb + // Parse the dataURI components as per RFC 2397 + matches = dataURI.match(dataURIPattern) + if (!matches) { + throw new Error('invalid data URI') + } + // Default to text/plain;charset=US-ASCII + mediaType = matches[2] + ? matches[1] + : 'text/plain' + (matches[3] || ';charset=US-ASCII') + isBase64 = !!matches[4] + dataString = dataURI.slice(matches[0].length) + if (isBase64) { + // Convert base64 to raw binary data held in a string: + byteString = atob(dataString) + } else { + // Convert base64/URLEncoded data component to raw binary: + byteString = decodeURIComponent(dataString) + } + // Write the bytes of the string to an ArrayBuffer: + arrayBuffer = new ArrayBuffer(byteString.length) + intArray = new Uint8Array(arrayBuffer) + for (i = 0; i < byteString.length; i += 1) { + intArray[i] = byteString.charCodeAt(i) + } + // Write the ArrayBuffer (or ArrayBufferView) to a blob: + if (hasBlobConstructor) { + return new Blob( + [hasArrayBufferViewSupport ? intArray : arrayBuffer], + {type: mediaType} + ) + } + bb = new BlobBuilder() + bb.append(arrayBuffer) + return bb.getBlob(mediaType) + } + if (window.HTMLCanvasElement && !CanvasPrototype.toBlob) { + if (CanvasPrototype.mozGetAsFile) { + CanvasPrototype.toBlob = function (callback, type, quality) { + if (quality && CanvasPrototype.toDataURL && dataURLtoBlob) { + callback(dataURLtoBlob(this.toDataURL(type, quality))) + } else { + callback(this.mozGetAsFile('blob', type)) + } + } + } else if (CanvasPrototype.toDataURL && dataURLtoBlob) { + CanvasPrototype.toBlob = function (callback, type, quality) { + callback(dataURLtoBlob(this.toDataURL(type, quality))) + } + } + } + if (typeof define === 'function' && define.amd) { + define(function () { + return dataURLtoBlob + }) + } else if (typeof module === 'object' && module.exports) { + module.exports = dataURLtoBlob + } else { + window.dataURLtoBlob = dataURLtoBlob + } +}(window)) diff --git a/node_modules/blueimp-canvas-to-blob/package.json b/node_modules/blueimp-canvas-to-blob/package.json new file mode 100644 index 000000000..f15fd279a --- /dev/null +++ b/node_modules/blueimp-canvas-to-blob/package.json @@ -0,0 +1,39 @@ +{ + "name": "blueimp-canvas-to-blob", + "version": "3.5.0", + "title": "JavaScript Canvas to Blob", + "description": "Canvas to Blob is a polyfill for the standard JavaScript canvas.toBlob method. It can be used to create Blob objects from an HTML canvas element.", + "keywords": [ + "javascript", + "canvas", + "blob", + "convert", + "conversion" + ], + "homepage": "https://github.com/blueimp/JavaScript-Canvas-to-Blob", + "author": { + "name": "Sebastian Tschan", + "url": "https://blueimp.net" + }, + "repository": { + "type": "git", + "url": "git://github.com/blueimp/JavaScript-Canvas-to-Blob.git" + }, + "license": "MIT", + "main": "./js/canvas-to-blob.js", + "devDependencies": { + "phantomjs-prebuilt": "2.1.13", + "mocha-phantomjs-core": "1.3.1", + "standard": "8.3.0", + "uglify-js": "2.7.3" + }, + "scripts": { + "lint": "standard js/*.js test/*.js", + "unit": "phantomjs node_modules/mocha-phantomjs-core/mocha-phantomjs-core.js test/index.html", + "test": "npm run lint && npm run unit", + "build": "cd js && uglifyjs canvas-to-blob.js -c -m -o canvas-to-blob.min.js --source-map canvas-to-blob.min.js.map", + "preversion": "npm test", + "version": "npm run build && git add -A js", + "postversion": "git push --tags origin master master:gh-pages && npm publish" + } +} diff --git a/node_modules/blueimp-file-upload/LICENSE.txt b/node_modules/blueimp-file-upload/LICENSE.txt new file mode 100644 index 000000000..87a644638 --- /dev/null +++ b/node_modules/blueimp-file-upload/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright © 2010 Sebastian Tschan, https://blueimp.net + +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. diff --git a/node_modules/blueimp-file-upload/README.md b/node_modules/blueimp-file-upload/README.md new file mode 100644 index 000000000..76bdf89d5 --- /dev/null +++ b/node_modules/blueimp-file-upload/README.md @@ -0,0 +1,107 @@ +# jQuery File Upload Plugin + +## Demo +[Demo File Upload](https://blueimp.github.io/jQuery-File-Upload/) + +## Description +File Upload widget with multiple file selection, drag&drop support, progress bars, validation and preview images, audio and video for jQuery. +Supports cross-domain, chunked and resumable file uploads and client-side image resizing. Works with any server-side platform (PHP, Python, Ruby on Rails, Java, Node.js, Go etc.) that supports standard HTML form file uploads. + +## Setup +* [How to setup the plugin on your website](https://github.com/blueimp/jQuery-File-Upload/wiki/Setup) +* [How to use only the basic plugin (minimal setup guide).](https://github.com/blueimp/jQuery-File-Upload/wiki/Basic-plugin) + +## Features +* **Multiple file upload:** + Allows to select multiple files at once and upload them simultaneously. +* **Drag & Drop support:** + Allows to upload files by dragging them from your desktop or filemanager and dropping them on your browser window. +* **Upload progress bar:** + Shows a progress bar indicating the upload progress for individual files and for all uploads combined. +* **Cancelable uploads:** + Individual file uploads can be canceled to stop the upload progress. +* **Resumable uploads:** + Aborted uploads can be resumed with browsers supporting the Blob API. +* **Chunked uploads:** + Large files can be uploaded in smaller chunks with browsers supporting the Blob API. +* **Client-side image resizing:** + Images can be automatically resized on client-side with browsers supporting the required JS APIs. +* **Preview images, audio and video:** + A preview of image, audio and video files can be displayed before uploading with browsers supporting the required APIs. +* **No browser plugins (e.g. Adobe Flash) required:** + The implementation is based on open standards like HTML5 and JavaScript and requires no additional browser plugins. +* **Graceful fallback for legacy browsers:** + Uploads files via XMLHttpRequests if supported and uses iframes as fallback for legacy browsers. +* **HTML file upload form fallback:** + Allows progressive enhancement by using a standard HTML file upload form as widget element. +* **Cross-site file uploads:** + Supports uploading files to a different domain with cross-site XMLHttpRequests or iframe redirects. +* **Multiple plugin instances:** + Allows to use multiple plugin instances on the same webpage. +* **Customizable and extensible:** + Provides an API to set individual options and define callback methods for various upload events. +* **Multipart and file contents stream uploads:** + Files can be uploaded as standard "multipart/form-data" or file contents stream (HTTP PUT file upload). +* **Compatible with any server-side application platform:** + Works with any server-side platform (PHP, Python, Ruby on Rails, Java, Node.js, Go etc.) that supports standard HTML form file uploads. + +## Requirements + +### Mandatory requirements +* [jQuery](https://jquery.com/) v. 1.6+ +* [jQuery UI widget factory](https://api.jqueryui.com/jQuery.widget/) v. 1.9+ (included): Required for the basic File Upload plugin, but very lightweight without any other dependencies from the jQuery UI suite. +* [jQuery Iframe Transport plugin](https://github.com/blueimp/jQuery-File-Upload/blob/master/js/jquery.iframe-transport.js) (included): Required for [browsers without XHR file upload support](https://github.com/blueimp/jQuery-File-Upload/wiki/Browser-support). + +### Optional requirements +* [JavaScript Templates engine](https://github.com/blueimp/JavaScript-Templates) v. 2.5.4+: Used to render the selected and uploaded files for the Basic Plus UI and jQuery UI versions. +* [JavaScript Load Image library](https://github.com/blueimp/JavaScript-Load-Image) v. 1.13.0+: Required for the image previews and resizing functionality. +* [JavaScript Canvas to Blob polyfill](https://github.com/blueimp/JavaScript-Canvas-to-Blob) v. 2.1.1+:Required for the image previews and resizing functionality. +* [blueimp Gallery](https://github.com/blueimp/Gallery) v. 2.15.1+: Used to display the uploaded images in a lightbox. +* [Bootstrap](http://getbootstrap.com/) v. 3.2.0+ +* [Glyphicons](http://glyphicons.com/) + +The user interface of all versions, except the jQuery UI version, is built with [Bootstrap](http://getbootstrap.com/) and icons from [Glyphicons](http://glyphicons.com/). + +### Cross-domain requirements +[Cross-domain File Uploads](https://github.com/blueimp/jQuery-File-Upload/wiki/Cross-domain-uploads) using the [Iframe Transport plugin](https://github.com/blueimp/jQuery-File-Upload/blob/master/js/jquery.iframe-transport.js) require a redirect back to the origin server to retrieve the upload results. The [example implementation](https://github.com/blueimp/jQuery-File-Upload/blob/master/js/main.js) makes use of [result.html](https://github.com/blueimp/jQuery-File-Upload/blob/master/cors/result.html) as a static redirect page for the origin server. + +The repository also includes the [jQuery XDomainRequest Transport plugin](https://github.com/blueimp/jQuery-File-Upload/blob/master/js/cors/jquery.xdr-transport.js), which enables limited cross-domain AJAX requests in Microsoft Internet Explorer 8 and 9 (IE 10 supports cross-domain XHR requests). +The XDomainRequest object allows GET and POST requests only and doesn't support file uploads. It is used on the [Demo](https://blueimp.github.io/jQuery-File-Upload/) to delete uploaded files from the cross-domain demo file upload service. + +### Custom Backends + +You can add support for various backends by adhering to the specification [outlined here](https://github.com/blueimp/jQuery-File-Upload/wiki/JSON-Response). + +## Browsers + +### Desktop browsers +The File Upload plugin is regularly tested with the latest browser versions and supports the following minimal versions: + +* Google Chrome +* Apple Safari 4.0+ +* Mozilla Firefox 3.0+ +* Opera 11.0+ +* Microsoft Internet Explorer 6.0+ + +### Mobile browsers +The File Upload plugin has been tested with and supports the following mobile browsers: + +* Apple Safari on iOS 6.0+ +* Google Chrome on iOS 6.0+ +* Google Chrome on Android 4.0+ +* Default Browser on Android 2.3+ +* Opera Mobile 12.0+ + +### Supported features +For a detailed overview of the features supported by each browser version, please have a look at the [Extended browser support information](https://github.com/blueimp/jQuery-File-Upload/wiki/Browser-support). + +## Contributing +**Bug fixes** and **new features** can be proposed using [pull requests](https://github.com/blueimp/jQuery-File-Upload/pulls). +Please read the [contribution guidelines](https://github.com/blueimp/jQuery-File-Upload/blob/master/CONTRIBUTING.md) before submitting a pull request. + +## Support +This project is actively maintained, but there is no official support channel. +If you have a question that another developer might help you with, please post to [Stack Overflow](http://stackoverflow.com/questions/tagged/blueimp+jquery+file-upload) and tag your question with `blueimp jquery file upload`. + +## License +Released under the [MIT license](https://opensource.org/licenses/MIT). diff --git a/node_modules/blueimp-file-upload/css/jquery.fileupload-noscript.css b/node_modules/blueimp-file-upload/css/jquery.fileupload-noscript.css new file mode 100644 index 000000000..2409bfb0a --- /dev/null +++ b/node_modules/blueimp-file-upload/css/jquery.fileupload-noscript.css @@ -0,0 +1,22 @@ +@charset "UTF-8"; +/* + * jQuery File Upload Plugin NoScript CSS + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +.fileinput-button input { + position: static; + opacity: 1; + filter: none; + font-size: inherit !important; + direction: inherit; +} +.fileinput-button span { + display: none; +} diff --git a/node_modules/blueimp-file-upload/css/jquery.fileupload-ui-noscript.css b/node_modules/blueimp-file-upload/css/jquery.fileupload-ui-noscript.css new file mode 100644 index 000000000..30651acf0 --- /dev/null +++ b/node_modules/blueimp-file-upload/css/jquery.fileupload-ui-noscript.css @@ -0,0 +1,17 @@ +@charset "UTF-8"; +/* + * jQuery File Upload UI Plugin NoScript CSS + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2012, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +.fileinput-button i, +.fileupload-buttonbar .delete, +.fileupload-buttonbar .toggle { + display: none; +} diff --git a/node_modules/blueimp-file-upload/css/jquery.fileupload-ui.css b/node_modules/blueimp-file-upload/css/jquery.fileupload-ui.css new file mode 100644 index 000000000..9e36c42c5 --- /dev/null +++ b/node_modules/blueimp-file-upload/css/jquery.fileupload-ui.css @@ -0,0 +1,57 @@ +@charset "UTF-8"; +/* + * jQuery File Upload UI Plugin CSS + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2010, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +.fileupload-buttonbar .btn, +.fileupload-buttonbar .toggle { + margin-bottom: 5px; +} +.progress-animated .progress-bar, +.progress-animated .bar { + background: url("../img/progressbar.gif") !important; + filter: none; +} +.fileupload-process { + float: right; + display: none; +} +.fileupload-processing .fileupload-process, +.files .processing .preview { + display: block; + width: 32px; + height: 32px; + background: url("../img/loading.gif") center no-repeat; + background-size: contain; +} +.files audio, +.files video { + max-width: 300px; +} + +@media (max-width: 767px) { + .fileupload-buttonbar .toggle, + .files .toggle, + .files .btn span { + display: none; + } + .files .name { + width: 80px; + word-wrap: break-word; + } + .files audio, + .files video { + max-width: 80px; + } + .files img, + .files canvas { + max-width: 100%; + } +} diff --git a/node_modules/blueimp-file-upload/css/jquery.fileupload.css b/node_modules/blueimp-file-upload/css/jquery.fileupload.css new file mode 100644 index 000000000..8ae3b09d4 --- /dev/null +++ b/node_modules/blueimp-file-upload/css/jquery.fileupload.css @@ -0,0 +1,37 @@ +@charset "UTF-8"; +/* + * jQuery File Upload Plugin CSS + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +.fileinput-button { + position: relative; + overflow: hidden; + display: inline-block; +} +.fileinput-button input { + position: absolute; + top: 0; + right: 0; + margin: 0; + opacity: 0; + -ms-filter: 'alpha(opacity=0)'; + font-size: 200px !important; + direction: ltr; + cursor: pointer; +} + +/* Fixes for IE < 8 */ +@media screen\9 { + .fileinput-button input { + filter: alpha(opacity=0); + font-size: 100%; + height: 100%; + } +} diff --git a/node_modules/blueimp-file-upload/img/loading.gif b/node_modules/blueimp-file-upload/img/loading.gif new file mode 100644 index 000000000..90f28cbdb Binary files /dev/null and b/node_modules/blueimp-file-upload/img/loading.gif differ diff --git a/node_modules/blueimp-file-upload/img/progressbar.gif b/node_modules/blueimp-file-upload/img/progressbar.gif new file mode 100644 index 000000000..fbcce6bc9 Binary files /dev/null and b/node_modules/blueimp-file-upload/img/progressbar.gif differ diff --git a/node_modules/blueimp-file-upload/js/cors/jquery.postmessage-transport.js b/node_modules/blueimp-file-upload/js/cors/jquery.postmessage-transport.js new file mode 100644 index 000000000..2a0c38cb6 --- /dev/null +++ b/node_modules/blueimp-file-upload/js/cors/jquery.postmessage-transport.js @@ -0,0 +1,126 @@ +/* + * jQuery postMessage Transport Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2011, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* global define, require, window, document */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define(['jquery'], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory(require('jquery')); + } else { + // Browser globals: + factory(window.jQuery); + } +}(function ($) { + 'use strict'; + + var counter = 0, + names = [ + 'accepts', + 'cache', + 'contents', + 'contentType', + 'crossDomain', + 'data', + 'dataType', + 'headers', + 'ifModified', + 'mimeType', + 'password', + 'processData', + 'timeout', + 'traditional', + 'type', + 'url', + 'username' + ], + convert = function (p) { + return p; + }; + + $.ajaxSetup({ + converters: { + 'postmessage text': convert, + 'postmessage json': convert, + 'postmessage html': convert + } + }); + + $.ajaxTransport('postmessage', function (options) { + if (options.postMessage && window.postMessage) { + var iframe, + loc = $('').prop('href', options.postMessage)[0], + target = loc.protocol + '//' + loc.host, + xhrUpload = options.xhr().upload; + // IE always includes the port for the host property of a link + // element, but not in the location.host or origin property for the + // default http port 80 and https port 443, so we strip it: + if (/^(http:\/\/.+:80)|(https:\/\/.+:443)$/.test(target)) { + target = target.replace(/:(80|443)$/, ''); + } + return { + send: function (_, completeCallback) { + counter += 1; + var message = { + id: 'postmessage-transport-' + counter + }, + eventName = 'message.' + message.id; + iframe = $( + '' + ).bind('load', function () { + $.each(names, function (i, name) { + message[name] = options[name]; + }); + message.dataType = message.dataType.replace('postmessage ', ''); + $(window).bind(eventName, function (e) { + e = e.originalEvent; + var data = e.data, + ev; + if (e.origin === target && data.id === message.id) { + if (data.type === 'progress') { + ev = document.createEvent('Event'); + ev.initEvent(data.type, false, true); + $.extend(ev, data); + xhrUpload.dispatchEvent(ev); + } else { + completeCallback( + data.status, + data.statusText, + {postmessage: data.result}, + data.headers + ); + iframe.remove(); + $(window).unbind(eventName); + } + } + }); + iframe[0].contentWindow.postMessage( + message, + target + ); + }).appendTo(document.body); + }, + abort: function () { + if (iframe) { + iframe.remove(); + } + } + }; + } + }); + +})); diff --git a/node_modules/blueimp-file-upload/js/cors/jquery.xdr-transport.js b/node_modules/blueimp-file-upload/js/cors/jquery.xdr-transport.js new file mode 100644 index 000000000..a4e2699c6 --- /dev/null +++ b/node_modules/blueimp-file-upload/js/cors/jquery.xdr-transport.js @@ -0,0 +1,89 @@ +/* + * jQuery XDomainRequest Transport Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2011, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + * + * Based on Julian Aubourg's ajaxHooks xdr.js: + * https://github.com/jaubourg/ajaxHooks/ + */ + +/* global define, require, window, XDomainRequest */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define(['jquery'], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory(require('jquery')); + } else { + // Browser globals: + factory(window.jQuery); + } +}(function ($) { + 'use strict'; + if (window.XDomainRequest && !$.support.cors) { + $.ajaxTransport(function (s) { + if (s.crossDomain && s.async) { + if (s.timeout) { + s.xdrTimeout = s.timeout; + delete s.timeout; + } + var xdr; + return { + send: function (headers, completeCallback) { + var addParamChar = /\?/.test(s.url) ? '&' : '?'; + function callback(status, statusText, responses, responseHeaders) { + xdr.onload = xdr.onerror = xdr.ontimeout = $.noop; + xdr = null; + completeCallback(status, statusText, responses, responseHeaders); + } + xdr = new XDomainRequest(); + // XDomainRequest only supports GET and POST: + if (s.type === 'DELETE') { + s.url = s.url + addParamChar + '_method=DELETE'; + s.type = 'POST'; + } else if (s.type === 'PUT') { + s.url = s.url + addParamChar + '_method=PUT'; + s.type = 'POST'; + } else if (s.type === 'PATCH') { + s.url = s.url + addParamChar + '_method=PATCH'; + s.type = 'POST'; + } + xdr.open(s.type, s.url); + xdr.onload = function () { + callback( + 200, + 'OK', + {text: xdr.responseText}, + 'Content-Type: ' + xdr.contentType + ); + }; + xdr.onerror = function () { + callback(404, 'Not Found'); + }; + if (s.xdrTimeout) { + xdr.ontimeout = function () { + callback(0, 'timeout'); + }; + xdr.timeout = s.xdrTimeout; + } + xdr.send((s.hasContent && s.data) || null); + }, + abort: function () { + if (xdr) { + xdr.onerror = $.noop(); + xdr.abort(); + } + } + }; + } + }); + } +})); diff --git a/node_modules/blueimp-file-upload/js/jquery.fileupload-angular.js b/node_modules/blueimp-file-upload/js/jquery.fileupload-angular.js new file mode 100644 index 000000000..1c2055276 --- /dev/null +++ b/node_modules/blueimp-file-upload/js/jquery.fileupload-angular.js @@ -0,0 +1,437 @@ +/* + * jQuery File Upload AngularJS Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* jshint nomen:false */ +/* global define, angular, require */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define([ + 'jquery', + 'angular', + './jquery.fileupload-image', + './jquery.fileupload-audio', + './jquery.fileupload-video', + './jquery.fileupload-validate' + ], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory( + require('jquery'), + require('angular'), + require('./jquery.fileupload-image'), + require('./jquery.fileupload-audio'), + require('./jquery.fileupload-video'), + require('./jquery.fileupload-validate') + ); + } else { + factory(); + } +}(function () { + 'use strict'; + + angular.module('blueimp.fileupload', []) + + // The fileUpload service provides configuration options + // for the fileUpload directive and default handlers for + // File Upload events: + .provider('fileUpload', function () { + var scopeEvalAsync = function (expression) { + var scope = angular.element(this) + .fileupload('option', 'scope'); + // Schedule a new $digest cycle if not already inside of one + // and evaluate the given expression: + scope.$evalAsync(expression); + }, + addFileMethods = function (scope, data) { + var files = data.files, + file = files[0]; + angular.forEach(files, function (file, index) { + file._index = index; + file.$state = function () { + return data.state(); + }; + file.$processing = function () { + return data.processing(); + }; + file.$progress = function () { + return data.progress(); + }; + file.$response = function () { + return data.response(); + }; + }); + file.$submit = function () { + if (!file.error) { + return data.submit(); + } + }; + file.$cancel = function () { + return data.abort(); + }; + }, + $config; + $config = this.defaults = { + handleResponse: function (e, data) { + var files = data.result && data.result.files; + if (files) { + data.scope.replace(data.files, files); + } else if (data.errorThrown || + data.textStatus === 'error') { + data.files[0].error = data.errorThrown || + data.textStatus; + } + }, + add: function (e, data) { + if (e.isDefaultPrevented()) { + return false; + } + var scope = data.scope, + filesCopy = []; + angular.forEach(data.files, function (file) { + filesCopy.push(file); + }); + scope.$parent.$applyAsync(function () { + addFileMethods(scope, data); + var method = scope.option('prependFiles') ? + 'unshift' : 'push'; + Array.prototype[method].apply(scope.queue, data.files); + }); + data.process(function () { + return scope.process(data); + }).always(function () { + scope.$parent.$applyAsync(function () { + addFileMethods(scope, data); + scope.replace(filesCopy, data.files); + }); + }).then(function () { + if ((scope.option('autoUpload') || + data.autoUpload) && + data.autoUpload !== false) { + data.submit(); + } + }); + }, + done: function (e, data) { + if (e.isDefaultPrevented()) { + return false; + } + var that = this; + data.scope.$apply(function () { + data.handleResponse.call(that, e, data); + }); + }, + fail: function (e, data) { + if (e.isDefaultPrevented()) { + return false; + } + var that = this, + scope = data.scope; + if (data.errorThrown === 'abort') { + scope.clear(data.files); + return; + } + scope.$apply(function () { + data.handleResponse.call(that, e, data); + }); + }, + stop: scopeEvalAsync, + processstart: scopeEvalAsync, + processstop: scopeEvalAsync, + getNumberOfFiles: function () { + var scope = this.scope; + return scope.queue.length - scope.processing(); + }, + dataType: 'json', + autoUpload: false + }; + this.$get = [ + function () { + return { + defaults: $config + }; + } + ]; + }) + + // Format byte numbers to readable presentations: + .provider('formatFileSizeFilter', function () { + var $config = { + // Byte units following the IEC format + // http://en.wikipedia.org/wiki/Kilobyte + units: [ + {size: 1000000000, suffix: ' GB'}, + {size: 1000000, suffix: ' MB'}, + {size: 1000, suffix: ' KB'} + ] + }; + this.defaults = $config; + this.$get = function () { + return function (bytes) { + if (!angular.isNumber(bytes)) { + return ''; + } + var unit = true, + i = 0, + prefix, + suffix; + while (unit) { + unit = $config.units[i]; + prefix = unit.prefix || ''; + suffix = unit.suffix || ''; + if (i === $config.units.length - 1 || bytes >= unit.size) { + return prefix + (bytes / unit.size).toFixed(2) + suffix; + } + i += 1; + } + }; + }; + }) + + // The FileUploadController initializes the fileupload widget and + // provides scope methods to control the File Upload functionality: + .controller('FileUploadController', [ + '$scope', '$element', '$attrs', '$window', 'fileUpload','$q', + function ($scope, $element, $attrs, $window, fileUpload, $q) { + var uploadMethods = { + progress: function () { + return $element.fileupload('progress'); + }, + active: function () { + return $element.fileupload('active'); + }, + option: function (option, data) { + if (arguments.length === 1) { + return $element.fileupload('option', option); + } + $element.fileupload('option', option, data); + }, + add: function (data) { + return $element.fileupload('add', data); + }, + send: function (data) { + return $element.fileupload('send', data); + }, + process: function (data) { + return $element.fileupload('process', data); + }, + processing: function (data) { + return $element.fileupload('processing', data); + } + }; + $scope.disabled = !$window.jQuery.support.fileInput; + $scope.queue = $scope.queue || []; + $scope.clear = function (files) { + var queue = this.queue, + i = queue.length, + file = files, + length = 1; + if (angular.isArray(files)) { + file = files[0]; + length = files.length; + } + while (i) { + i -= 1; + if (queue[i] === file) { + return queue.splice(i, length); + } + } + }; + $scope.replace = function (oldFiles, newFiles) { + var queue = this.queue, + file = oldFiles[0], + i, + j; + for (i = 0; i < queue.length; i += 1) { + if (queue[i] === file) { + for (j = 0; j < newFiles.length; j += 1) { + queue[i + j] = newFiles[j]; + } + return; + } + } + }; + $scope.applyOnQueue = function (method) { + var list = this.queue.slice(0), + i, + file, + promises = []; + for (i = 0; i < list.length; i += 1) { + file = list[i]; + if (file[method]) { + promises.push(file[method]()); + } + } + return $q.all(promises); + }; + $scope.submit = function () { + return this.applyOnQueue('$submit'); + }; + $scope.cancel = function () { + return this.applyOnQueue('$cancel'); + }; + // Add upload methods to the scope: + angular.extend($scope, uploadMethods); + // The fileupload widget will initialize with + // the options provided via "data-"-parameters, + // as well as those given via options object: + $element.fileupload(angular.extend( + {scope: $scope}, + fileUpload.defaults + )).on('fileuploadadd', function (e, data) { + data.scope = $scope; + }).on('fileuploadfail', function (e, data) { + if (data.errorThrown === 'abort') { + return; + } + if (data.dataType && + data.dataType.indexOf('json') === data.dataType.length - 4) { + try { + data.result = angular.fromJson(data.jqXHR.responseText); + } catch (ignore) {} + } + }).on([ + 'fileuploadadd', + 'fileuploadsubmit', + 'fileuploadsend', + 'fileuploaddone', + 'fileuploadfail', + 'fileuploadalways', + 'fileuploadprogress', + 'fileuploadprogressall', + 'fileuploadstart', + 'fileuploadstop', + 'fileuploadchange', + 'fileuploadpaste', + 'fileuploaddrop', + 'fileuploaddragover', + 'fileuploadchunksend', + 'fileuploadchunkdone', + 'fileuploadchunkfail', + 'fileuploadchunkalways', + 'fileuploadprocessstart', + 'fileuploadprocess', + 'fileuploadprocessdone', + 'fileuploadprocessfail', + 'fileuploadprocessalways', + 'fileuploadprocessstop' + ].join(' '), function (e, data) { + $scope.$parent.$applyAsync(function () { + if ($scope.$emit(e.type, data).defaultPrevented) { + e.preventDefault(); + } + }); + }).on('remove', function () { + // Remove upload methods from the scope, + // when the widget is removed: + var method; + for (method in uploadMethods) { + if (uploadMethods.hasOwnProperty(method)) { + delete $scope[method]; + } + } + }); + // Observe option changes: + $scope.$watch( + $attrs.fileUpload, + function (newOptions) { + if (newOptions) { + $element.fileupload('option', newOptions); + } + } + ); + } + ]) + + // Provide File Upload progress feedback: + .controller('FileUploadProgressController', [ + '$scope', '$attrs', '$parse', + function ($scope, $attrs, $parse) { + var fn = $parse($attrs.fileUploadProgress), + update = function () { + var progress = fn($scope); + if (!progress || !progress.total) { + return; + } + $scope.num = Math.floor( + progress.loaded / progress.total * 100 + ); + }; + update(); + $scope.$watch( + $attrs.fileUploadProgress + '.loaded', + function (newValue, oldValue) { + if (newValue !== oldValue) { + update(); + } + } + ); + } + ]) + + // Display File Upload previews: + .controller('FileUploadPreviewController', [ + '$scope', '$element', '$attrs', + function ($scope, $element, $attrs) { + $scope.$watch( + $attrs.fileUploadPreview + '.preview', + function (preview) { + $element.empty(); + if (preview) { + $element.append(preview); + } + } + ); + } + ]) + + .directive('fileUpload', function () { + return { + controller: 'FileUploadController', + scope: true + }; + }) + + .directive('fileUploadProgress', function () { + return { + controller: 'FileUploadProgressController', + scope: true + }; + }) + + .directive('fileUploadPreview', function () { + return { + controller: 'FileUploadPreviewController' + }; + }) + + // Enhance the HTML5 download attribute to + // allow drag&drop of files to the desktop: + .directive('download', function () { + return function (scope, elm) { + elm.on('dragstart', function (e) { + try { + e.originalEvent.dataTransfer.setData( + 'DownloadURL', + [ + 'application/octet-stream', + elm.prop('download'), + elm.prop('href') + ].join(':') + ); + } catch (ignore) {} + }); + }; + }); + +})); diff --git a/node_modules/blueimp-file-upload/js/jquery.fileupload-audio.js b/node_modules/blueimp-file-upload/js/jquery.fileupload-audio.js new file mode 100644 index 000000000..a25377619 --- /dev/null +++ b/node_modules/blueimp-file-upload/js/jquery.fileupload-audio.js @@ -0,0 +1,113 @@ +/* + * jQuery File Upload Audio Preview Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* jshint nomen:false */ +/* global define, require, window, document */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define([ + 'jquery', + 'load-image', + './jquery.fileupload-process' + ], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory( + require('jquery'), + require('blueimp-load-image/js/load-image'), + require('./jquery.fileupload-process') + ); + } else { + // Browser globals: + factory( + window.jQuery, + window.loadImage + ); + } +}(function ($, loadImage) { + 'use strict'; + + // Prepend to the default processQueue: + $.blueimp.fileupload.prototype.options.processQueue.unshift( + { + action: 'loadAudio', + // Use the action as prefix for the "@" options: + prefix: true, + fileTypes: '@', + maxFileSize: '@', + disabled: '@disableAudioPreview' + }, + { + action: 'setAudio', + name: '@audioPreviewName', + disabled: '@disableAudioPreview' + } + ); + + // The File Upload Audio Preview plugin extends the fileupload widget + // with audio preview functionality: + $.widget('blueimp.fileupload', $.blueimp.fileupload, { + + options: { + // The regular expression for the types of audio files to load, + // matched against the file type: + loadAudioFileTypes: /^audio\/.*$/ + }, + + _audioElement: document.createElement('audio'), + + processActions: { + + // Loads the audio file given via data.files and data.index + // as audio element if the browser supports playing it. + // Accepts the options fileTypes (regular expression) + // and maxFileSize (integer) to limit the files to load: + loadAudio: function (data, options) { + if (options.disabled) { + return data; + } + var file = data.files[data.index], + url, + audio; + if (this._audioElement.canPlayType && + this._audioElement.canPlayType(file.type) && + ($.type(options.maxFileSize) !== 'number' || + file.size <= options.maxFileSize) && + (!options.fileTypes || + options.fileTypes.test(file.type))) { + url = loadImage.createObjectURL(file); + if (url) { + audio = this._audioElement.cloneNode(false); + audio.src = url; + audio.controls = true; + data.audio = audio; + return data; + } + } + return data; + }, + + // Sets the audio element as a property of the file object: + setAudio: function (data, options) { + if (data.audio && !options.disabled) { + data.files[data.index][options.name || 'preview'] = data.audio; + } + return data; + } + + } + + }); + +})); diff --git a/node_modules/blueimp-file-upload/js/jquery.fileupload-image.js b/node_modules/blueimp-file-upload/js/jquery.fileupload-image.js new file mode 100644 index 000000000..65fc6d7b8 --- /dev/null +++ b/node_modules/blueimp-file-upload/js/jquery.fileupload-image.js @@ -0,0 +1,326 @@ +/* + * jQuery File Upload Image Preview & Resize Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* jshint nomen:false */ +/* global define, require, window, Blob */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define([ + 'jquery', + 'load-image', + 'load-image-meta', + 'load-image-scale', + 'load-image-exif', + 'canvas-to-blob', + './jquery.fileupload-process' + ], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory( + require('jquery'), + require('blueimp-load-image/js/load-image'), + require('blueimp-load-image/js/load-image-meta'), + require('blueimp-load-image/js/load-image-scale'), + require('blueimp-load-image/js/load-image-exif'), + require('blueimp-canvas-to-blob'), + require('./jquery.fileupload-process') + ); + } else { + // Browser globals: + factory( + window.jQuery, + window.loadImage + ); + } +}(function ($, loadImage) { + 'use strict'; + + // Prepend to the default processQueue: + $.blueimp.fileupload.prototype.options.processQueue.unshift( + { + action: 'loadImageMetaData', + disableImageHead: '@', + disableExif: '@', + disableExifThumbnail: '@', + disableExifSub: '@', + disableExifGps: '@', + disabled: '@disableImageMetaDataLoad' + }, + { + action: 'loadImage', + // Use the action as prefix for the "@" options: + prefix: true, + fileTypes: '@', + maxFileSize: '@', + noRevoke: '@', + disabled: '@disableImageLoad' + }, + { + action: 'resizeImage', + // Use "image" as prefix for the "@" options: + prefix: 'image', + maxWidth: '@', + maxHeight: '@', + minWidth: '@', + minHeight: '@', + crop: '@', + orientation: '@', + forceResize: '@', + disabled: '@disableImageResize' + }, + { + action: 'saveImage', + quality: '@imageQuality', + type: '@imageType', + disabled: '@disableImageResize' + }, + { + action: 'saveImageMetaData', + disabled: '@disableImageMetaDataSave' + }, + { + action: 'resizeImage', + // Use "preview" as prefix for the "@" options: + prefix: 'preview', + maxWidth: '@', + maxHeight: '@', + minWidth: '@', + minHeight: '@', + crop: '@', + orientation: '@', + thumbnail: '@', + canvas: '@', + disabled: '@disableImagePreview' + }, + { + action: 'setImage', + name: '@imagePreviewName', + disabled: '@disableImagePreview' + }, + { + action: 'deleteImageReferences', + disabled: '@disableImageReferencesDeletion' + } + ); + + // The File Upload Resize plugin extends the fileupload widget + // with image resize functionality: + $.widget('blueimp.fileupload', $.blueimp.fileupload, { + + options: { + // The regular expression for the types of images to load: + // matched against the file type: + loadImageFileTypes: /^image\/(gif|jpeg|png|svg\+xml)$/, + // The maximum file size of images to load: + loadImageMaxFileSize: 10000000, // 10MB + // The maximum width of resized images: + imageMaxWidth: 1920, + // The maximum height of resized images: + imageMaxHeight: 1080, + // Defines the image orientation (1-8) or takes the orientation + // value from Exif data if set to true: + imageOrientation: false, + // Define if resized images should be cropped or only scaled: + imageCrop: false, + // Disable the resize image functionality by default: + disableImageResize: true, + // The maximum width of the preview images: + previewMaxWidth: 80, + // The maximum height of the preview images: + previewMaxHeight: 80, + // Defines the preview orientation (1-8) or takes the orientation + // value from Exif data if set to true: + previewOrientation: true, + // Create the preview using the Exif data thumbnail: + previewThumbnail: true, + // Define if preview images should be cropped or only scaled: + previewCrop: false, + // Define if preview images should be resized as canvas elements: + previewCanvas: true + }, + + processActions: { + + // Loads the image given via data.files and data.index + // as img element, if the browser supports the File API. + // Accepts the options fileTypes (regular expression) + // and maxFileSize (integer) to limit the files to load: + loadImage: function (data, options) { + if (options.disabled) { + return data; + } + var that = this, + file = data.files[data.index], + dfd = $.Deferred(); + if (($.type(options.maxFileSize) === 'number' && + file.size > options.maxFileSize) || + (options.fileTypes && + !options.fileTypes.test(file.type)) || + !loadImage( + file, + function (img) { + if (img.src) { + data.img = img; + } + dfd.resolveWith(that, [data]); + }, + options + )) { + return data; + } + return dfd.promise(); + }, + + // Resizes the image given as data.canvas or data.img + // and updates data.canvas or data.img with the resized image. + // Also stores the resized image as preview property. + // Accepts the options maxWidth, maxHeight, minWidth, + // minHeight, canvas and crop: + resizeImage: function (data, options) { + if (options.disabled || !(data.canvas || data.img)) { + return data; + } + options = $.extend({canvas: true}, options); + var that = this, + dfd = $.Deferred(), + img = (options.canvas && data.canvas) || data.img, + resolve = function (newImg) { + if (newImg && (newImg.width !== img.width || + newImg.height !== img.height || + options.forceResize)) { + data[newImg.getContext ? 'canvas' : 'img'] = newImg; + } + data.preview = newImg; + dfd.resolveWith(that, [data]); + }, + thumbnail; + if (data.exif) { + if (options.orientation === true) { + options.orientation = data.exif.get('Orientation'); + } + if (options.thumbnail) { + thumbnail = data.exif.get('Thumbnail'); + if (thumbnail) { + loadImage(thumbnail, resolve, options); + return dfd.promise(); + } + } + // Prevent orienting the same image twice: + if (data.orientation) { + delete options.orientation; + } else { + data.orientation = options.orientation; + } + } + if (img) { + resolve(loadImage.scale(img, options)); + return dfd.promise(); + } + return data; + }, + + // Saves the processed image given as data.canvas + // inplace at data.index of data.files: + saveImage: function (data, options) { + if (!data.canvas || options.disabled) { + return data; + } + var that = this, + file = data.files[data.index], + dfd = $.Deferred(); + if (data.canvas.toBlob) { + data.canvas.toBlob( + function (blob) { + if (!blob.name) { + if (file.type === blob.type) { + blob.name = file.name; + } else if (file.name) { + blob.name = file.name.replace( + /\.\w+$/, + '.' + blob.type.substr(6) + ); + } + } + // Don't restore invalid meta data: + if (file.type !== blob.type) { + delete data.imageHead; + } + // Store the created blob at the position + // of the original file in the files list: + data.files[data.index] = blob; + dfd.resolveWith(that, [data]); + }, + options.type || file.type, + options.quality + ); + } else { + return data; + } + return dfd.promise(); + }, + + loadImageMetaData: function (data, options) { + if (options.disabled) { + return data; + } + var that = this, + dfd = $.Deferred(); + loadImage.parseMetaData(data.files[data.index], function (result) { + $.extend(data, result); + dfd.resolveWith(that, [data]); + }, options); + return dfd.promise(); + }, + + saveImageMetaData: function (data, options) { + if (!(data.imageHead && data.canvas && + data.canvas.toBlob && !options.disabled)) { + return data; + } + var file = data.files[data.index], + blob = new Blob([ + data.imageHead, + // Resized images always have a head size of 20 bytes, + // including the JPEG marker and a minimal JFIF header: + this._blobSlice.call(file, 20) + ], {type: file.type}); + blob.name = file.name; + data.files[data.index] = blob; + return data; + }, + + // Sets the resized version of the image as a property of the + // file object, must be called after "saveImage": + setImage: function (data, options) { + if (data.preview && !options.disabled) { + data.files[data.index][options.name || 'preview'] = data.preview; + } + return data; + }, + + deleteImageReferences: function (data, options) { + if (!options.disabled) { + delete data.img; + delete data.canvas; + delete data.preview; + delete data.imageHead; + } + return data; + } + + } + + }); + +})); diff --git a/node_modules/blueimp-file-upload/js/jquery.fileupload-jquery-ui.js b/node_modules/blueimp-file-upload/js/jquery.fileupload-jquery-ui.js new file mode 100644 index 000000000..7b136b379 --- /dev/null +++ b/node_modules/blueimp-file-upload/js/jquery.fileupload-jquery-ui.js @@ -0,0 +1,161 @@ +/* + * jQuery File Upload jQuery UI Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* jshint nomen:false */ +/* global define, require, window */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define([ + 'jquery', + './jquery.fileupload-ui' + ], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory( + require('jquery'), + require('./jquery.fileupload-ui') + ); + } else { + // Browser globals: + factory(window.jQuery); + } +}(function ($) { + 'use strict'; + + $.widget('blueimp.fileupload', $.blueimp.fileupload, { + + options: { + processdone: function (e, data) { + data.context.find('.start').button('enable'); + }, + progress: function (e, data) { + if (data.context) { + data.context.find('.progress').progressbar( + 'option', + 'value', + parseInt(data.loaded / data.total * 100, 10) + ); + } + }, + progressall: function (e, data) { + var $this = $(this); + $this.find('.fileupload-progress') + .find('.progress').progressbar( + 'option', + 'value', + parseInt(data.loaded / data.total * 100, 10) + ).end() + .find('.progress-extended').each(function () { + $(this).html( + ($this.data('blueimp-fileupload') || + $this.data('fileupload')) + ._renderExtendedProgress(data) + ); + }); + } + }, + + _renderUpload: function (func, files) { + var node = this._super(func, files), + showIconText = $(window).width() > 480; + node.find('.progress').empty().progressbar(); + node.find('.start').button({ + icons: {primary: 'ui-icon-circle-arrow-e'}, + text: showIconText + }); + node.find('.cancel').button({ + icons: {primary: 'ui-icon-cancel'}, + text: showIconText + }); + if (node.hasClass('fade')) { + node.hide(); + } + return node; + }, + + _renderDownload: function (func, files) { + var node = this._super(func, files), + showIconText = $(window).width() > 480; + node.find('.delete').button({ + icons: {primary: 'ui-icon-trash'}, + text: showIconText + }); + if (node.hasClass('fade')) { + node.hide(); + } + return node; + }, + + _startHandler: function (e) { + $(e.currentTarget).button('disable'); + this._super(e); + }, + + _transition: function (node) { + var deferred = $.Deferred(); + if (node.hasClass('fade')) { + node.fadeToggle( + this.options.transitionDuration, + this.options.transitionEasing, + function () { + deferred.resolveWith(node); + } + ); + } else { + deferred.resolveWith(node); + } + return deferred; + }, + + _create: function () { + this._super(); + this.element + .find('.fileupload-buttonbar') + .find('.fileinput-button').each(function () { + var input = $(this).find('input:file').detach(); + $(this) + .button({icons: {primary: 'ui-icon-plusthick'}}) + .append(input); + }) + .end().find('.start') + .button({icons: {primary: 'ui-icon-circle-arrow-e'}}) + .end().find('.cancel') + .button({icons: {primary: 'ui-icon-cancel'}}) + .end().find('.delete') + .button({icons: {primary: 'ui-icon-trash'}}) + .end().find('.progress').progressbar(); + }, + + _destroy: function () { + this.element + .find('.fileupload-buttonbar') + .find('.fileinput-button').each(function () { + var input = $(this).find('input:file').detach(); + $(this) + .button('destroy') + .append(input); + }) + .end().find('.start') + .button('destroy') + .end().find('.cancel') + .button('destroy') + .end().find('.delete') + .button('destroy') + .end().find('.progress').progressbar('destroy'); + this._super(); + } + + }); + +})); diff --git a/node_modules/blueimp-file-upload/js/jquery.fileupload-process.js b/node_modules/blueimp-file-upload/js/jquery.fileupload-process.js new file mode 100644 index 000000000..638f0d26b --- /dev/null +++ b/node_modules/blueimp-file-upload/js/jquery.fileupload-process.js @@ -0,0 +1,178 @@ +/* + * jQuery File Upload Processing Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2012, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* jshint nomen:false */ +/* global define, require, window */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define([ + 'jquery', + './jquery.fileupload' + ], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory( + require('jquery'), + require('./jquery.fileupload') + ); + } else { + // Browser globals: + factory( + window.jQuery + ); + } +}(function ($) { + 'use strict'; + + var originalAdd = $.blueimp.fileupload.prototype.options.add; + + // The File Upload Processing plugin extends the fileupload widget + // with file processing functionality: + $.widget('blueimp.fileupload', $.blueimp.fileupload, { + + options: { + // The list of processing actions: + processQueue: [ + /* + { + action: 'log', + type: 'debug' + } + */ + ], + add: function (e, data) { + var $this = $(this); + data.process(function () { + return $this.fileupload('process', data); + }); + originalAdd.call(this, e, data); + } + }, + + processActions: { + /* + log: function (data, options) { + console[options.type]( + 'Processing "' + data.files[data.index].name + '"' + ); + } + */ + }, + + _processFile: function (data, originalData) { + var that = this, + dfd = $.Deferred().resolveWith(that, [data]), + chain = dfd.promise(); + this._trigger('process', null, data); + $.each(data.processQueue, function (i, settings) { + var func = function (data) { + if (originalData.errorThrown) { + return $.Deferred() + .rejectWith(that, [originalData]).promise(); + } + return that.processActions[settings.action].call( + that, + data, + settings + ); + }; + chain = chain.then(func, settings.always && func); + }); + chain + .done(function () { + that._trigger('processdone', null, data); + that._trigger('processalways', null, data); + }) + .fail(function () { + that._trigger('processfail', null, data); + that._trigger('processalways', null, data); + }); + return chain; + }, + + // Replaces the settings of each processQueue item that + // are strings starting with an "@", using the remaining + // substring as key for the option map, + // e.g. "@autoUpload" is replaced with options.autoUpload: + _transformProcessQueue: function (options) { + var processQueue = []; + $.each(options.processQueue, function () { + var settings = {}, + action = this.action, + prefix = this.prefix === true ? action : this.prefix; + $.each(this, function (key, value) { + if ($.type(value) === 'string' && + value.charAt(0) === '@') { + settings[key] = options[ + value.slice(1) || (prefix ? prefix + + key.charAt(0).toUpperCase() + key.slice(1) : key) + ]; + } else { + settings[key] = value; + } + + }); + processQueue.push(settings); + }); + options.processQueue = processQueue; + }, + + // Returns the number of files currently in the processsing queue: + processing: function () { + return this._processing; + }, + + // Processes the files given as files property of the data parameter, + // returns a Promise object that allows to bind callbacks: + process: function (data) { + var that = this, + options = $.extend({}, this.options, data); + if (options.processQueue && options.processQueue.length) { + this._transformProcessQueue(options); + if (this._processing === 0) { + this._trigger('processstart'); + } + $.each(data.files, function (index) { + var opts = index ? $.extend({}, options) : options, + func = function () { + if (data.errorThrown) { + return $.Deferred() + .rejectWith(that, [data]).promise(); + } + return that._processFile(opts, data); + }; + opts.index = index; + that._processing += 1; + that._processingQueue = that._processingQueue.then(func, func) + .always(function () { + that._processing -= 1; + if (that._processing === 0) { + that._trigger('processstop'); + } + }); + }); + } + return this._processingQueue; + }, + + _create: function () { + this._super(); + this._processing = 0; + this._processingQueue = $.Deferred().resolveWith(this) + .promise(); + } + + }); + +})); diff --git a/node_modules/blueimp-file-upload/js/jquery.fileupload-ui.js b/node_modules/blueimp-file-upload/js/jquery.fileupload-ui.js new file mode 100644 index 000000000..5058084b4 --- /dev/null +++ b/node_modules/blueimp-file-upload/js/jquery.fileupload-ui.js @@ -0,0 +1,714 @@ +/* + * jQuery File Upload User Interface Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2010, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* jshint nomen:false */ +/* global define, require, window */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define([ + 'jquery', + 'blueimp-tmpl', + './jquery.fileupload-image', + './jquery.fileupload-audio', + './jquery.fileupload-video', + './jquery.fileupload-validate' + ], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory( + require('jquery'), + require('blueimp-tmpl'), + require('./jquery.fileupload-image'), + require('./jquery.fileupload-audio'), + require('./jquery.fileupload-video'), + require('./jquery.fileupload-validate') + ); + } else { + // Browser globals: + factory( + window.jQuery, + window.tmpl + ); + } +}(function ($, tmpl) { + 'use strict'; + + $.blueimp.fileupload.prototype._specialOptions.push( + 'filesContainer', + 'uploadTemplateId', + 'downloadTemplateId' + ); + + // The UI version extends the file upload widget + // and adds complete user interface interaction: + $.widget('blueimp.fileupload', $.blueimp.fileupload, { + + options: { + // By default, files added to the widget are uploaded as soon + // as the user clicks on the start buttons. To enable automatic + // uploads, set the following option to true: + autoUpload: false, + // The ID of the upload template: + uploadTemplateId: 'template-upload', + // The ID of the download template: + downloadTemplateId: 'template-download', + // The container for the list of files. If undefined, it is set to + // an element with class "files" inside of the widget element: + filesContainer: undefined, + // By default, files are appended to the files container. + // Set the following option to true, to prepend files instead: + prependFiles: false, + // The expected data type of the upload response, sets the dataType + // option of the $.ajax upload requests: + dataType: 'json', + + // Error and info messages: + messages: { + unknownError: 'Unknown error' + }, + + // Function returning the current number of files, + // used by the maxNumberOfFiles validation: + getNumberOfFiles: function () { + return this.filesContainer.children() + .not('.processing').length; + }, + + // Callback to retrieve the list of files from the server response: + getFilesFromResponse: function (data) { + if (data.result && $.isArray(data.result.files)) { + return data.result.files; + } + return []; + }, + + // The add callback is invoked as soon as files are added to the fileupload + // widget (via file input selection, drag & drop or add API call). + // See the basic file upload widget for more information: + add: function (e, data) { + if (e.isDefaultPrevented()) { + return false; + } + var $this = $(this), + that = $this.data('blueimp-fileupload') || + $this.data('fileupload'), + options = that.options; + data.context = that._renderUpload(data.files) + .data('data', data) + .addClass('processing'); + options.filesContainer[ + options.prependFiles ? 'prepend' : 'append' + ](data.context); + that._forceReflow(data.context); + that._transition(data.context); + data.process(function () { + return $this.fileupload('process', data); + }).always(function () { + data.context.each(function (index) { + $(this).find('.size').text( + that._formatFileSize(data.files[index].size) + ); + }).removeClass('processing'); + that._renderPreviews(data); + }).done(function () { + data.context.find('.start').prop('disabled', false); + if ((that._trigger('added', e, data) !== false) && + (options.autoUpload || data.autoUpload) && + data.autoUpload !== false) { + data.submit(); + } + }).fail(function () { + if (data.files.error) { + data.context.each(function (index) { + var error = data.files[index].error; + if (error) { + $(this).find('.error').text(error); + } + }); + } + }); + }, + // Callback for the start of each file upload request: + send: function (e, data) { + if (e.isDefaultPrevented()) { + return false; + } + var that = $(this).data('blueimp-fileupload') || + $(this).data('fileupload'); + if (data.context && data.dataType && + data.dataType.substr(0, 6) === 'iframe') { + // Iframe Transport does not support progress events. + // In lack of an indeterminate progress bar, we set + // the progress to 100%, showing the full animated bar: + data.context + .find('.progress').addClass( + !$.support.transition && 'progress-animated' + ) + .attr('aria-valuenow', 100) + .children().first().css( + 'width', + '100%' + ); + } + return that._trigger('sent', e, data); + }, + // Callback for successful uploads: + done: function (e, data) { + if (e.isDefaultPrevented()) { + return false; + } + var that = $(this).data('blueimp-fileupload') || + $(this).data('fileupload'), + getFilesFromResponse = data.getFilesFromResponse || + that.options.getFilesFromResponse, + files = getFilesFromResponse(data), + template, + deferred; + if (data.context) { + data.context.each(function (index) { + var file = files[index] || + {error: 'Empty file upload result'}; + deferred = that._addFinishedDeferreds(); + that._transition($(this)).done( + function () { + var node = $(this); + template = that._renderDownload([file]) + .replaceAll(node); + that._forceReflow(template); + that._transition(template).done( + function () { + data.context = $(this); + that._trigger('completed', e, data); + that._trigger('finished', e, data); + deferred.resolve(); + } + ); + } + ); + }); + } else { + template = that._renderDownload(files)[ + that.options.prependFiles ? 'prependTo' : 'appendTo' + ](that.options.filesContainer); + that._forceReflow(template); + deferred = that._addFinishedDeferreds(); + that._transition(template).done( + function () { + data.context = $(this); + that._trigger('completed', e, data); + that._trigger('finished', e, data); + deferred.resolve(); + } + ); + } + }, + // Callback for failed (abort or error) uploads: + fail: function (e, data) { + if (e.isDefaultPrevented()) { + return false; + } + var that = $(this).data('blueimp-fileupload') || + $(this).data('fileupload'), + template, + deferred; + if (data.context) { + data.context.each(function (index) { + if (data.errorThrown !== 'abort') { + var file = data.files[index]; + file.error = file.error || data.errorThrown || + data.i18n('unknownError'); + deferred = that._addFinishedDeferreds(); + that._transition($(this)).done( + function () { + var node = $(this); + template = that._renderDownload([file]) + .replaceAll(node); + that._forceReflow(template); + that._transition(template).done( + function () { + data.context = $(this); + that._trigger('failed', e, data); + that._trigger('finished', e, data); + deferred.resolve(); + } + ); + } + ); + } else { + deferred = that._addFinishedDeferreds(); + that._transition($(this)).done( + function () { + $(this).remove(); + that._trigger('failed', e, data); + that._trigger('finished', e, data); + deferred.resolve(); + } + ); + } + }); + } else if (data.errorThrown !== 'abort') { + data.context = that._renderUpload(data.files)[ + that.options.prependFiles ? 'prependTo' : 'appendTo' + ](that.options.filesContainer) + .data('data', data); + that._forceReflow(data.context); + deferred = that._addFinishedDeferreds(); + that._transition(data.context).done( + function () { + data.context = $(this); + that._trigger('failed', e, data); + that._trigger('finished', e, data); + deferred.resolve(); + } + ); + } else { + that._trigger('failed', e, data); + that._trigger('finished', e, data); + that._addFinishedDeferreds().resolve(); + } + }, + // Callback for upload progress events: + progress: function (e, data) { + if (e.isDefaultPrevented()) { + return false; + } + var progress = Math.floor(data.loaded / data.total * 100); + if (data.context) { + data.context.each(function () { + $(this).find('.progress') + .attr('aria-valuenow', progress) + .children().first().css( + 'width', + progress + '%' + ); + }); + } + }, + // Callback for global upload progress events: + progressall: function (e, data) { + if (e.isDefaultPrevented()) { + return false; + } + var $this = $(this), + progress = Math.floor(data.loaded / data.total * 100), + globalProgressNode = $this.find('.fileupload-progress'), + extendedProgressNode = globalProgressNode + .find('.progress-extended'); + if (extendedProgressNode.length) { + extendedProgressNode.html( + ($this.data('blueimp-fileupload') || $this.data('fileupload')) + ._renderExtendedProgress(data) + ); + } + globalProgressNode + .find('.progress') + .attr('aria-valuenow', progress) + .children().first().css( + 'width', + progress + '%' + ); + }, + // Callback for uploads start, equivalent to the global ajaxStart event: + start: function (e) { + if (e.isDefaultPrevented()) { + return false; + } + var that = $(this).data('blueimp-fileupload') || + $(this).data('fileupload'); + that._resetFinishedDeferreds(); + that._transition($(this).find('.fileupload-progress')).done( + function () { + that._trigger('started', e); + } + ); + }, + // Callback for uploads stop, equivalent to the global ajaxStop event: + stop: function (e) { + if (e.isDefaultPrevented()) { + return false; + } + var that = $(this).data('blueimp-fileupload') || + $(this).data('fileupload'), + deferred = that._addFinishedDeferreds(); + $.when.apply($, that._getFinishedDeferreds()) + .done(function () { + that._trigger('stopped', e); + }); + that._transition($(this).find('.fileupload-progress')).done( + function () { + $(this).find('.progress') + .attr('aria-valuenow', '0') + .children().first().css('width', '0%'); + $(this).find('.progress-extended').html(' '); + deferred.resolve(); + } + ); + }, + processstart: function (e) { + if (e.isDefaultPrevented()) { + return false; + } + $(this).addClass('fileupload-processing'); + }, + processstop: function (e) { + if (e.isDefaultPrevented()) { + return false; + } + $(this).removeClass('fileupload-processing'); + }, + // Callback for file deletion: + destroy: function (e, data) { + if (e.isDefaultPrevented()) { + return false; + } + var that = $(this).data('blueimp-fileupload') || + $(this).data('fileupload'), + removeNode = function () { + that._transition(data.context).done( + function () { + $(this).remove(); + that._trigger('destroyed', e, data); + } + ); + }; + if (data.url) { + data.dataType = data.dataType || that.options.dataType; + $.ajax(data).done(removeNode).fail(function () { + that._trigger('destroyfailed', e, data); + }); + } else { + removeNode(); + } + } + }, + + _resetFinishedDeferreds: function () { + this._finishedUploads = []; + }, + + _addFinishedDeferreds: function (deferred) { + if (!deferred) { + deferred = $.Deferred(); + } + this._finishedUploads.push(deferred); + return deferred; + }, + + _getFinishedDeferreds: function () { + return this._finishedUploads; + }, + + // Link handler, that allows to download files + // by drag & drop of the links to the desktop: + _enableDragToDesktop: function () { + var link = $(this), + url = link.prop('href'), + name = link.prop('download'), + type = 'application/octet-stream'; + link.bind('dragstart', function (e) { + try { + e.originalEvent.dataTransfer.setData( + 'DownloadURL', + [type, name, url].join(':') + ); + } catch (ignore) {} + }); + }, + + _formatFileSize: function (bytes) { + if (typeof bytes !== 'number') { + return ''; + } + if (bytes >= 1000000000) { + return (bytes / 1000000000).toFixed(2) + ' GB'; + } + if (bytes >= 1000000) { + return (bytes / 1000000).toFixed(2) + ' MB'; + } + return (bytes / 1000).toFixed(2) + ' KB'; + }, + + _formatBitrate: function (bits) { + if (typeof bits !== 'number') { + return ''; + } + if (bits >= 1000000000) { + return (bits / 1000000000).toFixed(2) + ' Gbit/s'; + } + if (bits >= 1000000) { + return (bits / 1000000).toFixed(2) + ' Mbit/s'; + } + if (bits >= 1000) { + return (bits / 1000).toFixed(2) + ' kbit/s'; + } + return bits.toFixed(2) + ' bit/s'; + }, + + _formatTime: function (seconds) { + var date = new Date(seconds * 1000), + days = Math.floor(seconds / 86400); + days = days ? days + 'd ' : ''; + return days + + ('0' + date.getUTCHours()).slice(-2) + ':' + + ('0' + date.getUTCMinutes()).slice(-2) + ':' + + ('0' + date.getUTCSeconds()).slice(-2); + }, + + _formatPercentage: function (floatValue) { + return (floatValue * 100).toFixed(2) + ' %'; + }, + + _renderExtendedProgress: function (data) { + return this._formatBitrate(data.bitrate) + ' | ' + + this._formatTime( + (data.total - data.loaded) * 8 / data.bitrate + ) + ' | ' + + this._formatPercentage( + data.loaded / data.total + ) + ' | ' + + this._formatFileSize(data.loaded) + ' / ' + + this._formatFileSize(data.total); + }, + + _renderTemplate: function (func, files) { + if (!func) { + return $(); + } + var result = func({ + files: files, + formatFileSize: this._formatFileSize, + options: this.options + }); + if (result instanceof $) { + return result; + } + return $(this.options.templatesContainer).html(result).children(); + }, + + _renderPreviews: function (data) { + data.context.find('.preview').each(function (index, elm) { + $(elm).append(data.files[index].preview); + }); + }, + + _renderUpload: function (files) { + return this._renderTemplate( + this.options.uploadTemplate, + files + ); + }, + + _renderDownload: function (files) { + return this._renderTemplate( + this.options.downloadTemplate, + files + ).find('a[download]').each(this._enableDragToDesktop).end(); + }, + + _startHandler: function (e) { + e.preventDefault(); + var button = $(e.currentTarget), + template = button.closest('.template-upload'), + data = template.data('data'); + button.prop('disabled', true); + if (data && data.submit) { + data.submit(); + } + }, + + _cancelHandler: function (e) { + e.preventDefault(); + var template = $(e.currentTarget) + .closest('.template-upload,.template-download'), + data = template.data('data') || {}; + data.context = data.context || template; + if (data.abort) { + data.abort(); + } else { + data.errorThrown = 'abort'; + this._trigger('fail', e, data); + } + }, + + _deleteHandler: function (e) { + e.preventDefault(); + var button = $(e.currentTarget); + this._trigger('destroy', e, $.extend({ + context: button.closest('.template-download'), + type: 'DELETE' + }, button.data())); + }, + + _forceReflow: function (node) { + return $.support.transition && node.length && + node[0].offsetWidth; + }, + + _transition: function (node) { + var dfd = $.Deferred(); + if ($.support.transition && node.hasClass('fade') && node.is(':visible')) { + node.bind( + $.support.transition.end, + function (e) { + // Make sure we don't respond to other transitions events + // in the container element, e.g. from button elements: + if (e.target === node[0]) { + node.unbind($.support.transition.end); + dfd.resolveWith(node); + } + } + ).toggleClass('in'); + } else { + node.toggleClass('in'); + dfd.resolveWith(node); + } + return dfd; + }, + + _initButtonBarEventHandlers: function () { + var fileUploadButtonBar = this.element.find('.fileupload-buttonbar'), + filesList = this.options.filesContainer; + this._on(fileUploadButtonBar.find('.start'), { + click: function (e) { + e.preventDefault(); + filesList.find('.start').click(); + } + }); + this._on(fileUploadButtonBar.find('.cancel'), { + click: function (e) { + e.preventDefault(); + filesList.find('.cancel').click(); + } + }); + this._on(fileUploadButtonBar.find('.delete'), { + click: function (e) { + e.preventDefault(); + filesList.find('.toggle:checked') + .closest('.template-download') + .find('.delete').click(); + fileUploadButtonBar.find('.toggle') + .prop('checked', false); + } + }); + this._on(fileUploadButtonBar.find('.toggle'), { + change: function (e) { + filesList.find('.toggle').prop( + 'checked', + $(e.currentTarget).is(':checked') + ); + } + }); + }, + + _destroyButtonBarEventHandlers: function () { + this._off( + this.element.find('.fileupload-buttonbar') + .find('.start, .cancel, .delete'), + 'click' + ); + this._off( + this.element.find('.fileupload-buttonbar .toggle'), + 'change.' + ); + }, + + _initEventHandlers: function () { + this._super(); + this._on(this.options.filesContainer, { + 'click .start': this._startHandler, + 'click .cancel': this._cancelHandler, + 'click .delete': this._deleteHandler + }); + this._initButtonBarEventHandlers(); + }, + + _destroyEventHandlers: function () { + this._destroyButtonBarEventHandlers(); + this._off(this.options.filesContainer, 'click'); + this._super(); + }, + + _enableFileInputButton: function () { + this.element.find('.fileinput-button input') + .prop('disabled', false) + .parent().removeClass('disabled'); + }, + + _disableFileInputButton: function () { + this.element.find('.fileinput-button input') + .prop('disabled', true) + .parent().addClass('disabled'); + }, + + _initTemplates: function () { + var options = this.options; + options.templatesContainer = this.document[0].createElement( + options.filesContainer.prop('nodeName') + ); + if (tmpl) { + if (options.uploadTemplateId) { + options.uploadTemplate = tmpl(options.uploadTemplateId); + } + if (options.downloadTemplateId) { + options.downloadTemplate = tmpl(options.downloadTemplateId); + } + } + }, + + _initFilesContainer: function () { + var options = this.options; + if (options.filesContainer === undefined) { + options.filesContainer = this.element.find('.files'); + } else if (!(options.filesContainer instanceof $)) { + options.filesContainer = $(options.filesContainer); + } + }, + + _initSpecialOptions: function () { + this._super(); + this._initFilesContainer(); + this._initTemplates(); + }, + + _create: function () { + this._super(); + this._resetFinishedDeferreds(); + if (!$.support.fileInput) { + this._disableFileInputButton(); + } + }, + + enable: function () { + var wasDisabled = false; + if (this.options.disabled) { + wasDisabled = true; + } + this._super(); + if (wasDisabled) { + this.element.find('input, button').prop('disabled', false); + this._enableFileInputButton(); + } + }, + + disable: function () { + if (!this.options.disabled) { + this.element.find('input, button').prop('disabled', true); + this._disableFileInputButton(); + } + this._super(); + } + + }); + +})); diff --git a/node_modules/blueimp-file-upload/js/jquery.fileupload-validate.js b/node_modules/blueimp-file-upload/js/jquery.fileupload-validate.js new file mode 100644 index 000000000..eebeb3733 --- /dev/null +++ b/node_modules/blueimp-file-upload/js/jquery.fileupload-validate.js @@ -0,0 +1,125 @@ +/* + * jQuery File Upload Validation Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* global define, require, window */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define([ + 'jquery', + './jquery.fileupload-process' + ], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory( + require('jquery'), + require('./jquery.fileupload-process') + ); + } else { + // Browser globals: + factory( + window.jQuery + ); + } +}(function ($) { + 'use strict'; + + // Append to the default processQueue: + $.blueimp.fileupload.prototype.options.processQueue.push( + { + action: 'validate', + // Always trigger this action, + // even if the previous action was rejected: + always: true, + // Options taken from the global options map: + acceptFileTypes: '@', + maxFileSize: '@', + minFileSize: '@', + maxNumberOfFiles: '@', + disabled: '@disableValidation' + } + ); + + // The File Upload Validation plugin extends the fileupload widget + // with file validation functionality: + $.widget('blueimp.fileupload', $.blueimp.fileupload, { + + options: { + /* + // The regular expression for allowed file types, matches + // against either file type or file name: + acceptFileTypes: /(\.|\/)(gif|jpe?g|png)$/i, + // The maximum allowed file size in bytes: + maxFileSize: 10000000, // 10 MB + // The minimum allowed file size in bytes: + minFileSize: undefined, // No minimal file size + // The limit of files to be uploaded: + maxNumberOfFiles: 10, + */ + + // Function returning the current number of files, + // has to be overriden for maxNumberOfFiles validation: + getNumberOfFiles: $.noop, + + // Error and info messages: + messages: { + maxNumberOfFiles: 'Maximum number of files exceeded', + acceptFileTypes: 'File type not allowed', + maxFileSize: 'File is too large', + minFileSize: 'File is too small' + } + }, + + processActions: { + + validate: function (data, options) { + if (options.disabled) { + return data; + } + var dfd = $.Deferred(), + settings = this.options, + file = data.files[data.index], + fileSize; + if (options.minFileSize || options.maxFileSize) { + fileSize = file.size; + } + if ($.type(options.maxNumberOfFiles) === 'number' && + (settings.getNumberOfFiles() || 0) + data.files.length > + options.maxNumberOfFiles) { + file.error = settings.i18n('maxNumberOfFiles'); + } else if (options.acceptFileTypes && + !(options.acceptFileTypes.test(file.type) || + options.acceptFileTypes.test(file.name))) { + file.error = settings.i18n('acceptFileTypes'); + } else if (fileSize > options.maxFileSize) { + file.error = settings.i18n('maxFileSize'); + } else if ($.type(fileSize) === 'number' && + fileSize < options.minFileSize) { + file.error = settings.i18n('minFileSize'); + } else { + delete file.error; + } + if (file.error || data.files.error) { + data.files.error = true; + dfd.rejectWith(this, [data]); + } else { + dfd.resolveWith(this, [data]); + } + return dfd.promise(); + } + + } + + }); + +})); diff --git a/node_modules/blueimp-file-upload/js/jquery.fileupload-video.js b/node_modules/blueimp-file-upload/js/jquery.fileupload-video.js new file mode 100644 index 000000000..aedcec2ba --- /dev/null +++ b/node_modules/blueimp-file-upload/js/jquery.fileupload-video.js @@ -0,0 +1,113 @@ +/* + * jQuery File Upload Video Preview Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* jshint nomen:false */ +/* global define, require, window, document */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define([ + 'jquery', + 'load-image', + './jquery.fileupload-process' + ], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory( + require('jquery'), + require('blueimp-load-image/js/load-image'), + require('./jquery.fileupload-process') + ); + } else { + // Browser globals: + factory( + window.jQuery, + window.loadImage + ); + } +}(function ($, loadImage) { + 'use strict'; + + // Prepend to the default processQueue: + $.blueimp.fileupload.prototype.options.processQueue.unshift( + { + action: 'loadVideo', + // Use the action as prefix for the "@" options: + prefix: true, + fileTypes: '@', + maxFileSize: '@', + disabled: '@disableVideoPreview' + }, + { + action: 'setVideo', + name: '@videoPreviewName', + disabled: '@disableVideoPreview' + } + ); + + // The File Upload Video Preview plugin extends the fileupload widget + // with video preview functionality: + $.widget('blueimp.fileupload', $.blueimp.fileupload, { + + options: { + // The regular expression for the types of video files to load, + // matched against the file type: + loadVideoFileTypes: /^video\/.*$/ + }, + + _videoElement: document.createElement('video'), + + processActions: { + + // Loads the video file given via data.files and data.index + // as video element if the browser supports playing it. + // Accepts the options fileTypes (regular expression) + // and maxFileSize (integer) to limit the files to load: + loadVideo: function (data, options) { + if (options.disabled) { + return data; + } + var file = data.files[data.index], + url, + video; + if (this._videoElement.canPlayType && + this._videoElement.canPlayType(file.type) && + ($.type(options.maxFileSize) !== 'number' || + file.size <= options.maxFileSize) && + (!options.fileTypes || + options.fileTypes.test(file.type))) { + url = loadImage.createObjectURL(file); + if (url) { + video = this._videoElement.cloneNode(false); + video.src = url; + video.controls = true; + data.video = video; + return data; + } + } + return data; + }, + + // Sets the video element as a property of the file object: + setVideo: function (data, options) { + if (data.video && !options.disabled) { + data.files[data.index][options.name || 'preview'] = data.video; + } + return data; + } + + } + + }); + +})); diff --git a/node_modules/blueimp-file-upload/js/jquery.fileupload.js b/node_modules/blueimp-file-upload/js/jquery.fileupload.js new file mode 100644 index 000000000..629f57a25 --- /dev/null +++ b/node_modules/blueimp-file-upload/js/jquery.fileupload.js @@ -0,0 +1,1486 @@ +/* + * jQuery File Upload Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2010, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* jshint nomen:false */ +/* global define, require, window, document, location, Blob, FormData */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define([ + 'jquery', + 'jquery-ui/ui/widget' + ], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory( + require('jquery'), + require('./vendor/jquery.ui.widget') + ); + } else { + // Browser globals: + factory(window.jQuery); + } +}(function ($) { + 'use strict'; + + // Detect file input support, based on + // http://viljamis.com/blog/2012/file-upload-support-on-mobile/ + $.support.fileInput = !(new RegExp( + // Handle devices which give false positives for the feature detection: + '(Android (1\\.[0156]|2\\.[01]))' + + '|(Windows Phone (OS 7|8\\.0))|(XBLWP)|(ZuneWP)|(WPDesktop)' + + '|(w(eb)?OSBrowser)|(webOS)' + + '|(Kindle/(1\\.0|2\\.[05]|3\\.0))' + ).test(window.navigator.userAgent) || + // Feature detection for all other devices: + $('').prop('disabled')); + + // The FileReader API is not actually used, but works as feature detection, + // as some Safari versions (5?) support XHR file uploads via the FormData API, + // but not non-multipart XHR file uploads. + // window.XMLHttpRequestUpload is not available on IE10, so we check for + // window.ProgressEvent instead to detect XHR2 file upload capability: + $.support.xhrFileUpload = !!(window.ProgressEvent && window.FileReader); + $.support.xhrFormDataFileUpload = !!window.FormData; + + // Detect support for Blob slicing (required for chunked uploads): + $.support.blobSlice = window.Blob && (Blob.prototype.slice || + Blob.prototype.webkitSlice || Blob.prototype.mozSlice); + + // Helper function to create drag handlers for dragover/dragenter/dragleave: + function getDragHandler(type) { + var isDragOver = type === 'dragover'; + return function (e) { + e.dataTransfer = e.originalEvent && e.originalEvent.dataTransfer; + var dataTransfer = e.dataTransfer; + if (dataTransfer && $.inArray('Files', dataTransfer.types) !== -1 && + this._trigger( + type, + $.Event(type, {delegatedEvent: e}) + ) !== false) { + e.preventDefault(); + if (isDragOver) { + dataTransfer.dropEffect = 'copy'; + } + } + }; + } + + // The fileupload widget listens for change events on file input fields defined + // via fileInput setting and paste or drop events of the given dropZone. + // In addition to the default jQuery Widget methods, the fileupload widget + // exposes the "add" and "send" methods, to add or directly send files using + // the fileupload API. + // By default, files added via file input selection, paste, drag & drop or + // "add" method are uploaded immediately, but it is possible to override + // the "add" callback option to queue file uploads. + $.widget('blueimp.fileupload', { + + options: { + // The drop target element(s), by the default the complete document. + // Set to null to disable drag & drop support: + dropZone: $(document), + // The paste target element(s), by the default undefined. + // Set to a DOM node or jQuery object to enable file pasting: + pasteZone: undefined, + // The file input field(s), that are listened to for change events. + // If undefined, it is set to the file input fields inside + // of the widget element on plugin initialization. + // Set to null to disable the change listener. + fileInput: undefined, + // By default, the file input field is replaced with a clone after + // each input field change event. This is required for iframe transport + // queues and allows change events to be fired for the same file + // selection, but can be disabled by setting the following option to false: + replaceFileInput: true, + // The parameter name for the file form data (the request argument name). + // If undefined or empty, the name property of the file input field is + // used, or "files[]" if the file input name property is also empty, + // can be a string or an array of strings: + paramName: undefined, + // By default, each file of a selection is uploaded using an individual + // request for XHR type uploads. Set to false to upload file + // selections in one request each: + singleFileUploads: true, + // To limit the number of files uploaded with one XHR request, + // set the following option to an integer greater than 0: + limitMultiFileUploads: undefined, + // The following option limits the number of files uploaded with one + // XHR request to keep the request size under or equal to the defined + // limit in bytes: + limitMultiFileUploadSize: undefined, + // Multipart file uploads add a number of bytes to each uploaded file, + // therefore the following option adds an overhead for each file used + // in the limitMultiFileUploadSize configuration: + limitMultiFileUploadSizeOverhead: 512, + // Set the following option to true to issue all file upload requests + // in a sequential order: + sequentialUploads: false, + // To limit the number of concurrent uploads, + // set the following option to an integer greater than 0: + limitConcurrentUploads: undefined, + // Set the following option to true to force iframe transport uploads: + forceIframeTransport: false, + // Set the following option to the location of a redirect url on the + // origin server, for cross-domain iframe transport uploads: + redirect: undefined, + // The parameter name for the redirect url, sent as part of the form + // data and set to 'redirect' if this option is empty: + redirectParamName: undefined, + // Set the following option to the location of a postMessage window, + // to enable postMessage transport uploads: + postMessage: undefined, + // By default, XHR file uploads are sent as multipart/form-data. + // The iframe transport is always using multipart/form-data. + // Set to false to enable non-multipart XHR uploads: + multipart: true, + // To upload large files in smaller chunks, set the following option + // to a preferred maximum chunk size. If set to 0, null or undefined, + // or the browser does not support the required Blob API, files will + // be uploaded as a whole. + maxChunkSize: undefined, + // When a non-multipart upload or a chunked multipart upload has been + // aborted, this option can be used to resume the upload by setting + // it to the size of the already uploaded bytes. This option is most + // useful when modifying the options object inside of the "add" or + // "send" callbacks, as the options are cloned for each file upload. + uploadedBytes: undefined, + // By default, failed (abort or error) file uploads are removed from the + // global progress calculation. Set the following option to false to + // prevent recalculating the global progress data: + recalculateProgress: true, + // Interval in milliseconds to calculate and trigger progress events: + progressInterval: 100, + // Interval in milliseconds to calculate progress bitrate: + bitrateInterval: 500, + // By default, uploads are started automatically when adding files: + autoUpload: true, + + // Error and info messages: + messages: { + uploadedBytes: 'Uploaded bytes exceed file size' + }, + + // Translation function, gets the message key to be translated + // and an object with context specific data as arguments: + i18n: function (message, context) { + message = this.messages[message] || message.toString(); + if (context) { + $.each(context, function (key, value) { + message = message.replace('{' + key + '}', value); + }); + } + return message; + }, + + // Additional form data to be sent along with the file uploads can be set + // using this option, which accepts an array of objects with name and + // value properties, a function returning such an array, a FormData + // object (for XHR file uploads), or a simple object. + // The form of the first fileInput is given as parameter to the function: + formData: function (form) { + return form.serializeArray(); + }, + + // The add callback is invoked as soon as files are added to the fileupload + // widget (via file input selection, drag & drop, paste or add API call). + // If the singleFileUploads option is enabled, this callback will be + // called once for each file in the selection for XHR file uploads, else + // once for each file selection. + // + // The upload starts when the submit method is invoked on the data parameter. + // The data object contains a files property holding the added files + // and allows you to override plugin options as well as define ajax settings. + // + // Listeners for this callback can also be bound the following way: + // .bind('fileuploadadd', func); + // + // data.submit() returns a Promise object and allows to attach additional + // handlers using jQuery's Deferred callbacks: + // data.submit().done(func).fail(func).always(func); + add: function (e, data) { + if (e.isDefaultPrevented()) { + return false; + } + if (data.autoUpload || (data.autoUpload !== false && + $(this).fileupload('option', 'autoUpload'))) { + data.process().done(function () { + data.submit(); + }); + } + }, + + // Other callbacks: + + // Callback for the submit event of each file upload: + // submit: function (e, data) {}, // .bind('fileuploadsubmit', func); + + // Callback for the start of each file upload request: + // send: function (e, data) {}, // .bind('fileuploadsend', func); + + // Callback for successful uploads: + // done: function (e, data) {}, // .bind('fileuploaddone', func); + + // Callback for failed (abort or error) uploads: + // fail: function (e, data) {}, // .bind('fileuploadfail', func); + + // Callback for completed (success, abort or error) requests: + // always: function (e, data) {}, // .bind('fileuploadalways', func); + + // Callback for upload progress events: + // progress: function (e, data) {}, // .bind('fileuploadprogress', func); + + // Callback for global upload progress events: + // progressall: function (e, data) {}, // .bind('fileuploadprogressall', func); + + // Callback for uploads start, equivalent to the global ajaxStart event: + // start: function (e) {}, // .bind('fileuploadstart', func); + + // Callback for uploads stop, equivalent to the global ajaxStop event: + // stop: function (e) {}, // .bind('fileuploadstop', func); + + // Callback for change events of the fileInput(s): + // change: function (e, data) {}, // .bind('fileuploadchange', func); + + // Callback for paste events to the pasteZone(s): + // paste: function (e, data) {}, // .bind('fileuploadpaste', func); + + // Callback for drop events of the dropZone(s): + // drop: function (e, data) {}, // .bind('fileuploaddrop', func); + + // Callback for dragover events of the dropZone(s): + // dragover: function (e) {}, // .bind('fileuploaddragover', func); + + // Callback for the start of each chunk upload request: + // chunksend: function (e, data) {}, // .bind('fileuploadchunksend', func); + + // Callback for successful chunk uploads: + // chunkdone: function (e, data) {}, // .bind('fileuploadchunkdone', func); + + // Callback for failed (abort or error) chunk uploads: + // chunkfail: function (e, data) {}, // .bind('fileuploadchunkfail', func); + + // Callback for completed (success, abort or error) chunk upload requests: + // chunkalways: function (e, data) {}, // .bind('fileuploadchunkalways', func); + + // The plugin options are used as settings object for the ajax calls. + // The following are jQuery ajax settings required for the file uploads: + processData: false, + contentType: false, + cache: false, + timeout: 0 + }, + + // A list of options that require reinitializing event listeners and/or + // special initialization code: + _specialOptions: [ + 'fileInput', + 'dropZone', + 'pasteZone', + 'multipart', + 'forceIframeTransport' + ], + + _blobSlice: $.support.blobSlice && function () { + var slice = this.slice || this.webkitSlice || this.mozSlice; + return slice.apply(this, arguments); + }, + + _BitrateTimer: function () { + this.timestamp = ((Date.now) ? Date.now() : (new Date()).getTime()); + this.loaded = 0; + this.bitrate = 0; + this.getBitrate = function (now, loaded, interval) { + var timeDiff = now - this.timestamp; + if (!this.bitrate || !interval || timeDiff > interval) { + this.bitrate = (loaded - this.loaded) * (1000 / timeDiff) * 8; + this.loaded = loaded; + this.timestamp = now; + } + return this.bitrate; + }; + }, + + _isXHRUpload: function (options) { + return !options.forceIframeTransport && + ((!options.multipart && $.support.xhrFileUpload) || + $.support.xhrFormDataFileUpload); + }, + + _getFormData: function (options) { + var formData; + if ($.type(options.formData) === 'function') { + return options.formData(options.form); + } + if ($.isArray(options.formData)) { + return options.formData; + } + if ($.type(options.formData) === 'object') { + formData = []; + $.each(options.formData, function (name, value) { + formData.push({name: name, value: value}); + }); + return formData; + } + return []; + }, + + _getTotal: function (files) { + var total = 0; + $.each(files, function (index, file) { + total += file.size || 1; + }); + return total; + }, + + _initProgressObject: function (obj) { + var progress = { + loaded: 0, + total: 0, + bitrate: 0 + }; + if (obj._progress) { + $.extend(obj._progress, progress); + } else { + obj._progress = progress; + } + }, + + _initResponseObject: function (obj) { + var prop; + if (obj._response) { + for (prop in obj._response) { + if (obj._response.hasOwnProperty(prop)) { + delete obj._response[prop]; + } + } + } else { + obj._response = {}; + } + }, + + _onProgress: function (e, data) { + if (e.lengthComputable) { + var now = ((Date.now) ? Date.now() : (new Date()).getTime()), + loaded; + if (data._time && data.progressInterval && + (now - data._time < data.progressInterval) && + e.loaded !== e.total) { + return; + } + data._time = now; + loaded = Math.floor( + e.loaded / e.total * (data.chunkSize || data._progress.total) + ) + (data.uploadedBytes || 0); + // Add the difference from the previously loaded state + // to the global loaded counter: + this._progress.loaded += (loaded - data._progress.loaded); + this._progress.bitrate = this._bitrateTimer.getBitrate( + now, + this._progress.loaded, + data.bitrateInterval + ); + data._progress.loaded = data.loaded = loaded; + data._progress.bitrate = data.bitrate = data._bitrateTimer.getBitrate( + now, + loaded, + data.bitrateInterval + ); + // Trigger a custom progress event with a total data property set + // to the file size(s) of the current upload and a loaded data + // property calculated accordingly: + this._trigger( + 'progress', + $.Event('progress', {delegatedEvent: e}), + data + ); + // Trigger a global progress event for all current file uploads, + // including ajax calls queued for sequential file uploads: + this._trigger( + 'progressall', + $.Event('progressall', {delegatedEvent: e}), + this._progress + ); + } + }, + + _initProgressListener: function (options) { + var that = this, + xhr = options.xhr ? options.xhr() : $.ajaxSettings.xhr(); + // Accesss to the native XHR object is required to add event listeners + // for the upload progress event: + if (xhr.upload) { + $(xhr.upload).bind('progress', function (e) { + var oe = e.originalEvent; + // Make sure the progress event properties get copied over: + e.lengthComputable = oe.lengthComputable; + e.loaded = oe.loaded; + e.total = oe.total; + that._onProgress(e, options); + }); + options.xhr = function () { + return xhr; + }; + } + }, + + _isInstanceOf: function (type, obj) { + // Cross-frame instanceof check + return Object.prototype.toString.call(obj) === '[object ' + type + ']'; + }, + + _initXHRData: function (options) { + var that = this, + formData, + file = options.files[0], + // Ignore non-multipart setting if not supported: + multipart = options.multipart || !$.support.xhrFileUpload, + paramName = $.type(options.paramName) === 'array' ? + options.paramName[0] : options.paramName; + options.headers = $.extend({}, options.headers); + if (options.contentRange) { + options.headers['Content-Range'] = options.contentRange; + } + if (!multipart || options.blob || !this._isInstanceOf('File', file)) { + options.headers['Content-Disposition'] = 'attachment; filename="' + + encodeURI(file.uploadName || file.name) + '"'; + } + if (!multipart) { + options.contentType = file.type || 'application/octet-stream'; + options.data = options.blob || file; + } else if ($.support.xhrFormDataFileUpload) { + if (options.postMessage) { + // window.postMessage does not allow sending FormData + // objects, so we just add the File/Blob objects to + // the formData array and let the postMessage window + // create the FormData object out of this array: + formData = this._getFormData(options); + if (options.blob) { + formData.push({ + name: paramName, + value: options.blob + }); + } else { + $.each(options.files, function (index, file) { + formData.push({ + name: ($.type(options.paramName) === 'array' && + options.paramName[index]) || paramName, + value: file + }); + }); + } + } else { + if (that._isInstanceOf('FormData', options.formData)) { + formData = options.formData; + } else { + formData = new FormData(); + $.each(this._getFormData(options), function (index, field) { + formData.append(field.name, field.value); + }); + } + if (options.blob) { + formData.append( + paramName, + options.blob, + file.uploadName || file.name + ); + } else { + $.each(options.files, function (index, file) { + // This check allows the tests to run with + // dummy objects: + if (that._isInstanceOf('File', file) || + that._isInstanceOf('Blob', file)) { + formData.append( + ($.type(options.paramName) === 'array' && + options.paramName[index]) || paramName, + file, + file.uploadName || file.name + ); + } + }); + } + } + options.data = formData; + } + // Blob reference is not needed anymore, free memory: + options.blob = null; + }, + + _initIframeSettings: function (options) { + var targetHost = $('').prop('href', options.url).prop('host'); + // Setting the dataType to iframe enables the iframe transport: + options.dataType = 'iframe ' + (options.dataType || ''); + // The iframe transport accepts a serialized array as form data: + options.formData = this._getFormData(options); + // Add redirect url to form data on cross-domain uploads: + if (options.redirect && targetHost && targetHost !== location.host) { + options.formData.push({ + name: options.redirectParamName || 'redirect', + value: options.redirect + }); + } + }, + + _initDataSettings: function (options) { + if (this._isXHRUpload(options)) { + if (!this._chunkedUpload(options, true)) { + if (!options.data) { + this._initXHRData(options); + } + this._initProgressListener(options); + } + if (options.postMessage) { + // Setting the dataType to postmessage enables the + // postMessage transport: + options.dataType = 'postmessage ' + (options.dataType || ''); + } + } else { + this._initIframeSettings(options); + } + }, + + _getParamName: function (options) { + var fileInput = $(options.fileInput), + paramName = options.paramName; + if (!paramName) { + paramName = []; + fileInput.each(function () { + var input = $(this), + name = input.prop('name') || 'files[]', + i = (input.prop('files') || [1]).length; + while (i) { + paramName.push(name); + i -= 1; + } + }); + if (!paramName.length) { + paramName = [fileInput.prop('name') || 'files[]']; + } + } else if (!$.isArray(paramName)) { + paramName = [paramName]; + } + return paramName; + }, + + _initFormSettings: function (options) { + // Retrieve missing options from the input field and the + // associated form, if available: + if (!options.form || !options.form.length) { + options.form = $(options.fileInput.prop('form')); + // If the given file input doesn't have an associated form, + // use the default widget file input's form: + if (!options.form.length) { + options.form = $(this.options.fileInput.prop('form')); + } + } + options.paramName = this._getParamName(options); + if (!options.url) { + options.url = options.form.prop('action') || location.href; + } + // The HTTP request method must be "POST" or "PUT": + options.type = (options.type || + ($.type(options.form.prop('method')) === 'string' && + options.form.prop('method')) || '' + ).toUpperCase(); + if (options.type !== 'POST' && options.type !== 'PUT' && + options.type !== 'PATCH') { + options.type = 'POST'; + } + if (!options.formAcceptCharset) { + options.formAcceptCharset = options.form.attr('accept-charset'); + } + }, + + _getAJAXSettings: function (data) { + var options = $.extend({}, this.options, data); + this._initFormSettings(options); + this._initDataSettings(options); + return options; + }, + + // jQuery 1.6 doesn't provide .state(), + // while jQuery 1.8+ removed .isRejected() and .isResolved(): + _getDeferredState: function (deferred) { + if (deferred.state) { + return deferred.state(); + } + if (deferred.isResolved()) { + return 'resolved'; + } + if (deferred.isRejected()) { + return 'rejected'; + } + return 'pending'; + }, + + // Maps jqXHR callbacks to the equivalent + // methods of the given Promise object: + _enhancePromise: function (promise) { + promise.success = promise.done; + promise.error = promise.fail; + promise.complete = promise.always; + return promise; + }, + + // Creates and returns a Promise object enhanced with + // the jqXHR methods abort, success, error and complete: + _getXHRPromise: function (resolveOrReject, context, args) { + var dfd = $.Deferred(), + promise = dfd.promise(); + context = context || this.options.context || promise; + if (resolveOrReject === true) { + dfd.resolveWith(context, args); + } else if (resolveOrReject === false) { + dfd.rejectWith(context, args); + } + promise.abort = dfd.promise; + return this._enhancePromise(promise); + }, + + // Adds convenience methods to the data callback argument: + _addConvenienceMethods: function (e, data) { + var that = this, + getPromise = function (args) { + return $.Deferred().resolveWith(that, args).promise(); + }; + data.process = function (resolveFunc, rejectFunc) { + if (resolveFunc || rejectFunc) { + data._processQueue = this._processQueue = + (this._processQueue || getPromise([this])).then( + function () { + if (data.errorThrown) { + return $.Deferred() + .rejectWith(that, [data]).promise(); + } + return getPromise(arguments); + } + ).then(resolveFunc, rejectFunc); + } + return this._processQueue || getPromise([this]); + }; + data.submit = function () { + if (this.state() !== 'pending') { + data.jqXHR = this.jqXHR = + (that._trigger( + 'submit', + $.Event('submit', {delegatedEvent: e}), + this + ) !== false) && that._onSend(e, this); + } + return this.jqXHR || that._getXHRPromise(); + }; + data.abort = function () { + if (this.jqXHR) { + return this.jqXHR.abort(); + } + this.errorThrown = 'abort'; + that._trigger('fail', null, this); + return that._getXHRPromise(false); + }; + data.state = function () { + if (this.jqXHR) { + return that._getDeferredState(this.jqXHR); + } + if (this._processQueue) { + return that._getDeferredState(this._processQueue); + } + }; + data.processing = function () { + return !this.jqXHR && this._processQueue && that + ._getDeferredState(this._processQueue) === 'pending'; + }; + data.progress = function () { + return this._progress; + }; + data.response = function () { + return this._response; + }; + }, + + // Parses the Range header from the server response + // and returns the uploaded bytes: + _getUploadedBytes: function (jqXHR) { + var range = jqXHR.getResponseHeader('Range'), + parts = range && range.split('-'), + upperBytesPos = parts && parts.length > 1 && + parseInt(parts[1], 10); + return upperBytesPos && upperBytesPos + 1; + }, + + // Uploads a file in multiple, sequential requests + // by splitting the file up in multiple blob chunks. + // If the second parameter is true, only tests if the file + // should be uploaded in chunks, but does not invoke any + // upload requests: + _chunkedUpload: function (options, testOnly) { + options.uploadedBytes = options.uploadedBytes || 0; + var that = this, + file = options.files[0], + fs = file.size, + ub = options.uploadedBytes, + mcs = options.maxChunkSize || fs, + slice = this._blobSlice, + dfd = $.Deferred(), + promise = dfd.promise(), + jqXHR, + upload; + if (!(this._isXHRUpload(options) && slice && (ub || ($.type(mcs) === 'function' ? mcs(options) : mcs) < fs)) || + options.data) { + return false; + } + if (testOnly) { + return true; + } + if (ub >= fs) { + file.error = options.i18n('uploadedBytes'); + return this._getXHRPromise( + false, + options.context, + [null, 'error', file.error] + ); + } + // The chunk upload method: + upload = function () { + // Clone the options object for each chunk upload: + var o = $.extend({}, options), + currentLoaded = o._progress.loaded; + o.blob = slice.call( + file, + ub, + ub + ($.type(mcs) === 'function' ? mcs(o) : mcs), + file.type + ); + // Store the current chunk size, as the blob itself + // will be dereferenced after data processing: + o.chunkSize = o.blob.size; + // Expose the chunk bytes position range: + o.contentRange = 'bytes ' + ub + '-' + + (ub + o.chunkSize - 1) + '/' + fs; + // Process the upload data (the blob and potential form data): + that._initXHRData(o); + // Add progress listeners for this chunk upload: + that._initProgressListener(o); + jqXHR = ((that._trigger('chunksend', null, o) !== false && $.ajax(o)) || + that._getXHRPromise(false, o.context)) + .done(function (result, textStatus, jqXHR) { + ub = that._getUploadedBytes(jqXHR) || + (ub + o.chunkSize); + // Create a progress event if no final progress event + // with loaded equaling total has been triggered + // for this chunk: + if (currentLoaded + o.chunkSize - o._progress.loaded) { + that._onProgress($.Event('progress', { + lengthComputable: true, + loaded: ub - o.uploadedBytes, + total: ub - o.uploadedBytes + }), o); + } + options.uploadedBytes = o.uploadedBytes = ub; + o.result = result; + o.textStatus = textStatus; + o.jqXHR = jqXHR; + that._trigger('chunkdone', null, o); + that._trigger('chunkalways', null, o); + if (ub < fs) { + // File upload not yet complete, + // continue with the next chunk: + upload(); + } else { + dfd.resolveWith( + o.context, + [result, textStatus, jqXHR] + ); + } + }) + .fail(function (jqXHR, textStatus, errorThrown) { + o.jqXHR = jqXHR; + o.textStatus = textStatus; + o.errorThrown = errorThrown; + that._trigger('chunkfail', null, o); + that._trigger('chunkalways', null, o); + dfd.rejectWith( + o.context, + [jqXHR, textStatus, errorThrown] + ); + }); + }; + this._enhancePromise(promise); + promise.abort = function () { + return jqXHR.abort(); + }; + upload(); + return promise; + }, + + _beforeSend: function (e, data) { + if (this._active === 0) { + // the start callback is triggered when an upload starts + // and no other uploads are currently running, + // equivalent to the global ajaxStart event: + this._trigger('start'); + // Set timer for global bitrate progress calculation: + this._bitrateTimer = new this._BitrateTimer(); + // Reset the global progress values: + this._progress.loaded = this._progress.total = 0; + this._progress.bitrate = 0; + } + // Make sure the container objects for the .response() and + // .progress() methods on the data object are available + // and reset to their initial state: + this._initResponseObject(data); + this._initProgressObject(data); + data._progress.loaded = data.loaded = data.uploadedBytes || 0; + data._progress.total = data.total = this._getTotal(data.files) || 1; + data._progress.bitrate = data.bitrate = 0; + this._active += 1; + // Initialize the global progress values: + this._progress.loaded += data.loaded; + this._progress.total += data.total; + }, + + _onDone: function (result, textStatus, jqXHR, options) { + var total = options._progress.total, + response = options._response; + if (options._progress.loaded < total) { + // Create a progress event if no final progress event + // with loaded equaling total has been triggered: + this._onProgress($.Event('progress', { + lengthComputable: true, + loaded: total, + total: total + }), options); + } + response.result = options.result = result; + response.textStatus = options.textStatus = textStatus; + response.jqXHR = options.jqXHR = jqXHR; + this._trigger('done', null, options); + }, + + _onFail: function (jqXHR, textStatus, errorThrown, options) { + var response = options._response; + if (options.recalculateProgress) { + // Remove the failed (error or abort) file upload from + // the global progress calculation: + this._progress.loaded -= options._progress.loaded; + this._progress.total -= options._progress.total; + } + response.jqXHR = options.jqXHR = jqXHR; + response.textStatus = options.textStatus = textStatus; + response.errorThrown = options.errorThrown = errorThrown; + this._trigger('fail', null, options); + }, + + _onAlways: function (jqXHRorResult, textStatus, jqXHRorError, options) { + // jqXHRorResult, textStatus and jqXHRorError are added to the + // options object via done and fail callbacks + this._trigger('always', null, options); + }, + + _onSend: function (e, data) { + if (!data.submit) { + this._addConvenienceMethods(e, data); + } + var that = this, + jqXHR, + aborted, + slot, + pipe, + options = that._getAJAXSettings(data), + send = function () { + that._sending += 1; + // Set timer for bitrate progress calculation: + options._bitrateTimer = new that._BitrateTimer(); + jqXHR = jqXHR || ( + ((aborted || that._trigger( + 'send', + $.Event('send', {delegatedEvent: e}), + options + ) === false) && + that._getXHRPromise(false, options.context, aborted)) || + that._chunkedUpload(options) || $.ajax(options) + ).done(function (result, textStatus, jqXHR) { + that._onDone(result, textStatus, jqXHR, options); + }).fail(function (jqXHR, textStatus, errorThrown) { + that._onFail(jqXHR, textStatus, errorThrown, options); + }).always(function (jqXHRorResult, textStatus, jqXHRorError) { + that._onAlways( + jqXHRorResult, + textStatus, + jqXHRorError, + options + ); + that._sending -= 1; + that._active -= 1; + if (options.limitConcurrentUploads && + options.limitConcurrentUploads > that._sending) { + // Start the next queued upload, + // that has not been aborted: + var nextSlot = that._slots.shift(); + while (nextSlot) { + if (that._getDeferredState(nextSlot) === 'pending') { + nextSlot.resolve(); + break; + } + nextSlot = that._slots.shift(); + } + } + if (that._active === 0) { + // The stop callback is triggered when all uploads have + // been completed, equivalent to the global ajaxStop event: + that._trigger('stop'); + } + }); + return jqXHR; + }; + this._beforeSend(e, options); + if (this.options.sequentialUploads || + (this.options.limitConcurrentUploads && + this.options.limitConcurrentUploads <= this._sending)) { + if (this.options.limitConcurrentUploads > 1) { + slot = $.Deferred(); + this._slots.push(slot); + pipe = slot.then(send); + } else { + this._sequence = this._sequence.then(send, send); + pipe = this._sequence; + } + // Return the piped Promise object, enhanced with an abort method, + // which is delegated to the jqXHR object of the current upload, + // and jqXHR callbacks mapped to the equivalent Promise methods: + pipe.abort = function () { + aborted = [undefined, 'abort', 'abort']; + if (!jqXHR) { + if (slot) { + slot.rejectWith(options.context, aborted); + } + return send(); + } + return jqXHR.abort(); + }; + return this._enhancePromise(pipe); + } + return send(); + }, + + _onAdd: function (e, data) { + var that = this, + result = true, + options = $.extend({}, this.options, data), + files = data.files, + filesLength = files.length, + limit = options.limitMultiFileUploads, + limitSize = options.limitMultiFileUploadSize, + overhead = options.limitMultiFileUploadSizeOverhead, + batchSize = 0, + paramName = this._getParamName(options), + paramNameSet, + paramNameSlice, + fileSet, + i, + j = 0; + if (!filesLength) { + return false; + } + if (limitSize && files[0].size === undefined) { + limitSize = undefined; + } + if (!(options.singleFileUploads || limit || limitSize) || + !this._isXHRUpload(options)) { + fileSet = [files]; + paramNameSet = [paramName]; + } else if (!(options.singleFileUploads || limitSize) && limit) { + fileSet = []; + paramNameSet = []; + for (i = 0; i < filesLength; i += limit) { + fileSet.push(files.slice(i, i + limit)); + paramNameSlice = paramName.slice(i, i + limit); + if (!paramNameSlice.length) { + paramNameSlice = paramName; + } + paramNameSet.push(paramNameSlice); + } + } else if (!options.singleFileUploads && limitSize) { + fileSet = []; + paramNameSet = []; + for (i = 0; i < filesLength; i = i + 1) { + batchSize += files[i].size + overhead; + if (i + 1 === filesLength || + ((batchSize + files[i + 1].size + overhead) > limitSize) || + (limit && i + 1 - j >= limit)) { + fileSet.push(files.slice(j, i + 1)); + paramNameSlice = paramName.slice(j, i + 1); + if (!paramNameSlice.length) { + paramNameSlice = paramName; + } + paramNameSet.push(paramNameSlice); + j = i + 1; + batchSize = 0; + } + } + } else { + paramNameSet = paramName; + } + data.originalFiles = files; + $.each(fileSet || files, function (index, element) { + var newData = $.extend({}, data); + newData.files = fileSet ? element : [element]; + newData.paramName = paramNameSet[index]; + that._initResponseObject(newData); + that._initProgressObject(newData); + that._addConvenienceMethods(e, newData); + result = that._trigger( + 'add', + $.Event('add', {delegatedEvent: e}), + newData + ); + return result; + }); + return result; + }, + + _replaceFileInput: function (data) { + var input = data.fileInput, + inputClone = input.clone(true), + restoreFocus = input.is(document.activeElement); + // Add a reference for the new cloned file input to the data argument: + data.fileInputClone = inputClone; + $('
').append(inputClone)[0].reset(); + // Detaching allows to insert the fileInput on another form + // without loosing the file input value: + input.after(inputClone).detach(); + // If the fileInput had focus before it was detached, + // restore focus to the inputClone. + if (restoreFocus) { + inputClone.focus(); + } + // Avoid memory leaks with the detached file input: + $.cleanData(input.unbind('remove')); + // Replace the original file input element in the fileInput + // elements set with the clone, which has been copied including + // event handlers: + this.options.fileInput = this.options.fileInput.map(function (i, el) { + if (el === input[0]) { + return inputClone[0]; + } + return el; + }); + // If the widget has been initialized on the file input itself, + // override this.element with the file input clone: + if (input[0] === this.element[0]) { + this.element = inputClone; + } + }, + + _handleFileTreeEntry: function (entry, path) { + var that = this, + dfd = $.Deferred(), + entries = [], + dirReader, + errorHandler = function (e) { + if (e && !e.entry) { + e.entry = entry; + } + // Since $.when returns immediately if one + // Deferred is rejected, we use resolve instead. + // This allows valid files and invalid items + // to be returned together in one set: + dfd.resolve([e]); + }, + successHandler = function (entries) { + that._handleFileTreeEntries( + entries, + path + entry.name + '/' + ).done(function (files) { + dfd.resolve(files); + }).fail(errorHandler); + }, + readEntries = function () { + dirReader.readEntries(function (results) { + if (!results.length) { + successHandler(entries); + } else { + entries = entries.concat(results); + readEntries(); + } + }, errorHandler); + }; + path = path || ''; + if (entry.isFile) { + if (entry._file) { + // Workaround for Chrome bug #149735 + entry._file.relativePath = path; + dfd.resolve(entry._file); + } else { + entry.file(function (file) { + file.relativePath = path; + dfd.resolve(file); + }, errorHandler); + } + } else if (entry.isDirectory) { + dirReader = entry.createReader(); + readEntries(); + } else { + // Return an empty list for file system items + // other than files or directories: + dfd.resolve([]); + } + return dfd.promise(); + }, + + _handleFileTreeEntries: function (entries, path) { + var that = this; + return $.when.apply( + $, + $.map(entries, function (entry) { + return that._handleFileTreeEntry(entry, path); + }) + ).then(function () { + return Array.prototype.concat.apply( + [], + arguments + ); + }); + }, + + _getDroppedFiles: function (dataTransfer) { + dataTransfer = dataTransfer || {}; + var items = dataTransfer.items; + if (items && items.length && (items[0].webkitGetAsEntry || + items[0].getAsEntry)) { + return this._handleFileTreeEntries( + $.map(items, function (item) { + var entry; + if (item.webkitGetAsEntry) { + entry = item.webkitGetAsEntry(); + if (entry) { + // Workaround for Chrome bug #149735: + entry._file = item.getAsFile(); + } + return entry; + } + return item.getAsEntry(); + }) + ); + } + return $.Deferred().resolve( + $.makeArray(dataTransfer.files) + ).promise(); + }, + + _getSingleFileInputFiles: function (fileInput) { + fileInput = $(fileInput); + var entries = fileInput.prop('webkitEntries') || + fileInput.prop('entries'), + files, + value; + if (entries && entries.length) { + return this._handleFileTreeEntries(entries); + } + files = $.makeArray(fileInput.prop('files')); + if (!files.length) { + value = fileInput.prop('value'); + if (!value) { + return $.Deferred().resolve([]).promise(); + } + // If the files property is not available, the browser does not + // support the File API and we add a pseudo File object with + // the input value as name with path information removed: + files = [{name: value.replace(/^.*\\/, '')}]; + } else if (files[0].name === undefined && files[0].fileName) { + // File normalization for Safari 4 and Firefox 3: + $.each(files, function (index, file) { + file.name = file.fileName; + file.size = file.fileSize; + }); + } + return $.Deferred().resolve(files).promise(); + }, + + _getFileInputFiles: function (fileInput) { + if (!(fileInput instanceof $) || fileInput.length === 1) { + return this._getSingleFileInputFiles(fileInput); + } + return $.when.apply( + $, + $.map(fileInput, this._getSingleFileInputFiles) + ).then(function () { + return Array.prototype.concat.apply( + [], + arguments + ); + }); + }, + + _onChange: function (e) { + var that = this, + data = { + fileInput: $(e.target), + form: $(e.target.form) + }; + this._getFileInputFiles(data.fileInput).always(function (files) { + data.files = files; + if (that.options.replaceFileInput) { + that._replaceFileInput(data); + } + if (that._trigger( + 'change', + $.Event('change', {delegatedEvent: e}), + data + ) !== false) { + that._onAdd(e, data); + } + }); + }, + + _onPaste: function (e) { + var items = e.originalEvent && e.originalEvent.clipboardData && + e.originalEvent.clipboardData.items, + data = {files: []}; + if (items && items.length) { + $.each(items, function (index, item) { + var file = item.getAsFile && item.getAsFile(); + if (file) { + data.files.push(file); + } + }); + if (this._trigger( + 'paste', + $.Event('paste', {delegatedEvent: e}), + data + ) !== false) { + this._onAdd(e, data); + } + } + }, + + _onDrop: function (e) { + e.dataTransfer = e.originalEvent && e.originalEvent.dataTransfer; + var that = this, + dataTransfer = e.dataTransfer, + data = {}; + if (dataTransfer && dataTransfer.files && dataTransfer.files.length) { + e.preventDefault(); + this._getDroppedFiles(dataTransfer).always(function (files) { + data.files = files; + if (that._trigger( + 'drop', + $.Event('drop', {delegatedEvent: e}), + data + ) !== false) { + that._onAdd(e, data); + } + }); + } + }, + + _onDragOver: getDragHandler('dragover'), + + _onDragEnter: getDragHandler('dragenter'), + + _onDragLeave: getDragHandler('dragleave'), + + _initEventHandlers: function () { + if (this._isXHRUpload(this.options)) { + this._on(this.options.dropZone, { + dragover: this._onDragOver, + drop: this._onDrop, + // event.preventDefault() on dragenter is required for IE10+: + dragenter: this._onDragEnter, + // dragleave is not required, but added for completeness: + dragleave: this._onDragLeave + }); + this._on(this.options.pasteZone, { + paste: this._onPaste + }); + } + if ($.support.fileInput) { + this._on(this.options.fileInput, { + change: this._onChange + }); + } + }, + + _destroyEventHandlers: function () { + this._off(this.options.dropZone, 'dragenter dragleave dragover drop'); + this._off(this.options.pasteZone, 'paste'); + this._off(this.options.fileInput, 'change'); + }, + + _destroy: function () { + this._destroyEventHandlers(); + }, + + _setOption: function (key, value) { + var reinit = $.inArray(key, this._specialOptions) !== -1; + if (reinit) { + this._destroyEventHandlers(); + } + this._super(key, value); + if (reinit) { + this._initSpecialOptions(); + this._initEventHandlers(); + } + }, + + _initSpecialOptions: function () { + var options = this.options; + if (options.fileInput === undefined) { + options.fileInput = this.element.is('input[type="file"]') ? + this.element : this.element.find('input[type="file"]'); + } else if (!(options.fileInput instanceof $)) { + options.fileInput = $(options.fileInput); + } + if (!(options.dropZone instanceof $)) { + options.dropZone = $(options.dropZone); + } + if (!(options.pasteZone instanceof $)) { + options.pasteZone = $(options.pasteZone); + } + }, + + _getRegExp: function (str) { + var parts = str.split('/'), + modifiers = parts.pop(); + parts.shift(); + return new RegExp(parts.join('/'), modifiers); + }, + + _isRegExpOption: function (key, value) { + return key !== 'url' && $.type(value) === 'string' && + /^\/.*\/[igm]{0,3}$/.test(value); + }, + + _initDataAttributes: function () { + var that = this, + options = this.options, + data = this.element.data(); + // Initialize options set via HTML5 data-attributes: + $.each( + this.element[0].attributes, + function (index, attr) { + var key = attr.name.toLowerCase(), + value; + if (/^data-/.test(key)) { + // Convert hyphen-ated key to camelCase: + key = key.slice(5).replace(/-[a-z]/g, function (str) { + return str.charAt(1).toUpperCase(); + }); + value = data[key]; + if (that._isRegExpOption(key, value)) { + value = that._getRegExp(value); + } + options[key] = value; + } + } + ); + }, + + _create: function () { + this._initDataAttributes(); + this._initSpecialOptions(); + this._slots = []; + this._sequence = this._getXHRPromise(true); + this._sending = this._active = 0; + this._initProgressObject(this); + this._initEventHandlers(); + }, + + // This method is exposed to the widget API and allows to query + // the number of active uploads: + active: function () { + return this._active; + }, + + // This method is exposed to the widget API and allows to query + // the widget upload progress. + // It returns an object with loaded, total and bitrate properties + // for the running uploads: + progress: function () { + return this._progress; + }, + + // This method is exposed to the widget API and allows adding files + // using the fileupload API. The data parameter accepts an object which + // must have a files property and can contain additional options: + // .fileupload('add', {files: filesList}); + add: function (data) { + var that = this; + if (!data || this.options.disabled) { + return; + } + if (data.fileInput && !data.files) { + this._getFileInputFiles(data.fileInput).always(function (files) { + data.files = files; + that._onAdd(null, data); + }); + } else { + data.files = $.makeArray(data.files); + this._onAdd(null, data); + } + }, + + // This method is exposed to the widget API and allows sending files + // using the fileupload API. The data parameter accepts an object which + // must have a files or fileInput property and can contain additional options: + // .fileupload('send', {files: filesList}); + // The method returns a Promise object for the file upload call. + send: function (data) { + if (data && !this.options.disabled) { + if (data.fileInput && !data.files) { + var that = this, + dfd = $.Deferred(), + promise = dfd.promise(), + jqXHR, + aborted; + promise.abort = function () { + aborted = true; + if (jqXHR) { + return jqXHR.abort(); + } + dfd.reject(null, 'abort', 'abort'); + return promise; + }; + this._getFileInputFiles(data.fileInput).always( + function (files) { + if (aborted) { + return; + } + if (!files.length) { + dfd.reject(); + return; + } + data.files = files; + jqXHR = that._onSend(null, data); + jqXHR.then( + function (result, textStatus, jqXHR) { + dfd.resolve(result, textStatus, jqXHR); + }, + function (jqXHR, textStatus, errorThrown) { + dfd.reject(jqXHR, textStatus, errorThrown); + } + ); + } + ); + return this._enhancePromise(promise); + } + data.files = $.makeArray(data.files); + if (data.files.length) { + return this._onSend(null, data); + } + } + return this._getXHRPromise(false, data && data.context); + } + + }); + +})); diff --git a/node_modules/blueimp-file-upload/js/jquery.iframe-transport.js b/node_modules/blueimp-file-upload/js/jquery.iframe-transport.js new file mode 100644 index 000000000..8d25c4641 --- /dev/null +++ b/node_modules/blueimp-file-upload/js/jquery.iframe-transport.js @@ -0,0 +1,224 @@ +/* + * jQuery Iframe Transport Plugin + * https://github.com/blueimp/jQuery-File-Upload + * + * Copyright 2011, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* global define, require, window, document, JSON */ + +;(function (factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define(['jquery'], factory); + } else if (typeof exports === 'object') { + // Node/CommonJS: + factory(require('jquery')); + } else { + // Browser globals: + factory(window.jQuery); + } +}(function ($) { + 'use strict'; + + // Helper variable to create unique names for the transport iframes: + var counter = 0, + jsonAPI = $, + jsonParse = 'parseJSON'; + + if ('JSON' in window && 'parse' in JSON) { + jsonAPI = JSON; + jsonParse = 'parse'; + } + + // The iframe transport accepts four additional options: + // options.fileInput: a jQuery collection of file input fields + // options.paramName: the parameter name for the file form data, + // overrides the name property of the file input field(s), + // can be a string or an array of strings. + // options.formData: an array of objects with name and value properties, + // equivalent to the return data of .serializeArray(), e.g.: + // [{name: 'a', value: 1}, {name: 'b', value: 2}] + // options.initialIframeSrc: the URL of the initial iframe src, + // by default set to "javascript:false;" + $.ajaxTransport('iframe', function (options) { + if (options.async) { + // javascript:false as initial iframe src + // prevents warning popups on HTTPS in IE6: + /*jshint scripturl: true */ + var initialIframeSrc = options.initialIframeSrc || 'javascript:false;', + /*jshint scripturl: false */ + form, + iframe, + addParamChar; + return { + send: function (_, completeCallback) { + form = $('
'); + form.attr('accept-charset', options.formAcceptCharset); + addParamChar = /\?/.test(options.url) ? '&' : '?'; + // XDomainRequest only supports GET and POST: + if (options.type === 'DELETE') { + options.url = options.url + addParamChar + '_method=DELETE'; + options.type = 'POST'; + } else if (options.type === 'PUT') { + options.url = options.url + addParamChar + '_method=PUT'; + options.type = 'POST'; + } else if (options.type === 'PATCH') { + options.url = options.url + addParamChar + '_method=PATCH'; + options.type = 'POST'; + } + // IE versions below IE8 cannot set the name property of + // elements that have already been added to the DOM, + // so we set the name along with the iframe HTML markup: + counter += 1; + iframe = $( + '' + ).bind('load', function () { + var fileInputClones, + paramNames = $.isArray(options.paramName) ? + options.paramName : [options.paramName]; + iframe + .unbind('load') + .bind('load', function () { + var response; + // Wrap in a try/catch block to catch exceptions thrown + // when trying to access cross-domain iframe contents: + try { + response = iframe.contents(); + // Google Chrome and Firefox do not throw an + // exception when calling iframe.contents() on + // cross-domain requests, so we unify the response: + if (!response.length || !response[0].firstChild) { + throw new Error(); + } + } catch (e) { + response = undefined; + } + // The complete callback returns the + // iframe content document as response object: + completeCallback( + 200, + 'success', + {'iframe': response} + ); + // Fix for IE endless progress bar activity bug + // (happens on form submits to iframe targets): + $('') + .appendTo(form); + window.setTimeout(function () { + // Removing the form in a setTimeout call + // allows Chrome's developer tools to display + // the response result + form.remove(); + }, 0); + }); + form + .prop('target', iframe.prop('name')) + .prop('action', options.url) + .prop('method', options.type); + if (options.formData) { + $.each(options.formData, function (index, field) { + $('') + .prop('name', field.name) + .val(field.value) + .appendTo(form); + }); + } + if (options.fileInput && options.fileInput.length && + options.type === 'POST') { + fileInputClones = options.fileInput.clone(); + // Insert a clone for each file input field: + options.fileInput.after(function (index) { + return fileInputClones[index]; + }); + if (options.paramName) { + options.fileInput.each(function (index) { + $(this).prop( + 'name', + paramNames[index] || options.paramName + ); + }); + } + // Appending the file input fields to the hidden form + // removes them from their original location: + form + .append(options.fileInput) + .prop('enctype', 'multipart/form-data') + // enctype must be set as encoding for IE: + .prop('encoding', 'multipart/form-data'); + // Remove the HTML5 form attribute from the input(s): + options.fileInput.removeAttr('form'); + } + form.submit(); + // Insert the file input fields at their original location + // by replacing the clones with the originals: + if (fileInputClones && fileInputClones.length) { + options.fileInput.each(function (index, input) { + var clone = $(fileInputClones[index]); + // Restore the original name and form properties: + $(input) + .prop('name', clone.prop('name')) + .attr('form', clone.attr('form')); + clone.replaceWith(input); + }); + } + }); + form.append(iframe).appendTo(document.body); + }, + abort: function () { + if (iframe) { + // javascript:false as iframe src aborts the request + // and prevents warning popups on HTTPS in IE6. + // concat is used to avoid the "Script URL" JSLint error: + iframe + .unbind('load') + .prop('src', initialIframeSrc); + } + if (form) { + form.remove(); + } + } + }; + } + }); + + // The iframe transport returns the iframe content document as response. + // The following adds converters from iframe to text, json, html, xml + // and script. + // Please note that the Content-Type for JSON responses has to be text/plain + // or text/html, if the browser doesn't include application/json in the + // Accept header, else IE will show a download dialog. + // The Content-Type for XML responses on the other hand has to be always + // application/xml or text/xml, so IE properly parses the XML response. + // See also + // https://github.com/blueimp/jQuery-File-Upload/wiki/Setup#content-type-negotiation + $.ajaxSetup({ + converters: { + 'iframe text': function (iframe) { + return iframe && $(iframe[0].body).text(); + }, + 'iframe json': function (iframe) { + return iframe && jsonAPI[jsonParse]($(iframe[0].body).text()); + }, + 'iframe html': function (iframe) { + return iframe && $(iframe[0].body).html(); + }, + 'iframe xml': function (iframe) { + var xmlDoc = iframe && iframe[0]; + return xmlDoc && $.isXMLDoc(xmlDoc) ? xmlDoc : + $.parseXML((xmlDoc.XMLDocument && xmlDoc.XMLDocument.xml) || + $(xmlDoc.body).html()); + }, + 'iframe script': function (iframe) { + return iframe && $.globalEval($(iframe[0].body).text()); + } + } + }); + +})); diff --git a/node_modules/blueimp-file-upload/js/vendor/jquery.ui.widget.js b/node_modules/blueimp-file-upload/js/vendor/jquery.ui.widget.js new file mode 100644 index 000000000..914b8ffb8 --- /dev/null +++ b/node_modules/blueimp-file-upload/js/vendor/jquery.ui.widget.js @@ -0,0 +1,752 @@ +/*! jQuery UI - v1.12.1+CommonJS - 2018-02-10 + * http://jqueryui.com + * Includes: widget.js + * Copyright jQuery Foundation and other contributors; Licensed MIT */ + +(function( factory ) { + if ( typeof define === "function" && define.amd ) { + + // AMD. Register as an anonymous module. + define([ "jquery" ], factory ); + } else if ( typeof exports === "object" ) { + + // Node/CommonJS + factory( require( "jquery" ) ); + } else { + + // Browser globals + factory( jQuery ); + } +}(function( $ ) { + + $.ui = $.ui || {}; + + var version = $.ui.version = "1.12.1"; + + + /*! + * jQuery UI Widget 1.12.1 + * http://jqueryui.com + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license. + * http://jquery.org/license + */ + + //>>label: Widget + //>>group: Core + //>>description: Provides a factory for creating stateful widgets with a common API. + //>>docs: http://api.jqueryui.com/jQuery.widget/ + //>>demos: http://jqueryui.com/widget/ + + + + var widgetUuid = 0; + var widgetSlice = Array.prototype.slice; + + $.cleanData = ( function( orig ) { + return function( elems ) { + var events, elem, i; + for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) { + try { + + // Only trigger remove when necessary to save time + events = $._data( elem, "events" ); + if ( events && events.remove ) { + $( elem ).triggerHandler( "remove" ); + } + + // Http://bugs.jquery.com/ticket/8235 + } catch ( e ) {} + } + orig( elems ); + }; + } )( $.cleanData ); + + $.widget = function( name, base, prototype ) { + var existingConstructor, constructor, basePrototype; + + // ProxiedPrototype allows the provided prototype to remain unmodified + // so that it can be used as a mixin for multiple widgets (#8876) + var proxiedPrototype = {}; + + var namespace = name.split( "." )[ 0 ]; + name = name.split( "." )[ 1 ]; + var fullName = namespace + "-" + name; + + if ( !prototype ) { + prototype = base; + base = $.Widget; + } + + if ( $.isArray( prototype ) ) { + prototype = $.extend.apply( null, [ {} ].concat( prototype ) ); + } + + // Create selector for plugin + $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) { + return !!$.data( elem, fullName ); + }; + + $[ namespace ] = $[ namespace ] || {}; + existingConstructor = $[ namespace ][ name ]; + constructor = $[ namespace ][ name ] = function( options, element ) { + + // Allow instantiation without "new" keyword + if ( !this._createWidget ) { + return new constructor( options, element ); + } + + // Allow instantiation without initializing for simple inheritance + // must use "new" keyword (the code above always passes args) + if ( arguments.length ) { + this._createWidget( options, element ); + } + }; + + // Extend with the existing constructor to carry over any static properties + $.extend( constructor, existingConstructor, { + version: prototype.version, + + // Copy the object used to create the prototype in case we need to + // redefine the widget later + _proto: $.extend( {}, prototype ), + + // Track widgets that inherit from this widget in case this widget is + // redefined after a widget inherits from it + _childConstructors: [] + } ); + + basePrototype = new base(); + + // We need to make the options hash a property directly on the new instance + // otherwise we'll modify the options hash on the prototype that we're + // inheriting from + basePrototype.options = $.widget.extend( {}, basePrototype.options ); + $.each( prototype, function( prop, value ) { + if ( !$.isFunction( value ) ) { + proxiedPrototype[ prop ] = value; + return; + } + proxiedPrototype[ prop ] = ( function() { + function _super() { + return base.prototype[ prop ].apply( this, arguments ); + } + + function _superApply( args ) { + return base.prototype[ prop ].apply( this, args ); + } + + return function() { + var __super = this._super; + var __superApply = this._superApply; + var returnValue; + + this._super = _super; + this._superApply = _superApply; + + returnValue = value.apply( this, arguments ); + + this._super = __super; + this._superApply = __superApply; + + return returnValue; + }; + } )(); + } ); + constructor.prototype = $.widget.extend( basePrototype, { + + // TODO: remove support for widgetEventPrefix + // always use the name + a colon as the prefix, e.g., draggable:start + // don't prefix for widgets that aren't DOM-based + widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name + }, proxiedPrototype, { + constructor: constructor, + namespace: namespace, + widgetName: name, + widgetFullName: fullName + } ); + + // If this widget is being redefined then we need to find all widgets that + // are inheriting from it and redefine all of them so that they inherit from + // the new version of this widget. We're essentially trying to replace one + // level in the prototype chain. + if ( existingConstructor ) { + $.each( existingConstructor._childConstructors, function( i, child ) { + var childPrototype = child.prototype; + + // Redefine the child widget using the same prototype that was + // originally used, but inherit from the new version of the base + $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, + child._proto ); + } ); + + // Remove the list of existing child constructors from the old constructor + // so the old child constructors can be garbage collected + delete existingConstructor._childConstructors; + } else { + base._childConstructors.push( constructor ); + } + + $.widget.bridge( name, constructor ); + + return constructor; + }; + + $.widget.extend = function( target ) { + var input = widgetSlice.call( arguments, 1 ); + var inputIndex = 0; + var inputLength = input.length; + var key; + var value; + + for ( ; inputIndex < inputLength; inputIndex++ ) { + for ( key in input[ inputIndex ] ) { + value = input[ inputIndex ][ key ]; + if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) { + + // Clone objects + if ( $.isPlainObject( value ) ) { + target[ key ] = $.isPlainObject( target[ key ] ) ? + $.widget.extend( {}, target[ key ], value ) : + + // Don't extend strings, arrays, etc. with objects + $.widget.extend( {}, value ); + + // Copy everything else by reference + } else { + target[ key ] = value; + } + } + } + } + return target; + }; + + $.widget.bridge = function( name, object ) { + var fullName = object.prototype.widgetFullName || name; + $.fn[ name ] = function( options ) { + var isMethodCall = typeof options === "string"; + var args = widgetSlice.call( arguments, 1 ); + var returnValue = this; + + if ( isMethodCall ) { + + // If this is an empty collection, we need to have the instance method + // return undefined instead of the jQuery instance + if ( !this.length && options === "instance" ) { + returnValue = undefined; + } else { + this.each( function() { + var methodValue; + var instance = $.data( this, fullName ); + + if ( options === "instance" ) { + returnValue = instance; + return false; + } + + if ( !instance ) { + return $.error( "cannot call methods on " + name + + " prior to initialization; " + + "attempted to call method '" + options + "'" ); + } + + if ( !$.isFunction( instance[ options ] ) || options.charAt( 0 ) === "_" ) { + return $.error( "no such method '" + options + "' for " + name + + " widget instance" ); + } + + methodValue = instance[ options ].apply( instance, args ); + + if ( methodValue !== instance && methodValue !== undefined ) { + returnValue = methodValue && methodValue.jquery ? + returnValue.pushStack( methodValue.get() ) : + methodValue; + return false; + } + } ); + } + } else { + + // Allow multiple hashes to be passed on init + if ( args.length ) { + options = $.widget.extend.apply( null, [ options ].concat( args ) ); + } + + this.each( function() { + var instance = $.data( this, fullName ); + if ( instance ) { + instance.option( options || {} ); + if ( instance._init ) { + instance._init(); + } + } else { + $.data( this, fullName, new object( options, this ) ); + } + } ); + } + + return returnValue; + }; + }; + + $.Widget = function( /* options, element */ ) {}; + $.Widget._childConstructors = []; + + $.Widget.prototype = { + widgetName: "widget", + widgetEventPrefix: "", + defaultElement: "
", + + options: { + classes: {}, + disabled: false, + + // Callbacks + create: null + }, + + _createWidget: function( options, element ) { + element = $( element || this.defaultElement || this )[ 0 ]; + this.element = $( element ); + this.uuid = widgetUuid++; + this.eventNamespace = "." + this.widgetName + this.uuid; + + this.bindings = $(); + this.hoverable = $(); + this.focusable = $(); + this.classesElementLookup = {}; + + if ( element !== this ) { + $.data( element, this.widgetFullName, this ); + this._on( true, this.element, { + remove: function( event ) { + if ( event.target === element ) { + this.destroy(); + } + } + } ); + this.document = $( element.style ? + + // Element within the document + element.ownerDocument : + + // Element is window or document + element.document || element ); + this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow ); + } + + this.options = $.widget.extend( {}, + this.options, + this._getCreateOptions(), + options ); + + this._create(); + + if ( this.options.disabled ) { + this._setOptionDisabled( this.options.disabled ); + } + + this._trigger( "create", null, this._getCreateEventData() ); + this._init(); + }, + + _getCreateOptions: function() { + return {}; + }, + + _getCreateEventData: $.noop, + + _create: $.noop, + + _init: $.noop, + + destroy: function() { + var that = this; + + this._destroy(); + $.each( this.classesElementLookup, function( key, value ) { + that._removeClass( value, key ); + } ); + + // We can probably remove the unbind calls in 2.0 + // all event bindings should go through this._on() + this.element + .off( this.eventNamespace ) + .removeData( this.widgetFullName ); + this.widget() + .off( this.eventNamespace ) + .removeAttr( "aria-disabled" ); + + // Clean up events and states + this.bindings.off( this.eventNamespace ); + }, + + _destroy: $.noop, + + widget: function() { + return this.element; + }, + + option: function( key, value ) { + var options = key; + var parts; + var curOption; + var i; + + if ( arguments.length === 0 ) { + + // Don't return a reference to the internal hash + return $.widget.extend( {}, this.options ); + } + + if ( typeof key === "string" ) { + + // Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } } + options = {}; + parts = key.split( "." ); + key = parts.shift(); + if ( parts.length ) { + curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] ); + for ( i = 0; i < parts.length - 1; i++ ) { + curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {}; + curOption = curOption[ parts[ i ] ]; + } + key = parts.pop(); + if ( arguments.length === 1 ) { + return curOption[ key ] === undefined ? null : curOption[ key ]; + } + curOption[ key ] = value; + } else { + if ( arguments.length === 1 ) { + return this.options[ key ] === undefined ? null : this.options[ key ]; + } + options[ key ] = value; + } + } + + this._setOptions( options ); + + return this; + }, + + _setOptions: function( options ) { + var key; + + for ( key in options ) { + this._setOption( key, options[ key ] ); + } + + return this; + }, + + _setOption: function( key, value ) { + if ( key === "classes" ) { + this._setOptionClasses( value ); + } + + this.options[ key ] = value; + + if ( key === "disabled" ) { + this._setOptionDisabled( value ); + } + + return this; + }, + + _setOptionClasses: function( value ) { + var classKey, elements, currentElements; + + for ( classKey in value ) { + currentElements = this.classesElementLookup[ classKey ]; + if ( value[ classKey ] === this.options.classes[ classKey ] || + !currentElements || + !currentElements.length ) { + continue; + } + + // We are doing this to create a new jQuery object because the _removeClass() call + // on the next line is going to destroy the reference to the current elements being + // tracked. We need to save a copy of this collection so that we can add the new classes + // below. + elements = $( currentElements.get() ); + this._removeClass( currentElements, classKey ); + + // We don't use _addClass() here, because that uses this.options.classes + // for generating the string of classes. We want to use the value passed in from + // _setOption(), this is the new value of the classes option which was passed to + // _setOption(). We pass this value directly to _classes(). + elements.addClass( this._classes( { + element: elements, + keys: classKey, + classes: value, + add: true + } ) ); + } + }, + + _setOptionDisabled: function( value ) { + this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value ); + + // If the widget is becoming disabled, then nothing is interactive + if ( value ) { + this._removeClass( this.hoverable, null, "ui-state-hover" ); + this._removeClass( this.focusable, null, "ui-state-focus" ); + } + }, + + enable: function() { + return this._setOptions( { disabled: false } ); + }, + + disable: function() { + return this._setOptions( { disabled: true } ); + }, + + _classes: function( options ) { + var full = []; + var that = this; + + options = $.extend( { + element: this.element, + classes: this.options.classes || {} + }, options ); + + function processClassString( classes, checkOption ) { + var current, i; + for ( i = 0; i < classes.length; i++ ) { + current = that.classesElementLookup[ classes[ i ] ] || $(); + if ( options.add ) { + current = $( $.unique( current.get().concat( options.element.get() ) ) ); + } else { + current = $( current.not( options.element ).get() ); + } + that.classesElementLookup[ classes[ i ] ] = current; + full.push( classes[ i ] ); + if ( checkOption && options.classes[ classes[ i ] ] ) { + full.push( options.classes[ classes[ i ] ] ); + } + } + } + + this._on( options.element, { + "remove": "_untrackClassesElement" + } ); + + if ( options.keys ) { + processClassString( options.keys.match( /\S+/g ) || [], true ); + } + if ( options.extra ) { + processClassString( options.extra.match( /\S+/g ) || [] ); + } + + return full.join( " " ); + }, + + _untrackClassesElement: function( event ) { + var that = this; + $.each( that.classesElementLookup, function( key, value ) { + if ( $.inArray( event.target, value ) !== -1 ) { + that.classesElementLookup[ key ] = $( value.not( event.target ).get() ); + } + } ); + }, + + _removeClass: function( element, keys, extra ) { + return this._toggleClass( element, keys, extra, false ); + }, + + _addClass: function( element, keys, extra ) { + return this._toggleClass( element, keys, extra, true ); + }, + + _toggleClass: function( element, keys, extra, add ) { + add = ( typeof add === "boolean" ) ? add : extra; + var shift = ( typeof element === "string" || element === null ), + options = { + extra: shift ? keys : extra, + keys: shift ? element : keys, + element: shift ? this.element : element, + add: add + }; + options.element.toggleClass( this._classes( options ), add ); + return this; + }, + + _on: function( suppressDisabledCheck, element, handlers ) { + var delegateElement; + var instance = this; + + // No suppressDisabledCheck flag, shuffle arguments + if ( typeof suppressDisabledCheck !== "boolean" ) { + handlers = element; + element = suppressDisabledCheck; + suppressDisabledCheck = false; + } + + // No element argument, shuffle and use this.element + if ( !handlers ) { + handlers = element; + element = this.element; + delegateElement = this.widget(); + } else { + element = delegateElement = $( element ); + this.bindings = this.bindings.add( element ); + } + + $.each( handlers, function( event, handler ) { + function handlerProxy() { + + // Allow widgets to customize the disabled handling + // - disabled as an array instead of boolean + // - disabled class as method for disabling individual parts + if ( !suppressDisabledCheck && + ( instance.options.disabled === true || + $( this ).hasClass( "ui-state-disabled" ) ) ) { + return; + } + return ( typeof handler === "string" ? instance[ handler ] : handler ) + .apply( instance, arguments ); + } + + // Copy the guid so direct unbinding works + if ( typeof handler !== "string" ) { + handlerProxy.guid = handler.guid = + handler.guid || handlerProxy.guid || $.guid++; + } + + var match = event.match( /^([\w:-]*)\s*(.*)$/ ); + var eventName = match[ 1 ] + instance.eventNamespace; + var selector = match[ 2 ]; + + if ( selector ) { + delegateElement.on( eventName, selector, handlerProxy ); + } else { + element.on( eventName, handlerProxy ); + } + } ); + }, + + _off: function( element, eventName ) { + eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) + + this.eventNamespace; + element.off( eventName ).off( eventName ); + + // Clear the stack to avoid memory leaks (#10056) + this.bindings = $( this.bindings.not( element ).get() ); + this.focusable = $( this.focusable.not( element ).get() ); + this.hoverable = $( this.hoverable.not( element ).get() ); + }, + + _delay: function( handler, delay ) { + function handlerProxy() { + return ( typeof handler === "string" ? instance[ handler ] : handler ) + .apply( instance, arguments ); + } + var instance = this; + return setTimeout( handlerProxy, delay || 0 ); + }, + + _hoverable: function( element ) { + this.hoverable = this.hoverable.add( element ); + this._on( element, { + mouseenter: function( event ) { + this._addClass( $( event.currentTarget ), null, "ui-state-hover" ); + }, + mouseleave: function( event ) { + this._removeClass( $( event.currentTarget ), null, "ui-state-hover" ); + } + } ); + }, + + _focusable: function( element ) { + this.focusable = this.focusable.add( element ); + this._on( element, { + focusin: function( event ) { + this._addClass( $( event.currentTarget ), null, "ui-state-focus" ); + }, + focusout: function( event ) { + this._removeClass( $( event.currentTarget ), null, "ui-state-focus" ); + } + } ); + }, + + _trigger: function( type, event, data ) { + var prop, orig; + var callback = this.options[ type ]; + + data = data || {}; + event = $.Event( event ); + event.type = ( type === this.widgetEventPrefix ? + type : + this.widgetEventPrefix + type ).toLowerCase(); + + // The original event may come from any element + // so we need to reset the target on the new event + event.target = this.element[ 0 ]; + + // Copy original event properties over to the new event + orig = event.originalEvent; + if ( orig ) { + for ( prop in orig ) { + if ( !( prop in event ) ) { + event[ prop ] = orig[ prop ]; + } + } + } + + this.element.trigger( event, data ); + return !( $.isFunction( callback ) && + callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false || + event.isDefaultPrevented() ); + } + }; + + $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) { + $.Widget.prototype[ "_" + method ] = function( element, options, callback ) { + if ( typeof options === "string" ) { + options = { effect: options }; + } + + var hasOptions; + var effectName = !options ? + method : + options === true || typeof options === "number" ? + defaultEffect : + options.effect || defaultEffect; + + options = options || {}; + if ( typeof options === "number" ) { + options = { duration: options }; + } + + hasOptions = !$.isEmptyObject( options ); + options.complete = callback; + + if ( options.delay ) { + element.delay( options.delay ); + } + + if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) { + element[ method ]( options ); + } else if ( effectName !== method && element[ effectName ] ) { + element[ effectName ]( options.duration, options.easing, callback ); + } else { + element.queue( function( next ) { + $( this )[ method ](); + if ( callback ) { + callback.call( element[ 0 ] ); + } + next(); + } ); + } + }; + } ); + + var widget = $.widget; + + + + +})); diff --git a/node_modules/blueimp-file-upload/package.json b/node_modules/blueimp-file-upload/package.json new file mode 100644 index 000000000..ebaf51037 --- /dev/null +++ b/node_modules/blueimp-file-upload/package.json @@ -0,0 +1,55 @@ +{ + "name": "blueimp-file-upload", + "version": "9.22.1", + "title": "jQuery File Upload", + "description": "File Upload widget with multiple file selection, drag&drop support, progress bar, validation and preview images, audio and video for jQuery. Supports cross-domain, chunked and resumable file uploads. Works with any server-side platform (Google App Engine, PHP, Python, Ruby on Rails, Java, etc.) that supports standard HTML form file uploads.", + "keywords": [ + "jquery", + "file", + "upload", + "widget", + "multiple", + "selection", + "drag", + "drop", + "progress", + "preview", + "cross-domain", + "cross-site", + "chunk", + "resume", + "gae", + "go", + "python", + "php", + "bootstrap" + ], + "homepage": "https://github.com/blueimp/jQuery-File-Upload", + "author": { + "name": "Sebastian Tschan", + "url": "https://blueimp.net" + }, + "repository": { + "type": "git", + "url": "git://github.com/blueimp/jQuery-File-Upload.git" + }, + "license": "MIT", + "optionalDependencies": { + "blueimp-canvas-to-blob": "3.5.0", + "blueimp-load-image": "2.12.2", + "blueimp-tmpl": "3.6.0" + }, + "devDependencies": { + "bower-json": "0.8.1", + "jshint": "2.9.3" + }, + "scripts": { + "bower-version-update": "./bower-version-update.js", + "lint": "jshint *.js js/*.js js/cors/*.js", + "test": "npm run lint", + "preversion": "npm test", + "version": "npm run bower-version-update && git add bower.json", + "postversion": "git push --tags origin master && npm publish" + }, + "main": "js/jquery.fileupload.js" +} diff --git a/node_modules/blueimp-load-image/README.md b/node_modules/blueimp-load-image/README.md new file mode 100644 index 000000000..2a03e0b5f --- /dev/null +++ b/node_modules/blueimp-load-image/README.md @@ -0,0 +1,326 @@ +# JavaScript Load Image + +> A JavaScript library to load and transform image files. + +## Table of contents + +- [Demo](#demo) +- [Description](#description) +- [Setup](#setup) +- [Usage](#usage) +- [Image loading](#image-loading) +- [Image scaling](#image-scaling) +- [Requirements](#requirements) +- [API](#api) +- [Options](#options) +- [Meta data parsing](#meta-data-parsing) +- [Exif parser](#exif-parser) +- [License](#license) +- [Credits](#credits) + +## Demo +[JavaScript Load Image Demo](https://blueimp.github.io/JavaScript-Load-Image/) + +## Description +JavaScript Load Image is a library to load images provided as File or Blob +objects or via URL. +It returns an optionally scaled and/or cropped HTML img or canvas element via an +asynchronous callback. +It also provides a method to parse image meta data to extract Exif tags and +thumbnails and to restore the complete image header after resizing. + +## Setup +Include the (combined and minified) JavaScript Load Image script in your HTML +markup: + +```html + +``` + +Or alternatively, choose which components you want to include: + +```html + + + + + + + +``` + +## Usage + +### Image loading +In your application code, use the **loadImage()** function like this: + +```js +document.getElementById('file-input').onchange = function (e) { + loadImage( + e.target.files[0], + function (img) { + document.body.appendChild(img); + }, + {maxWidth: 600} // Options + ); +}; +``` + +### Image scaling +It is also possible to use the image scaling functionality with an existing +image: + +```js +var scaledImage = loadImage.scale( + img, // img or canvas element + {maxWidth: 600} +); +``` + +## Requirements +The JavaScript Load Image library has zero dependencies. + +However, JavaScript Load Image is a very suitable complement to the +[Canvas to Blob](https://github.com/blueimp/JavaScript-Canvas-to-Blob) library. + +## API +The **loadImage()** function accepts a +[File](https://developer.mozilla.org/en/DOM/File) or +[Blob](https://developer.mozilla.org/en/DOM/Blob) object or a simple image URL +(e.g. `'https://example.org/image.png'`) as first argument. + +If a [File](https://developer.mozilla.org/en/DOM/File) or +[Blob](https://developer.mozilla.org/en/DOM/Blob) is passed as parameter, it +returns a HTML **img** element if the browser supports the +[URL](https://developer.mozilla.org/en/DOM/window.URL) API or a +[FileReader](https://developer.mozilla.org/en/DOM/FileReader) object if +supported, or **false**. +It always returns a HTML +[img](https://developer.mozilla.org/en/docs/HTML/Element/Img) element when +passing an image URL: + +```js +document.getElementById('file-input').onchange = function (e) { + var loadingImage = loadImage( + e.target.files[0], + function (img) { + document.body.appendChild(img); + }, + {maxWidth: 600} + ); + if (!loadingImage) { + // Alternative code ... + } +}; +``` + +The **img** element or +[FileReader](https://developer.mozilla.org/en/DOM/FileReader) object returned by +the **loadImage()** function allows to abort the loading process by setting the +**onload** and **onerror** event handlers to null: + +```js +document.getElementById('file-input').onchange = function (e) { + var loadingImage = loadImage( + e.target.files[0], + function (img) { + document.body.appendChild(img); + }, + {maxWidth: 600} + ); + loadingImage.onload = loadingImage.onerror = null; +}; +``` + +The second argument must be a **callback** function, which is called when the +image has been loaded or an error occurred while loading the image. The callback +function is passed one argument, which is either a HTML **img** element, a +[canvas](https://developer.mozilla.org/en/HTML/Canvas) element, or an +[Event](https://developer.mozilla.org/en/DOM/event) object of type **error**: + +```js +var imageUrl = "https://example.org/image.png"; +loadImage( + imageUrl, + function (img) { + if(img.type === "error") { + console.log("Error loading image " + imageUrl); + } else { + document.body.appendChild(img); + } + }, + {maxWidth: 600} +); +``` + +## Options +The optional third argument to **loadImage()** is a map of options: + +* **maxWidth**: Defines the maximum width of the img/canvas element. +* **maxHeight**: Defines the maximum height of the img/canvas element. +* **minWidth**: Defines the minimum width of the img/canvas element. +* **minHeight**: Defines the minimum height of the img/canvas element. +* **sourceWidth**: The width of the sub-rectangle of the source image to draw +into the destination canvas. +Defaults to the source image width and requires `canvas: true`. +* **sourceHeight**: The height of the sub-rectangle of the source image to draw +into the destination canvas. +Defaults to the source image height and requires `canvas: true`. +* **top**: The top margin of the sub-rectangle of the source image. +Defaults to `0` and requires `canvas: true`. +* **right**: The right margin of the sub-rectangle of the source image. +Defaults to `0` and requires `canvas: true`. +* **bottom**: The bottom margin of the sub-rectangle of the source image. +Defaults to `0` and requires `canvas: true`. +* **left**: The left margin of the sub-rectangle of the source image. +Defaults to `0` and requires `canvas: true`. +* **contain**: Scales the image up/down to contain it in the max dimensions if +set to `true`. +This emulates the CSS feature +[background-image: contain](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Scaling_background_images#contain). +* **cover**: Scales the image up/down to cover the max dimensions with the image +dimensions if set to `true`. +This emulates the CSS feature +[background-image: cover](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Scaling_background_images#cover). +* **aspectRatio**: Crops the image to the given aspect ratio (e.g. `16/9`). +Setting the `aspectRatio` also enables the `crop` option. +* **pixelRatio**: Defines the ratio of the canvas pixels to the physical image +pixels on the screen. +Should be set to `window.devicePixelRatio` unless the scaled image is not +rendered on screen. +Defaults to `1` and requires `canvas: true`. +* **downsamplingRatio**: Defines the ratio in which the image is downsampled. +By default, images are downsampled in one step. With a ratio of `0.5`, each step +scales the image to half the size, before reaching the target dimensions. +Requires `canvas: true`. +* **crop**: Crops the image to the maxWidth/maxHeight constraints if set to +`true`. +Enabling the `crop` option also enables the `canvas` option. +* **orientation**: Transform the canvas according to the specified Exif +orientation, which can be an `integer` in the range of `1` to `8` or the boolean +value `true`. +When set to `true`, it will set the orientation value based on the EXIF data of +the image, which will be parsed automatically if the exif library is available. +Setting the `orientation` also enables the `canvas` option. +Setting `orientation` to `true` also enables the `meta` option. +* **meta**: Automatically parses the image meta data if set to `true`. +The meta data is passed to the callback as second argument. +If the file is given as URL and the browser supports the +[fetch API](https://developer.mozilla.org/en/docs/Web/API/Fetch_API), fetches +the file as Blob to be able to parse the meta data. +* **canvas**: Returns the image as +[canvas](https://developer.mozilla.org/en/HTML/Canvas) element if set to `true`. +* **crossOrigin**: Sets the crossOrigin property on the img element for loading +[CORS enabled images](https://developer.mozilla.org/en-US/docs/HTML/CORS_Enabled_Image). +* **noRevoke**: By default, the +[created object URL](https://developer.mozilla.org/en/DOM/window.URL.createObjectURL) +is revoked after the image has been loaded, except when this option is set to +`true`. + +They can be used the following way: + +```js +loadImage( + fileOrBlobOrUrl, + function (img) { + document.body.appendChild(img); + }, + { + maxWidth: 600, + maxHeight: 300, + minWidth: 100, + minHeight: 50, + canvas: true + } +); +``` + +All settings are optional. By default, the image is returned as HTML **img** +element without any image size restrictions. + +## Meta data parsing +If the Load Image Meta extension is included, it is also possible to parse image +meta data. +The extension provides the method **loadImage.parseMetaData**, which can be used +the following way: + +```js +loadImage.parseMetaData( + fileOrBlob, + function (data) { + if (!data.imageHead) { + return; + } + // Combine data.imageHead with the image body of a resized file + // to create scaled images with the original image meta data, e.g.: + var blob = new Blob([ + data.imageHead, + // Resized images always have a head size of 20 bytes, + // including the JPEG marker and a minimal JFIF header: + loadImage.blobSlice.call(resizedImage, 20) + ], {type: resizedImage.type}); + }, + { + maxMetaDataSize: 262144, + disableImageHead: false + } +); +``` + +The third argument is an options object which defines the maximum number of +bytes to parse for the image meta data, allows to disable the imageHead creation +and is also passed along to segment parsers registered via loadImage extensions, +e.g. the Exif parser. + +**Note:** +Blob objects of resized images can be created via +[canvas.toBlob()](https://github.com/blueimp/JavaScript-Canvas-to-Blob). + +### Exif parser +If you include the Load Image Exif Parser extension, the argument passed to the +callback for **parseMetaData** will contain the additional property **exif** if +Exif data could be found in the given image. +The **exif** object stores the parsed Exif tags: + +```js +var orientation = data.exif[0x0112]; +``` + +It also provides an **exif.get()** method to retrieve the tag value via the +tag's mapped name: + +```js +var orientation = data.exif.get('Orientation'); +``` + +By default, the only available mapped names are **Orientation** and +**Thumbnail**. +If you also include the Load Image Exif Map library, additional tag mappings +become available, as well as two additional methods, **exif.getText()** and +**exif.getAll()**: + +```js +var flashText = data.exif.getText('Flash'); // e.g.: 'Flash fired, auto mode', + +// A map of all parsed tags with their mapped names as keys and their text values: +var allTags = data.exif.getAll(); +``` + +The Exif parser also adds additional options for the parseMetaData method, to +disable certain aspects of the parser: + +* **disableExif**: Disables Exif parsing. +* **disableExifThumbnail**: Disables parsing of the Exif Thumbnail. +* **disableExifSub**: Disables parsing of the Exif Sub IFD. +* **disableExifGps**: Disables parsing of the Exif GPS Info IFD. + +## License +The JavaScript Load Image script is released under the +[MIT license](https://opensource.org/licenses/MIT). + +## Credits + +* Image meta data handling implementation based on the help and contribution of +Achim Stöhr. +* Exif tags mapping based on Jacob Seidelin's +[exif-js](https://github.com/jseidelin/exif-js). diff --git a/node_modules/blueimp-load-image/js/index.js b/node_modules/blueimp-load-image/js/index.js new file mode 100644 index 000000000..6cb50d03c --- /dev/null +++ b/node_modules/blueimp-load-image/js/index.js @@ -0,0 +1,8 @@ +module.exports = require('./load-image') + +require('./load-image-scale') +require('./load-image-meta') +require('./load-image-fetch') +require('./load-image-exif') +require('./load-image-exif-map') +require('./load-image-orientation') diff --git a/node_modules/blueimp-load-image/js/load-image-exif-map.js b/node_modules/blueimp-load-image/js/load-image-exif-map.js new file mode 100644 index 000000000..fcbc4d282 --- /dev/null +++ b/node_modules/blueimp-load-image/js/load-image-exif-map.js @@ -0,0 +1,387 @@ +/* + * JavaScript Load Image Exif Map + * https://github.com/blueimp/JavaScript-Load-Image + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Exif tags mapping based on + * https://github.com/jseidelin/exif-js + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* global define */ + +;(function (factory) { + 'use strict' + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define(['./load-image', './load-image-exif'], factory) + } else if (typeof module === 'object' && module.exports) { + factory(require('./load-image'), require('./load-image-exif')) + } else { + // Browser globals: + factory(window.loadImage) + } +}(function (loadImage) { + 'use strict' + + loadImage.ExifMap.prototype.tags = { + // ================= + // TIFF tags (IFD0): + // ================= + 0x0100: 'ImageWidth', + 0x0101: 'ImageHeight', + 0x8769: 'ExifIFDPointer', + 0x8825: 'GPSInfoIFDPointer', + 0xA005: 'InteroperabilityIFDPointer', + 0x0102: 'BitsPerSample', + 0x0103: 'Compression', + 0x0106: 'PhotometricInterpretation', + 0x0112: 'Orientation', + 0x0115: 'SamplesPerPixel', + 0x011C: 'PlanarConfiguration', + 0x0212: 'YCbCrSubSampling', + 0x0213: 'YCbCrPositioning', + 0x011A: 'XResolution', + 0x011B: 'YResolution', + 0x0128: 'ResolutionUnit', + 0x0111: 'StripOffsets', + 0x0116: 'RowsPerStrip', + 0x0117: 'StripByteCounts', + 0x0201: 'JPEGInterchangeFormat', + 0x0202: 'JPEGInterchangeFormatLength', + 0x012D: 'TransferFunction', + 0x013E: 'WhitePoint', + 0x013F: 'PrimaryChromaticities', + 0x0211: 'YCbCrCoefficients', + 0x0214: 'ReferenceBlackWhite', + 0x0132: 'DateTime', + 0x010E: 'ImageDescription', + 0x010F: 'Make', + 0x0110: 'Model', + 0x0131: 'Software', + 0x013B: 'Artist', + 0x8298: 'Copyright', + // ================== + // Exif Sub IFD tags: + // ================== + 0x9000: 'ExifVersion', // EXIF version + 0xA000: 'FlashpixVersion', // Flashpix format version + 0xA001: 'ColorSpace', // Color space information tag + 0xA002: 'PixelXDimension', // Valid width of meaningful image + 0xA003: 'PixelYDimension', // Valid height of meaningful image + 0xA500: 'Gamma', + 0x9101: 'ComponentsConfiguration', // Information about channels + 0x9102: 'CompressedBitsPerPixel', // Compressed bits per pixel + 0x927C: 'MakerNote', // Any desired information written by the manufacturer + 0x9286: 'UserComment', // Comments by user + 0xA004: 'RelatedSoundFile', // Name of related sound file + 0x9003: 'DateTimeOriginal', // Date and time when the original image was generated + 0x9004: 'DateTimeDigitized', // Date and time when the image was stored digitally + 0x9290: 'SubSecTime', // Fractions of seconds for DateTime + 0x9291: 'SubSecTimeOriginal', // Fractions of seconds for DateTimeOriginal + 0x9292: 'SubSecTimeDigitized', // Fractions of seconds for DateTimeDigitized + 0x829A: 'ExposureTime', // Exposure time (in seconds) + 0x829D: 'FNumber', + 0x8822: 'ExposureProgram', // Exposure program + 0x8824: 'SpectralSensitivity', // Spectral sensitivity + 0x8827: 'PhotographicSensitivity', // EXIF 2.3, ISOSpeedRatings in EXIF 2.2 + 0x8828: 'OECF', // Optoelectric conversion factor + 0x8830: 'SensitivityType', + 0x8831: 'StandardOutputSensitivity', + 0x8832: 'RecommendedExposureIndex', + 0x8833: 'ISOSpeed', + 0x8834: 'ISOSpeedLatitudeyyy', + 0x8835: 'ISOSpeedLatitudezzz', + 0x9201: 'ShutterSpeedValue', // Shutter speed + 0x9202: 'ApertureValue', // Lens aperture + 0x9203: 'BrightnessValue', // Value of brightness + 0x9204: 'ExposureBias', // Exposure bias + 0x9205: 'MaxApertureValue', // Smallest F number of lens + 0x9206: 'SubjectDistance', // Distance to subject in meters + 0x9207: 'MeteringMode', // Metering mode + 0x9208: 'LightSource', // Kind of light source + 0x9209: 'Flash', // Flash status + 0x9214: 'SubjectArea', // Location and area of main subject + 0x920A: 'FocalLength', // Focal length of the lens in mm + 0xA20B: 'FlashEnergy', // Strobe energy in BCPS + 0xA20C: 'SpatialFrequencyResponse', + 0xA20E: 'FocalPlaneXResolution', // Number of pixels in width direction per FPRUnit + 0xA20F: 'FocalPlaneYResolution', // Number of pixels in height direction per FPRUnit + 0xA210: 'FocalPlaneResolutionUnit', // Unit for measuring the focal plane resolution + 0xA214: 'SubjectLocation', // Location of subject in image + 0xA215: 'ExposureIndex', // Exposure index selected on camera + 0xA217: 'SensingMethod', // Image sensor type + 0xA300: 'FileSource', // Image source (3 == DSC) + 0xA301: 'SceneType', // Scene type (1 == directly photographed) + 0xA302: 'CFAPattern', // Color filter array geometric pattern + 0xA401: 'CustomRendered', // Special processing + 0xA402: 'ExposureMode', // Exposure mode + 0xA403: 'WhiteBalance', // 1 = auto white balance, 2 = manual + 0xA404: 'DigitalZoomRatio', // Digital zoom ratio + 0xA405: 'FocalLengthIn35mmFilm', + 0xA406: 'SceneCaptureType', // Type of scene + 0xA407: 'GainControl', // Degree of overall image gain adjustment + 0xA408: 'Contrast', // Direction of contrast processing applied by camera + 0xA409: 'Saturation', // Direction of saturation processing applied by camera + 0xA40A: 'Sharpness', // Direction of sharpness processing applied by camera + 0xA40B: 'DeviceSettingDescription', + 0xA40C: 'SubjectDistanceRange', // Distance to subject + 0xA420: 'ImageUniqueID', // Identifier assigned uniquely to each image + 0xA430: 'CameraOwnerName', + 0xA431: 'BodySerialNumber', + 0xA432: 'LensSpecification', + 0xA433: 'LensMake', + 0xA434: 'LensModel', + 0xA435: 'LensSerialNumber', + // ============== + // GPS Info tags: + // ============== + 0x0000: 'GPSVersionID', + 0x0001: 'GPSLatitudeRef', + 0x0002: 'GPSLatitude', + 0x0003: 'GPSLongitudeRef', + 0x0004: 'GPSLongitude', + 0x0005: 'GPSAltitudeRef', + 0x0006: 'GPSAltitude', + 0x0007: 'GPSTimeStamp', + 0x0008: 'GPSSatellites', + 0x0009: 'GPSStatus', + 0x000A: 'GPSMeasureMode', + 0x000B: 'GPSDOP', + 0x000C: 'GPSSpeedRef', + 0x000D: 'GPSSpeed', + 0x000E: 'GPSTrackRef', + 0x000F: 'GPSTrack', + 0x0010: 'GPSImgDirectionRef', + 0x0011: 'GPSImgDirection', + 0x0012: 'GPSMapDatum', + 0x0013: 'GPSDestLatitudeRef', + 0x0014: 'GPSDestLatitude', + 0x0015: 'GPSDestLongitudeRef', + 0x0016: 'GPSDestLongitude', + 0x0017: 'GPSDestBearingRef', + 0x0018: 'GPSDestBearing', + 0x0019: 'GPSDestDistanceRef', + 0x001A: 'GPSDestDistance', + 0x001B: 'GPSProcessingMethod', + 0x001C: 'GPSAreaInformation', + 0x001D: 'GPSDateStamp', + 0x001E: 'GPSDifferential', + 0x001F: 'GPSHPositioningError' + } + + loadImage.ExifMap.prototype.stringValues = { + ExposureProgram: { + 0: 'Undefined', + 1: 'Manual', + 2: 'Normal program', + 3: 'Aperture priority', + 4: 'Shutter priority', + 5: 'Creative program', + 6: 'Action program', + 7: 'Portrait mode', + 8: 'Landscape mode' + }, + MeteringMode: { + 0: 'Unknown', + 1: 'Average', + 2: 'CenterWeightedAverage', + 3: 'Spot', + 4: 'MultiSpot', + 5: 'Pattern', + 6: 'Partial', + 255: 'Other' + }, + LightSource: { + 0: 'Unknown', + 1: 'Daylight', + 2: 'Fluorescent', + 3: 'Tungsten (incandescent light)', + 4: 'Flash', + 9: 'Fine weather', + 10: 'Cloudy weather', + 11: 'Shade', + 12: 'Daylight fluorescent (D 5700 - 7100K)', + 13: 'Day white fluorescent (N 4600 - 5400K)', + 14: 'Cool white fluorescent (W 3900 - 4500K)', + 15: 'White fluorescent (WW 3200 - 3700K)', + 17: 'Standard light A', + 18: 'Standard light B', + 19: 'Standard light C', + 20: 'D55', + 21: 'D65', + 22: 'D75', + 23: 'D50', + 24: 'ISO studio tungsten', + 255: 'Other' + }, + Flash: { + 0x0000: 'Flash did not fire', + 0x0001: 'Flash fired', + 0x0005: 'Strobe return light not detected', + 0x0007: 'Strobe return light detected', + 0x0009: 'Flash fired, compulsory flash mode', + 0x000D: 'Flash fired, compulsory flash mode, return light not detected', + 0x000F: 'Flash fired, compulsory flash mode, return light detected', + 0x0010: 'Flash did not fire, compulsory flash mode', + 0x0018: 'Flash did not fire, auto mode', + 0x0019: 'Flash fired, auto mode', + 0x001D: 'Flash fired, auto mode, return light not detected', + 0x001F: 'Flash fired, auto mode, return light detected', + 0x0020: 'No flash function', + 0x0041: 'Flash fired, red-eye reduction mode', + 0x0045: 'Flash fired, red-eye reduction mode, return light not detected', + 0x0047: 'Flash fired, red-eye reduction mode, return light detected', + 0x0049: 'Flash fired, compulsory flash mode, red-eye reduction mode', + 0x004D: 'Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected', + 0x004F: 'Flash fired, compulsory flash mode, red-eye reduction mode, return light detected', + 0x0059: 'Flash fired, auto mode, red-eye reduction mode', + 0x005D: 'Flash fired, auto mode, return light not detected, red-eye reduction mode', + 0x005F: 'Flash fired, auto mode, return light detected, red-eye reduction mode' + }, + SensingMethod: { + 1: 'Undefined', + 2: 'One-chip color area sensor', + 3: 'Two-chip color area sensor', + 4: 'Three-chip color area sensor', + 5: 'Color sequential area sensor', + 7: 'Trilinear sensor', + 8: 'Color sequential linear sensor' + }, + SceneCaptureType: { + 0: 'Standard', + 1: 'Landscape', + 2: 'Portrait', + 3: 'Night scene' + }, + SceneType: { + 1: 'Directly photographed' + }, + CustomRendered: { + 0: 'Normal process', + 1: 'Custom process' + }, + WhiteBalance: { + 0: 'Auto white balance', + 1: 'Manual white balance' + }, + GainControl: { + 0: 'None', + 1: 'Low gain up', + 2: 'High gain up', + 3: 'Low gain down', + 4: 'High gain down' + }, + Contrast: { + 0: 'Normal', + 1: 'Soft', + 2: 'Hard' + }, + Saturation: { + 0: 'Normal', + 1: 'Low saturation', + 2: 'High saturation' + }, + Sharpness: { + 0: 'Normal', + 1: 'Soft', + 2: 'Hard' + }, + SubjectDistanceRange: { + 0: 'Unknown', + 1: 'Macro', + 2: 'Close view', + 3: 'Distant view' + }, + FileSource: { + 3: 'DSC' + }, + ComponentsConfiguration: { + 0: '', + 1: 'Y', + 2: 'Cb', + 3: 'Cr', + 4: 'R', + 5: 'G', + 6: 'B' + }, + Orientation: { + 1: 'top-left', + 2: 'top-right', + 3: 'bottom-right', + 4: 'bottom-left', + 5: 'left-top', + 6: 'right-top', + 7: 'right-bottom', + 8: 'left-bottom' + } + } + + loadImage.ExifMap.prototype.getText = function (id) { + var value = this.get(id) + switch (id) { + case 'LightSource': + case 'Flash': + case 'MeteringMode': + case 'ExposureProgram': + case 'SensingMethod': + case 'SceneCaptureType': + case 'SceneType': + case 'CustomRendered': + case 'WhiteBalance': + case 'GainControl': + case 'Contrast': + case 'Saturation': + case 'Sharpness': + case 'SubjectDistanceRange': + case 'FileSource': + case 'Orientation': + return this.stringValues[id][value] + case 'ExifVersion': + case 'FlashpixVersion': + if (!value) return + return String.fromCharCode(value[0], value[1], value[2], value[3]) + case 'ComponentsConfiguration': + if (!value) return + return this.stringValues[id][value[0]] + + this.stringValues[id][value[1]] + + this.stringValues[id][value[2]] + + this.stringValues[id][value[3]] + case 'GPSVersionID': + if (!value) return + return value[0] + '.' + value[1] + '.' + value[2] + '.' + value[3] + } + return String(value) + } + + ;(function (exifMapPrototype) { + var tags = exifMapPrototype.tags + var map = exifMapPrototype.map + var prop + // Map the tag names to tags: + for (prop in tags) { + if (tags.hasOwnProperty(prop)) { + map[tags[prop]] = prop + } + } + }(loadImage.ExifMap.prototype)) + + loadImage.ExifMap.prototype.getAll = function () { + var map = {} + var prop + var id + for (prop in this) { + if (this.hasOwnProperty(prop)) { + id = this.tags[prop] + if (id) { + map[id] = this.getText(id) + } + } + } + return map + } +})) diff --git a/node_modules/blueimp-load-image/js/load-image-exif.js b/node_modules/blueimp-load-image/js/load-image-exif.js new file mode 100644 index 000000000..f16dd9a5d --- /dev/null +++ b/node_modules/blueimp-load-image/js/load-image-exif.js @@ -0,0 +1,300 @@ +/* + * JavaScript Load Image Exif Parser + * https://github.com/blueimp/JavaScript-Load-Image + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* global define */ + +;(function (factory) { + 'use strict' + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define(['./load-image', './load-image-meta'], factory) + } else if (typeof module === 'object' && module.exports) { + factory(require('./load-image'), require('./load-image-meta')) + } else { + // Browser globals: + factory(window.loadImage) + } +}(function (loadImage) { + 'use strict' + + loadImage.ExifMap = function () { + return this + } + + loadImage.ExifMap.prototype.map = { + 'Orientation': 0x0112 + } + + loadImage.ExifMap.prototype.get = function (id) { + return this[id] || this[this.map[id]] + } + + loadImage.getExifThumbnail = function (dataView, offset, length) { + var hexData, + i, + b + if (!length || offset + length > dataView.byteLength) { + console.log('Invalid Exif data: Invalid thumbnail data.') + return + } + hexData = [] + for (i = 0; i < length; i += 1) { + b = dataView.getUint8(offset + i) + hexData.push((b < 16 ? '0' : '') + b.toString(16)) + } + return 'data:image/jpeg,%' + hexData.join('%') + } + + loadImage.exifTagTypes = { + // byte, 8-bit unsigned int: + 1: { + getValue: function (dataView, dataOffset) { + return dataView.getUint8(dataOffset) + }, + size: 1 + }, + // ascii, 8-bit byte: + 2: { + getValue: function (dataView, dataOffset) { + return String.fromCharCode(dataView.getUint8(dataOffset)) + }, + size: 1, + ascii: true + }, + // short, 16 bit int: + 3: { + getValue: function (dataView, dataOffset, littleEndian) { + return dataView.getUint16(dataOffset, littleEndian) + }, + size: 2 + }, + // long, 32 bit int: + 4: { + getValue: function (dataView, dataOffset, littleEndian) { + return dataView.getUint32(dataOffset, littleEndian) + }, + size: 4 + }, + // rational = two long values, first is numerator, second is denominator: + 5: { + getValue: function (dataView, dataOffset, littleEndian) { + return dataView.getUint32(dataOffset, littleEndian) / + dataView.getUint32(dataOffset + 4, littleEndian) + }, + size: 8 + }, + // slong, 32 bit signed int: + 9: { + getValue: function (dataView, dataOffset, littleEndian) { + return dataView.getInt32(dataOffset, littleEndian) + }, + size: 4 + }, + // srational, two slongs, first is numerator, second is denominator: + 10: { + getValue: function (dataView, dataOffset, littleEndian) { + return dataView.getInt32(dataOffset, littleEndian) / + dataView.getInt32(dataOffset + 4, littleEndian) + }, + size: 8 + } + } + // undefined, 8-bit byte, value depending on field: + loadImage.exifTagTypes[7] = loadImage.exifTagTypes[1] + + loadImage.getExifValue = function (dataView, tiffOffset, offset, type, length, littleEndian) { + var tagType = loadImage.exifTagTypes[type] + var tagSize + var dataOffset + var values + var i + var str + var c + if (!tagType) { + console.log('Invalid Exif data: Invalid tag type.') + return + } + tagSize = tagType.size * length + // Determine if the value is contained in the dataOffset bytes, + // or if the value at the dataOffset is a pointer to the actual data: + dataOffset = tagSize > 4 + ? tiffOffset + dataView.getUint32(offset + 8, littleEndian) + : (offset + 8) + if (dataOffset + tagSize > dataView.byteLength) { + console.log('Invalid Exif data: Invalid data offset.') + return + } + if (length === 1) { + return tagType.getValue(dataView, dataOffset, littleEndian) + } + values = [] + for (i = 0; i < length; i += 1) { + values[i] = tagType.getValue(dataView, dataOffset + i * tagType.size, littleEndian) + } + if (tagType.ascii) { + str = '' + // Concatenate the chars: + for (i = 0; i < values.length; i += 1) { + c = values[i] + // Ignore the terminating NULL byte(s): + if (c === '\u0000') { + break + } + str += c + } + return str + } + return values + } + + loadImage.parseExifTag = function (dataView, tiffOffset, offset, littleEndian, data) { + var tag = dataView.getUint16(offset, littleEndian) + data.exif[tag] = loadImage.getExifValue( + dataView, + tiffOffset, + offset, + dataView.getUint16(offset + 2, littleEndian), // tag type + dataView.getUint32(offset + 4, littleEndian), // tag length + littleEndian + ) + } + + loadImage.parseExifTags = function (dataView, tiffOffset, dirOffset, littleEndian, data) { + var tagsNumber, + dirEndOffset, + i + if (dirOffset + 6 > dataView.byteLength) { + console.log('Invalid Exif data: Invalid directory offset.') + return + } + tagsNumber = dataView.getUint16(dirOffset, littleEndian) + dirEndOffset = dirOffset + 2 + 12 * tagsNumber + if (dirEndOffset + 4 > dataView.byteLength) { + console.log('Invalid Exif data: Invalid directory size.') + return + } + for (i = 0; i < tagsNumber; i += 1) { + this.parseExifTag( + dataView, + tiffOffset, + dirOffset + 2 + 12 * i, // tag offset + littleEndian, + data + ) + } + // Return the offset to the next directory: + return dataView.getUint32(dirEndOffset, littleEndian) + } + + loadImage.parseExifData = function (dataView, offset, length, data, options) { + if (options.disableExif) { + return + } + var tiffOffset = offset + 10 + var littleEndian + var dirOffset + var thumbnailData + // Check for the ASCII code for "Exif" (0x45786966): + if (dataView.getUint32(offset + 4) !== 0x45786966) { + // No Exif data, might be XMP data instead + return + } + if (tiffOffset + 8 > dataView.byteLength) { + console.log('Invalid Exif data: Invalid segment size.') + return + } + // Check for the two null bytes: + if (dataView.getUint16(offset + 8) !== 0x0000) { + console.log('Invalid Exif data: Missing byte alignment offset.') + return + } + // Check the byte alignment: + switch (dataView.getUint16(tiffOffset)) { + case 0x4949: + littleEndian = true + break + case 0x4D4D: + littleEndian = false + break + default: + console.log('Invalid Exif data: Invalid byte alignment marker.') + return + } + // Check for the TIFF tag marker (0x002A): + if (dataView.getUint16(tiffOffset + 2, littleEndian) !== 0x002A) { + console.log('Invalid Exif data: Missing TIFF marker.') + return + } + // Retrieve the directory offset bytes, usually 0x00000008 or 8 decimal: + dirOffset = dataView.getUint32(tiffOffset + 4, littleEndian) + // Create the exif object to store the tags: + data.exif = new loadImage.ExifMap() + // Parse the tags of the main image directory and retrieve the + // offset to the next directory, usually the thumbnail directory: + dirOffset = loadImage.parseExifTags( + dataView, + tiffOffset, + tiffOffset + dirOffset, + littleEndian, + data + ) + if (dirOffset && !options.disableExifThumbnail) { + thumbnailData = {exif: {}} + dirOffset = loadImage.parseExifTags( + dataView, + tiffOffset, + tiffOffset + dirOffset, + littleEndian, + thumbnailData + ) + // Check for JPEG Thumbnail offset: + if (thumbnailData.exif[0x0201]) { + data.exif.Thumbnail = loadImage.getExifThumbnail( + dataView, + tiffOffset + thumbnailData.exif[0x0201], + thumbnailData.exif[0x0202] // Thumbnail data length + ) + } + } + // Check for Exif Sub IFD Pointer: + if (data.exif[0x8769] && !options.disableExifSub) { + loadImage.parseExifTags( + dataView, + tiffOffset, + tiffOffset + data.exif[0x8769], // directory offset + littleEndian, + data + ) + } + // Check for GPS Info IFD Pointer: + if (data.exif[0x8825] && !options.disableExifGps) { + loadImage.parseExifTags( + dataView, + tiffOffset, + tiffOffset + data.exif[0x8825], // directory offset + littleEndian, + data + ) + } + } + + // Registers the Exif parser for the APP1 JPEG meta data segment: + loadImage.metaDataParsers.jpeg[0xffe1].push(loadImage.parseExifData) + + // Adds the following properties to the parseMetaData callback data: + // * exif: The exif tags, parsed by the parseExifData method + + // Adds the following options to the parseMetaData method: + // * disableExif: Disables Exif parsing. + // * disableExifThumbnail: Disables parsing of the Exif Thumbnail. + // * disableExifSub: Disables parsing of the Exif Sub IFD. + // * disableExifGps: Disables parsing of the Exif GPS Info IFD. +})) diff --git a/node_modules/blueimp-load-image/js/load-image-fetch.js b/node_modules/blueimp-load-image/js/load-image-fetch.js new file mode 100644 index 000000000..9ca1ccd5c --- /dev/null +++ b/node_modules/blueimp-load-image/js/load-image-fetch.js @@ -0,0 +1,42 @@ +/* + * JavaScript Load Image Fetch + * https://github.com/blueimp/JavaScript-Load-Image + * + * Copyright 2017, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* global define, fetch, Request */ + +;(function (factory) { + 'use strict' + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define(['./load-image', './load-image-meta'], factory) + } else if (typeof module === 'object' && module.exports) { + factory(require('./load-image'), require('./load-image-meta')) + } else { + // Browser globals: + factory(window.loadImage) + } +}(function (loadImage) { + 'use strict' + + if ('fetch' in window && 'Request' in window) { + loadImage.fetchBlob = function (url, callback, options) { + if (loadImage.hasMetaOption(options)) { + return fetch(new Request(url, options)).then(function (response) { + return response.blob() + }).then(callback).catch(function (err) { + console.log(err) + callback() + }) + } else { + callback() + } + } + } +})) diff --git a/node_modules/blueimp-load-image/js/load-image-meta.js b/node_modules/blueimp-load-image/js/load-image-meta.js new file mode 100644 index 000000000..fc76958cc --- /dev/null +++ b/node_modules/blueimp-load-image/js/load-image-meta.js @@ -0,0 +1,159 @@ +/* + * JavaScript Load Image Meta + * https://github.com/blueimp/JavaScript-Load-Image + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Image meta data handling implementation + * based on the help and contribution of + * Achim Stöhr. + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* global define, Blob */ + +;(function (factory) { + 'use strict' + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define(['./load-image'], factory) + } else if (typeof module === 'object' && module.exports) { + factory(require('./load-image')) + } else { + // Browser globals: + factory(window.loadImage) + } +}(function (loadImage) { + 'use strict' + + var hasblobSlice = window.Blob && (Blob.prototype.slice || + Blob.prototype.webkitSlice || Blob.prototype.mozSlice) + + loadImage.blobSlice = hasblobSlice && function () { + var slice = this.slice || this.webkitSlice || this.mozSlice + return slice.apply(this, arguments) + } + + loadImage.metaDataParsers = { + jpeg: { + 0xffe1: [] // APP1 marker + } + } + + // Parses image meta data and calls the callback with an object argument + // with the following properties: + // * imageHead: The complete image head as ArrayBuffer (Uint8Array for IE10) + // The options arguments accepts an object and supports the following properties: + // * maxMetaDataSize: Defines the maximum number of bytes to parse. + // * disableImageHead: Disables creating the imageHead property. + loadImage.parseMetaData = function (file, callback, options, data) { + options = options || {} + data = data || {} + var that = this + // 256 KiB should contain all EXIF/ICC/IPTC segments: + var maxMetaDataSize = options.maxMetaDataSize || 262144 + var noMetaData = !(window.DataView && file && file.size >= 12 && + file.type === 'image/jpeg' && loadImage.blobSlice) + if (noMetaData || !loadImage.readFile( + loadImage.blobSlice.call(file, 0, maxMetaDataSize), + function (e) { + if (e.target.error) { + // FileReader error + console.log(e.target.error) + callback(data) + return + } + // Note on endianness: + // Since the marker and length bytes in JPEG files are always + // stored in big endian order, we can leave the endian parameter + // of the DataView methods undefined, defaulting to big endian. + var buffer = e.target.result + var dataView = new DataView(buffer) + var offset = 2 + var maxOffset = dataView.byteLength - 4 + var headLength = offset + var markerBytes + var markerLength + var parsers + var i + // Check for the JPEG marker (0xffd8): + if (dataView.getUint16(0) === 0xffd8) { + while (offset < maxOffset) { + markerBytes = dataView.getUint16(offset) + // Search for APPn (0xffeN) and COM (0xfffe) markers, + // which contain application-specific meta-data like + // Exif, ICC and IPTC data and text comments: + if ((markerBytes >= 0xffe0 && markerBytes <= 0xffef) || + markerBytes === 0xfffe) { + // The marker bytes (2) are always followed by + // the length bytes (2), indicating the length of the + // marker segment, which includes the length bytes, + // but not the marker bytes, so we add 2: + markerLength = dataView.getUint16(offset + 2) + 2 + if (offset + markerLength > dataView.byteLength) { + console.log('Invalid meta data: Invalid segment size.') + break + } + parsers = loadImage.metaDataParsers.jpeg[markerBytes] + if (parsers) { + for (i = 0; i < parsers.length; i += 1) { + parsers[i].call( + that, + dataView, + offset, + markerLength, + data, + options + ) + } + } + offset += markerLength + headLength = offset + } else { + // Not an APPn or COM marker, probably safe to + // assume that this is the end of the meta data + break + } + } + // Meta length must be longer than JPEG marker (2) + // plus APPn marker (2), followed by length bytes (2): + if (!options.disableImageHead && headLength > 6) { + if (buffer.slice) { + data.imageHead = buffer.slice(0, headLength) + } else { + // Workaround for IE10, which does not yet + // support ArrayBuffer.slice: + data.imageHead = new Uint8Array(buffer) + .subarray(0, headLength) + } + } + } else { + console.log('Invalid JPEG file: Missing JPEG marker.') + } + callback(data) + }, + 'readAsArrayBuffer' + )) { + callback(data) + } + } + + // Determines if meta data should be loaded automatically: + loadImage.hasMetaOption = function (options) { + return options && options.meta + } + + var originalTransform = loadImage.transform + loadImage.transform = function (img, options, callback, file, data) { + if (loadImage.hasMetaOption(options)) { + loadImage.parseMetaData(file, function (data) { + originalTransform.call(loadImage, img, options, callback, file, data) + }, options, data) + } else { + originalTransform.apply(loadImage, arguments) + } + } +})) diff --git a/node_modules/blueimp-load-image/js/load-image-orientation.js b/node_modules/blueimp-load-image/js/load-image-orientation.js new file mode 100644 index 000000000..c4fb94fac --- /dev/null +++ b/node_modules/blueimp-load-image/js/load-image-orientation.js @@ -0,0 +1,185 @@ +/* + * JavaScript Load Image Orientation + * https://github.com/blueimp/JavaScript-Load-Image + * + * Copyright 2013, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* global define */ + +;(function (factory) { + 'use strict' + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define(['./load-image', './load-image-scale', './load-image-meta'], factory) + } else if (typeof module === 'object' && module.exports) { + factory( + require('./load-image'), + require('./load-image-scale'), + require('./load-image-meta') + ) + } else { + // Browser globals: + factory(window.loadImage) + } +}(function (loadImage) { + 'use strict' + + var originalHasCanvasOption = loadImage.hasCanvasOption + var originalHasMetaOption = loadImage.hasMetaOption + var originalTransformCoordinates = loadImage.transformCoordinates + var originalGetTransformedOptions = loadImage.getTransformedOptions + + // Determines if the target image should be a canvas element: + loadImage.hasCanvasOption = function (options) { + return !!options.orientation || + originalHasCanvasOption.call(loadImage, options) + } + + // Determines if meta data should be loaded automatically: + loadImage.hasMetaOption = function (options) { + return options && options.orientation === true || + originalHasMetaOption.call(loadImage, options) + } + + // Transform image orientation based on + // the given EXIF orientation option: + loadImage.transformCoordinates = function (canvas, options) { + originalTransformCoordinates.call(loadImage, canvas, options) + var ctx = canvas.getContext('2d') + var width = canvas.width + var height = canvas.height + var styleWidth = canvas.style.width + var styleHeight = canvas.style.height + var orientation = options.orientation + if (!orientation || orientation > 8) { + return + } + if (orientation > 4) { + canvas.width = height + canvas.height = width + canvas.style.width = styleHeight + canvas.style.height = styleWidth + } + switch (orientation) { + case 2: + // horizontal flip + ctx.translate(width, 0) + ctx.scale(-1, 1) + break + case 3: + // 180° rotate left + ctx.translate(width, height) + ctx.rotate(Math.PI) + break + case 4: + // vertical flip + ctx.translate(0, height) + ctx.scale(1, -1) + break + case 5: + // vertical flip + 90 rotate right + ctx.rotate(0.5 * Math.PI) + ctx.scale(1, -1) + break + case 6: + // 90° rotate right + ctx.rotate(0.5 * Math.PI) + ctx.translate(0, -height) + break + case 7: + // horizontal flip + 90 rotate right + ctx.rotate(0.5 * Math.PI) + ctx.translate(width, -height) + ctx.scale(-1, 1) + break + case 8: + // 90° rotate left + ctx.rotate(-0.5 * Math.PI) + ctx.translate(-width, 0) + break + } + } + + // Transforms coordinate and dimension options + // based on the given orientation option: + loadImage.getTransformedOptions = function (img, opts, data) { + var options = originalGetTransformedOptions.call(loadImage, img, opts) + var orientation = options.orientation + var newOptions + var i + if (orientation === true && data && data.exif) { + orientation = data.exif.get('Orientation') + } + if (!orientation || orientation > 8 || orientation === 1) { + return options + } + newOptions = {} + for (i in options) { + if (options.hasOwnProperty(i)) { + newOptions[i] = options[i] + } + } + newOptions.orientation = orientation + switch (orientation) { + case 2: + // horizontal flip + newOptions.left = options.right + newOptions.right = options.left + break + case 3: + // 180° rotate left + newOptions.left = options.right + newOptions.top = options.bottom + newOptions.right = options.left + newOptions.bottom = options.top + break + case 4: + // vertical flip + newOptions.top = options.bottom + newOptions.bottom = options.top + break + case 5: + // vertical flip + 90 rotate right + newOptions.left = options.top + newOptions.top = options.left + newOptions.right = options.bottom + newOptions.bottom = options.right + break + case 6: + // 90° rotate right + newOptions.left = options.top + newOptions.top = options.right + newOptions.right = options.bottom + newOptions.bottom = options.left + break + case 7: + // horizontal flip + 90 rotate right + newOptions.left = options.bottom + newOptions.top = options.right + newOptions.right = options.top + newOptions.bottom = options.left + break + case 8: + // 90° rotate left + newOptions.left = options.bottom + newOptions.top = options.left + newOptions.right = options.top + newOptions.bottom = options.right + break + } + if (newOptions.orientation > 4) { + newOptions.maxWidth = options.maxHeight + newOptions.maxHeight = options.maxWidth + newOptions.minWidth = options.minHeight + newOptions.minHeight = options.minWidth + newOptions.sourceWidth = options.sourceHeight + newOptions.sourceHeight = options.sourceWidth + } + return newOptions + } +})) diff --git a/node_modules/blueimp-load-image/js/load-image-scale.js b/node_modules/blueimp-load-image/js/load-image-scale.js new file mode 100644 index 000000000..aaaebeb28 --- /dev/null +++ b/node_modules/blueimp-load-image/js/load-image-scale.js @@ -0,0 +1,282 @@ +/* + * JavaScript Load Image Scaling + * https://github.com/blueimp/JavaScript-Load-Image + * + * Copyright 2011, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* global define */ + +;(function (factory) { + 'use strict' + if (typeof define === 'function' && define.amd) { + // Register as an anonymous AMD module: + define(['./load-image'], factory) + } else if (typeof module === 'object' && module.exports) { + factory(require('./load-image')) + } else { + // Browser globals: + factory(window.loadImage) + } +}(function (loadImage) { + 'use strict' + + var originalTransform = loadImage.transform + + loadImage.transform = function (img, options, callback, file, data) { + originalTransform.call( + loadImage, + loadImage.scale(img, options, data), + options, + callback, + file, + data + ) + } + + // Transform image coordinates, allows to override e.g. + // the canvas orientation based on the orientation option, + // gets canvas, options passed as arguments: + loadImage.transformCoordinates = function () { + return + } + + // Returns transformed options, allows to override e.g. + // maxWidth, maxHeight and crop options based on the aspectRatio. + // gets img, options passed as arguments: + loadImage.getTransformedOptions = function (img, options) { + var aspectRatio = options.aspectRatio + var newOptions + var i + var width + var height + if (!aspectRatio) { + return options + } + newOptions = {} + for (i in options) { + if (options.hasOwnProperty(i)) { + newOptions[i] = options[i] + } + } + newOptions.crop = true + width = img.naturalWidth || img.width + height = img.naturalHeight || img.height + if (width / height > aspectRatio) { + newOptions.maxWidth = height * aspectRatio + newOptions.maxHeight = height + } else { + newOptions.maxWidth = width + newOptions.maxHeight = width / aspectRatio + } + return newOptions + } + + // Canvas render method, allows to implement a different rendering algorithm: + loadImage.renderImageToCanvas = function ( + canvas, + img, + sourceX, + sourceY, + sourceWidth, + sourceHeight, + destX, + destY, + destWidth, + destHeight + ) { + canvas.getContext('2d').drawImage( + img, + sourceX, + sourceY, + sourceWidth, + sourceHeight, + destX, + destY, + destWidth, + destHeight + ) + return canvas + } + + // Determines if the target image should be a canvas element: + loadImage.hasCanvasOption = function (options) { + return options.canvas || options.crop || !!options.aspectRatio + } + + // Scales and/or crops the given image (img or canvas HTML element) + // using the given options. + // Returns a canvas object if the browser supports canvas + // and the hasCanvasOption method returns true or a canvas + // object is passed as image, else the scaled image: + loadImage.scale = function (img, options, data) { + options = options || {} + var canvas = document.createElement('canvas') + var useCanvas = img.getContext || + (loadImage.hasCanvasOption(options) && canvas.getContext) + var width = img.naturalWidth || img.width + var height = img.naturalHeight || img.height + var destWidth = width + var destHeight = height + var maxWidth + var maxHeight + var minWidth + var minHeight + var sourceWidth + var sourceHeight + var sourceX + var sourceY + var pixelRatio + var downsamplingRatio + var tmp + function scaleUp () { + var scale = Math.max( + (minWidth || destWidth) / destWidth, + (minHeight || destHeight) / destHeight + ) + if (scale > 1) { + destWidth *= scale + destHeight *= scale + } + } + function scaleDown () { + var scale = Math.min( + (maxWidth || destWidth) / destWidth, + (maxHeight || destHeight) / destHeight + ) + if (scale < 1) { + destWidth *= scale + destHeight *= scale + } + } + if (useCanvas) { + options = loadImage.getTransformedOptions(img, options, data) + sourceX = options.left || 0 + sourceY = options.top || 0 + if (options.sourceWidth) { + sourceWidth = options.sourceWidth + if (options.right !== undefined && options.left === undefined) { + sourceX = width - sourceWidth - options.right + } + } else { + sourceWidth = width - sourceX - (options.right || 0) + } + if (options.sourceHeight) { + sourceHeight = options.sourceHeight + if (options.bottom !== undefined && options.top === undefined) { + sourceY = height - sourceHeight - options.bottom + } + } else { + sourceHeight = height - sourceY - (options.bottom || 0) + } + destWidth = sourceWidth + destHeight = sourceHeight + } + maxWidth = options.maxWidth + maxHeight = options.maxHeight + minWidth = options.minWidth + minHeight = options.minHeight + if (useCanvas && maxWidth && maxHeight && options.crop) { + destWidth = maxWidth + destHeight = maxHeight + tmp = sourceWidth / sourceHeight - maxWidth / maxHeight + if (tmp < 0) { + sourceHeight = maxHeight * sourceWidth / maxWidth + if (options.top === undefined && options.bottom === undefined) { + sourceY = (height - sourceHeight) / 2 + } + } else if (tmp > 0) { + sourceWidth = maxWidth * sourceHeight / maxHeight + if (options.left === undefined && options.right === undefined) { + sourceX = (width - sourceWidth) / 2 + } + } + } else { + if (options.contain || options.cover) { + minWidth = maxWidth = maxWidth || minWidth + minHeight = maxHeight = maxHeight || minHeight + } + if (options.cover) { + scaleDown() + scaleUp() + } else { + scaleUp() + scaleDown() + } + } + if (useCanvas) { + pixelRatio = options.pixelRatio + if (pixelRatio > 1) { + canvas.style.width = destWidth + 'px' + canvas.style.height = destHeight + 'px' + destWidth *= pixelRatio + destHeight *= pixelRatio + canvas.getContext('2d').scale(pixelRatio, pixelRatio) + } + downsamplingRatio = options.downsamplingRatio + if (downsamplingRatio > 0 && downsamplingRatio < 1 && + destWidth < sourceWidth && destHeight < sourceHeight) { + while (sourceWidth * downsamplingRatio > destWidth) { + canvas.width = sourceWidth * downsamplingRatio + canvas.height = sourceHeight * downsamplingRatio + loadImage.renderImageToCanvas( + canvas, + img, + sourceX, + sourceY, + sourceWidth, + sourceHeight, + 0, + 0, + canvas.width, + canvas.height + ) + sourceX = 0 + sourceY = 0 + sourceWidth = canvas.width + sourceHeight = canvas.height + img = document.createElement('canvas') + img.width = sourceWidth + img.height = sourceHeight + loadImage.renderImageToCanvas( + img, + canvas, + 0, + 0, + sourceWidth, + sourceHeight, + 0, + 0, + sourceWidth, + sourceHeight + ) + } + } + canvas.width = destWidth + canvas.height = destHeight + loadImage.transformCoordinates( + canvas, + options + ) + return loadImage.renderImageToCanvas( + canvas, + img, + sourceX, + sourceY, + sourceWidth, + sourceHeight, + 0, + 0, + destWidth, + destHeight + ) + } + img.width = destWidth + img.height = destHeight + return img + } +})) diff --git a/node_modules/blueimp-load-image/js/load-image.all.min.js b/node_modules/blueimp-load-image/js/load-image.all.min.js new file mode 100644 index 000000000..ee6718444 --- /dev/null +++ b/node_modules/blueimp-load-image/js/load-image.all.min.js @@ -0,0 +1,2 @@ +!function(e){"use strict";function t(e,i,o){var a,n=document.createElement("img");return n.onerror=function(a){return t.onerror(n,a,e,i,o)},n.onload=function(a){return t.onload(n,a,e,i,o)},"string"==typeof e?(t.fetchBlob(e,function(i){i?(e=i,a=t.createObjectURL(e)):(a=e,o&&o.crossOrigin&&(n.crossOrigin=o.crossOrigin)),n.src=a},o),n):t.isInstanceOf("Blob",e)||t.isInstanceOf("File",e)?(a=n._objectURL=t.createObjectURL(e),a?(n.src=a,n):t.readFile(e,function(e){var t=e.target;t&&t.result?n.src=t.result:i&&i(e)})):void 0}function i(e,i){!e._objectURL||i&&i.noRevoke||(t.revokeObjectURL(e._objectURL),delete e._objectURL)}var o=window.createObjectURL&&window||window.URL&&URL.revokeObjectURL&&URL||window.webkitURL&&webkitURL;t.fetchBlob=function(e,t,i){t()},t.isInstanceOf=function(e,t){return Object.prototype.toString.call(t)==="[object "+e+"]"},t.transform=function(e,t,i,o,a){i(e,a)},t.onerror=function(e,t,o,a,n){i(e,n),a&&a.call(e,t)},t.onload=function(e,o,a,n,r){i(e,r),n&&t.transform(e,r,n,a,{})},t.createObjectURL=function(e){return!!o&&o.createObjectURL(e)},t.revokeObjectURL=function(e){return!!o&&o.revokeObjectURL(e)},t.readFile=function(e,t,i){if(window.FileReader){var o=new FileReader;if(o.onload=o.onerror=t,i=i||"readAsDataURL",o[i])return o[i](e),o}return!1},"function"==typeof define&&define.amd?define(function(){return t}):"object"==typeof module&&module.exports?module.exports=t:e.loadImage=t}(window),function(e){"use strict";"function"==typeof define&&define.amd?define(["./load-image"],e):e("object"==typeof module&&module.exports?require("./load-image"):window.loadImage)}(function(e){"use strict";var t=e.transform;e.transform=function(i,o,a,n,r){t.call(e,e.scale(i,o,r),o,a,n,r)},e.transformCoordinates=function(){},e.getTransformedOptions=function(e,t){var i,o,a,n,r=t.aspectRatio;if(!r)return t;i={};for(o in t)t.hasOwnProperty(o)&&(i[o]=t[o]);return i.crop=!0,a=e.naturalWidth||e.width,n=e.naturalHeight||e.height,a/n>r?(i.maxWidth=n*r,i.maxHeight=n):(i.maxWidth=a,i.maxHeight=a/r),i},e.renderImageToCanvas=function(e,t,i,o,a,n,r,s,l,d){return e.getContext("2d").drawImage(t,i,o,a,n,r,s,l,d),e},e.hasCanvasOption=function(e){return e.canvas||e.crop||!!e.aspectRatio},e.scale=function(t,i,o){function a(){var e=Math.max((l||v)/v,(d||w)/w);e>1&&(v*=e,w*=e)}function n(){var e=Math.min((r||v)/v,(s||w)/w);e<1&&(v*=e,w*=e)}i=i||{};var r,s,l,d,c,u,f,g,h,m,p,S=document.createElement("canvas"),b=t.getContext||e.hasCanvasOption(i)&&S.getContext,x=t.naturalWidth||t.width,y=t.naturalHeight||t.height,v=x,w=y;if(b&&(i=e.getTransformedOptions(t,i,o),f=i.left||0,g=i.top||0,i.sourceWidth?(c=i.sourceWidth,void 0!==i.right&&void 0===i.left&&(f=x-c-i.right)):c=x-f-(i.right||0),i.sourceHeight?(u=i.sourceHeight,void 0!==i.bottom&&void 0===i.top&&(g=y-u-i.bottom)):u=y-g-(i.bottom||0),v=c,w=u),r=i.maxWidth,s=i.maxHeight,l=i.minWidth,d=i.minHeight,b&&r&&s&&i.crop?(v=r,w=s,p=c/u-r/s,p<0?(u=s*c/r,void 0===i.top&&void 0===i.bottom&&(g=(y-u)/2)):p>0&&(c=r*u/s,void 0===i.left&&void 0===i.right&&(f=(x-c)/2))):((i.contain||i.cover)&&(l=r=r||l,d=s=s||d),i.cover?(n(),a()):(a(),n())),b){if(h=i.pixelRatio,h>1&&(S.style.width=v+"px",S.style.height=w+"px",v*=h,w*=h,S.getContext("2d").scale(h,h)),m=i.downsamplingRatio,m>0&&m<1&&vv;)S.width=c*m,S.height=u*m,e.renderImageToCanvas(S,t,f,g,c,u,0,0,S.width,S.height),f=0,g=0,c=S.width,u=S.height,t=document.createElement("canvas"),t.width=c,t.height=u,e.renderImageToCanvas(t,S,0,0,c,u,0,0,c,u);return S.width=v,S.height=w,e.transformCoordinates(S,i),e.renderImageToCanvas(S,t,f,g,c,u,0,0,v,w)}return t.width=v,t.height=w,t}}),function(e){"use strict";"function"==typeof define&&define.amd?define(["./load-image"],e):e("object"==typeof module&&module.exports?require("./load-image"):window.loadImage)}(function(e){"use strict";var t=window.Blob&&(Blob.prototype.slice||Blob.prototype.webkitSlice||Blob.prototype.mozSlice);e.blobSlice=t&&function(){var e=this.slice||this.webkitSlice||this.mozSlice;return e.apply(this,arguments)},e.metaDataParsers={jpeg:{65505:[]}},e.parseMetaData=function(t,i,o,a){o=o||{},a=a||{};var n=this,r=o.maxMetaDataSize||262144,s=!(window.DataView&&t&&t.size>=12&&"image/jpeg"===t.type&&e.blobSlice);!s&&e.readFile(e.blobSlice.call(t,0,r),function(t){if(t.target.error)return console.log(t.target.error),void i(a);var r,s,l,d,c=t.target.result,u=new DataView(c),f=2,g=u.byteLength-4,h=f;if(65496===u.getUint16(0)){for(;f=65504&&r<=65519||65534===r);){if(s=u.getUint16(f+2)+2,f+s>u.byteLength){console.log("Invalid meta data: Invalid segment size.");break}if(l=e.metaDataParsers.jpeg[r])for(d=0;d6&&(c.slice?a.imageHead=c.slice(0,h):a.imageHead=new Uint8Array(c).subarray(0,h))}else console.log("Invalid JPEG file: Missing JPEG marker.");i(a)},"readAsArrayBuffer")||i(a)},e.hasMetaOption=function(e){return e&&e.meta};var i=e.transform;e.transform=function(t,o,a,n,r){e.hasMetaOption(o)?e.parseMetaData(n,function(r){i.call(e,t,o,a,n,r)},o,r):i.apply(e,arguments)}}),function(e){"use strict";"function"==typeof define&&define.amd?define(["./load-image","./load-image-meta"],e):"object"==typeof module&&module.exports?e(require("./load-image"),require("./load-image-meta")):e(window.loadImage)}(function(e){"use strict";"fetch"in window&&"Request"in window&&(e.fetchBlob=function(t,i,o){return e.hasMetaOption(o)?fetch(new Request(t,o)).then(function(e){return e.blob()}).then(i).catch(function(e){console.log(e),i()}):void i()})}),function(e){"use strict";"function"==typeof define&&define.amd?define(["./load-image","./load-image-meta"],e):"object"==typeof module&&module.exports?e(require("./load-image"),require("./load-image-meta")):e(window.loadImage)}(function(e){"use strict";e.ExifMap=function(){return this},e.ExifMap.prototype.map={Orientation:274},e.ExifMap.prototype.get=function(e){return this[e]||this[this.map[e]]},e.getExifThumbnail=function(e,t,i){var o,a,n;if(!i||t+i>e.byteLength)return void console.log("Invalid Exif data: Invalid thumbnail data.");for(o=[],a=0;a4?i+t.getUint32(o+8,r):o+8,l+s>t.byteLength)return void console.log("Invalid Exif data: Invalid data offset.");if(1===n)return g.getValue(t,l,r);for(d=[],c=0;ce.byteLength)return void console.log("Invalid Exif data: Invalid directory offset.");if(n=e.getUint16(i,o),r=i+2+12*n,r+4>e.byteLength)return void console.log("Invalid Exif data: Invalid directory size.");for(s=0;st.byteLength)return void console.log("Invalid Exif data: Invalid segment size.");if(0!==t.getUint16(i+8))return void console.log("Invalid Exif data: Missing byte alignment offset.");switch(t.getUint16(d)){case 18761:r=!0;break;case 19789:r=!1;break;default:return void console.log("Invalid Exif data: Invalid byte alignment marker.")}if(42!==t.getUint16(d+2,r))return void console.log("Invalid Exif data: Missing TIFF marker.");s=t.getUint32(d+4,r),a.exif=new e.ExifMap,s=e.parseExifTags(t,d,d+s,r,a),s&&!n.disableExifThumbnail&&(l={exif:{}},s=e.parseExifTags(t,d,d+s,r,l),l.exif[513]&&(a.exif.Thumbnail=e.getExifThumbnail(t,d+l.exif[513],l.exif[514]))),a.exif[34665]&&!n.disableExifSub&&e.parseExifTags(t,d,d+a.exif[34665],r,a),a.exif[34853]&&!n.disableExifGps&&e.parseExifTags(t,d,d+a.exif[34853],r,a)}}},e.metaDataParsers.jpeg[65505].push(e.parseExifData)}),function(e){"use strict";"function"==typeof define&&define.amd?define(["./load-image","./load-image-exif"],e):"object"==typeof module&&module.exports?e(require("./load-image"),require("./load-image-exif")):e(window.loadImage)}(function(e){"use strict";e.ExifMap.prototype.tags={256:"ImageWidth",257:"ImageHeight",34665:"ExifIFDPointer",34853:"GPSInfoIFDPointer",40965:"InteroperabilityIFDPointer",258:"BitsPerSample",259:"Compression",262:"PhotometricInterpretation",274:"Orientation",277:"SamplesPerPixel",284:"PlanarConfiguration",530:"YCbCrSubSampling",531:"YCbCrPositioning",282:"XResolution",283:"YResolution",296:"ResolutionUnit",273:"StripOffsets",278:"RowsPerStrip",279:"StripByteCounts",513:"JPEGInterchangeFormat",514:"JPEGInterchangeFormatLength",301:"TransferFunction",318:"WhitePoint",319:"PrimaryChromaticities",529:"YCbCrCoefficients",532:"ReferenceBlackWhite",306:"DateTime",270:"ImageDescription",271:"Make",272:"Model",305:"Software",315:"Artist",33432:"Copyright",36864:"ExifVersion",40960:"FlashpixVersion",40961:"ColorSpace",40962:"PixelXDimension",40963:"PixelYDimension",42240:"Gamma",37121:"ComponentsConfiguration",37122:"CompressedBitsPerPixel",37500:"MakerNote",37510:"UserComment",40964:"RelatedSoundFile",36867:"DateTimeOriginal",36868:"DateTimeDigitized",37520:"SubSecTime",37521:"SubSecTimeOriginal",37522:"SubSecTimeDigitized",33434:"ExposureTime",33437:"FNumber",34850:"ExposureProgram",34852:"SpectralSensitivity",34855:"PhotographicSensitivity",34856:"OECF",34864:"SensitivityType",34865:"StandardOutputSensitivity",34866:"RecommendedExposureIndex",34867:"ISOSpeed",34868:"ISOSpeedLatitudeyyy",34869:"ISOSpeedLatitudezzz",37377:"ShutterSpeedValue",37378:"ApertureValue",37379:"BrightnessValue",37380:"ExposureBias",37381:"MaxApertureValue",37382:"SubjectDistance",37383:"MeteringMode",37384:"LightSource",37385:"Flash",37396:"SubjectArea",37386:"FocalLength",41483:"FlashEnergy",41484:"SpatialFrequencyResponse",41486:"FocalPlaneXResolution",41487:"FocalPlaneYResolution",41488:"FocalPlaneResolutionUnit",41492:"SubjectLocation",41493:"ExposureIndex",41495:"SensingMethod",41728:"FileSource",41729:"SceneType",41730:"CFAPattern",41985:"CustomRendered",41986:"ExposureMode",41987:"WhiteBalance",41988:"DigitalZoomRatio",41989:"FocalLengthIn35mmFilm",41990:"SceneCaptureType",41991:"GainControl",41992:"Contrast",41993:"Saturation",41994:"Sharpness",41995:"DeviceSettingDescription",41996:"SubjectDistanceRange",42016:"ImageUniqueID",42032:"CameraOwnerName",42033:"BodySerialNumber",42034:"LensSpecification",42035:"LensMake",42036:"LensModel",42037:"LensSerialNumber",0:"GPSVersionID",1:"GPSLatitudeRef",2:"GPSLatitude",3:"GPSLongitudeRef",4:"GPSLongitude",5:"GPSAltitudeRef",6:"GPSAltitude",7:"GPSTimeStamp",8:"GPSSatellites",9:"GPSStatus",10:"GPSMeasureMode",11:"GPSDOP",12:"GPSSpeedRef",13:"GPSSpeed",14:"GPSTrackRef",15:"GPSTrack",16:"GPSImgDirectionRef",17:"GPSImgDirection",18:"GPSMapDatum",19:"GPSDestLatitudeRef",20:"GPSDestLatitude",21:"GPSDestLongitudeRef",22:"GPSDestLongitude",23:"GPSDestBearingRef",24:"GPSDestBearing",25:"GPSDestDistanceRef",26:"GPSDestDistance",27:"GPSProcessingMethod",28:"GPSAreaInformation",29:"GPSDateStamp",30:"GPSDifferential",31:"GPSHPositioningError"},e.ExifMap.prototype.stringValues={ExposureProgram:{0:"Undefined",1:"Manual",2:"Normal program",3:"Aperture priority",4:"Shutter priority",5:"Creative program",6:"Action program",7:"Portrait mode",8:"Landscape mode"},MeteringMode:{0:"Unknown",1:"Average",2:"CenterWeightedAverage",3:"Spot",4:"MultiSpot",5:"Pattern",6:"Partial",255:"Other"},LightSource:{0:"Unknown",1:"Daylight",2:"Fluorescent",3:"Tungsten (incandescent light)",4:"Flash",9:"Fine weather",10:"Cloudy weather",11:"Shade",12:"Daylight fluorescent (D 5700 - 7100K)",13:"Day white fluorescent (N 4600 - 5400K)",14:"Cool white fluorescent (W 3900 - 4500K)",15:"White fluorescent (WW 3200 - 3700K)",17:"Standard light A",18:"Standard light B",19:"Standard light C",20:"D55",21:"D65",22:"D75",23:"D50",24:"ISO studio tungsten",255:"Other"},Flash:{0:"Flash did not fire",1:"Flash fired",5:"Strobe return light not detected",7:"Strobe return light detected",9:"Flash fired, compulsory flash mode",13:"Flash fired, compulsory flash mode, return light not detected",15:"Flash fired, compulsory flash mode, return light detected",16:"Flash did not fire, compulsory flash mode",24:"Flash did not fire, auto mode",25:"Flash fired, auto mode",29:"Flash fired, auto mode, return light not detected",31:"Flash fired, auto mode, return light detected",32:"No flash function",65:"Flash fired, red-eye reduction mode",69:"Flash fired, red-eye reduction mode, return light not detected",71:"Flash fired, red-eye reduction mode, return light detected",73:"Flash fired, compulsory flash mode, red-eye reduction mode",77:"Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected",79:"Flash fired, compulsory flash mode, red-eye reduction mode, return light detected",89:"Flash fired, auto mode, red-eye reduction mode",93:"Flash fired, auto mode, return light not detected, red-eye reduction mode",95:"Flash fired, auto mode, return light detected, red-eye reduction mode"},SensingMethod:{1:"Undefined",2:"One-chip color area sensor",3:"Two-chip color area sensor",4:"Three-chip color area sensor",5:"Color sequential area sensor",7:"Trilinear sensor",8:"Color sequential linear sensor"},SceneCaptureType:{0:"Standard",1:"Landscape",2:"Portrait",3:"Night scene"},SceneType:{1:"Directly photographed"},CustomRendered:{0:"Normal process",1:"Custom process"},WhiteBalance:{0:"Auto white balance",1:"Manual white balance"},GainControl:{0:"None",1:"Low gain up",2:"High gain up",3:"Low gain down",4:"High gain down"},Contrast:{0:"Normal",1:"Soft",2:"Hard"},Saturation:{0:"Normal",1:"Low saturation",2:"High saturation"},Sharpness:{0:"Normal",1:"Soft",2:"Hard"},SubjectDistanceRange:{0:"Unknown",1:"Macro",2:"Close view",3:"Distant view"},FileSource:{3:"DSC"},ComponentsConfiguration:{0:"",1:"Y",2:"Cb",3:"Cr",4:"R",5:"G",6:"B"},Orientation:{1:"top-left",2:"top-right",3:"bottom-right",4:"bottom-left",5:"left-top",6:"right-top",7:"right-bottom",8:"left-bottom"}},e.ExifMap.prototype.getText=function(e){var t=this.get(e);switch(e){case"LightSource":case"Flash":case"MeteringMode":case"ExposureProgram":case"SensingMethod":case"SceneCaptureType":case"SceneType":case"CustomRendered":case"WhiteBalance":case"GainControl":case"Contrast":case"Saturation":case"Sharpness":case"SubjectDistanceRange":case"FileSource":case"Orientation":return this.stringValues[e][t];case"ExifVersion":case"FlashpixVersion":if(!t)return;return String.fromCharCode(t[0],t[1],t[2],t[3]);case"ComponentsConfiguration":if(!t)return;return this.stringValues[e][t[0]]+this.stringValues[e][t[1]]+this.stringValues[e][t[2]]+this.stringValues[e][t[3]];case"GPSVersionID":if(!t)return;return t[0]+"."+t[1]+"."+t[2]+"."+t[3]}return String(t)},function(e){var t,i=e.tags,o=e.map;for(t in i)i.hasOwnProperty(t)&&(o[i[t]]=t)}(e.ExifMap.prototype),e.ExifMap.prototype.getAll=function(){var e,t,i={};for(e in this)this.hasOwnProperty(e)&&(t=this.tags[e],t&&(i[t]=this.getText(t)));return i}}),function(e){"use strict";"function"==typeof define&&define.amd?define(["./load-image","./load-image-scale","./load-image-meta"],e):"object"==typeof module&&module.exports?e(require("./load-image"),require("./load-image-scale"),require("./load-image-meta")):e(window.loadImage)}(function(e){"use strict";var t=e.hasCanvasOption,i=e.hasMetaOption,o=e.transformCoordinates,a=e.getTransformedOptions;e.hasCanvasOption=function(i){return!!i.orientation||t.call(e,i)},e.hasMetaOption=function(t){return t&&t.orientation===!0||i.call(e,t)},e.transformCoordinates=function(t,i){o.call(e,t,i);var a=t.getContext("2d"),n=t.width,r=t.height,s=t.style.width,l=t.style.height,d=i.orientation;if(d&&!(d>8))switch(d>4&&(t.width=r,t.height=n,t.style.width=l,t.style.height=s),d){case 2:a.translate(n,0),a.scale(-1,1);break;case 3:a.translate(n,r),a.rotate(Math.PI);break;case 4:a.translate(0,r),a.scale(1,-1);break;case 5:a.rotate(.5*Math.PI),a.scale(1,-1);break;case 6:a.rotate(.5*Math.PI),a.translate(0,-r);break;case 7:a.rotate(.5*Math.PI),a.translate(n,-r),a.scale(-1,1);break;case 8:a.rotate(-.5*Math.PI),a.translate(-n,0)}},e.getTransformedOptions=function(t,i,o){var n,r,s=a.call(e,t,i),l=s.orientation;if(l===!0&&o&&o.exif&&(l=o.exif.get("Orientation")),!l||l>8||1===l)return s;n={};for(r in s)s.hasOwnProperty(r)&&(n[r]=s[r]);switch(n.orientation=l,l){case 2:n.left=s.right,n.right=s.left;break;case 3:n.left=s.right,n.top=s.bottom,n.right=s.left,n.bottom=s.top;break;case 4:n.top=s.bottom,n.bottom=s.top;break;case 5:n.left=s.top,n.top=s.left,n.right=s.bottom,n.bottom=s.right;break;case 6:n.left=s.top,n.top=s.right,n.right=s.bottom,n.bottom=s.left;break;case 7:n.left=s.bottom,n.top=s.right,n.right=s.top,n.bottom=s.left;break;case 8:n.left=s.bottom,n.top=s.left,n.right=s.top,n.bottom=s.right}return n.orientation>4&&(n.maxWidth=s.maxHeight,n.maxHeight=s.maxWidth,n.minWidth=s.minHeight,n.minHeight=s.minWidth,n.sourceWidth=s.sourceHeight,n.sourceHeight=s.sourceWidth),n}}); +//# sourceMappingURL=load-image.all.min.js.map \ No newline at end of file diff --git a/node_modules/blueimp-load-image/js/load-image.all.min.js.map b/node_modules/blueimp-load-image/js/load-image.all.min.js.map new file mode 100644 index 000000000..212270f6c --- /dev/null +++ b/node_modules/blueimp-load-image/js/load-image.all.min.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["load-image.js","load-image-scale.js","load-image-meta.js","load-image-fetch.js","load-image-exif.js","load-image-exif-map.js","load-image-orientation.js"],"names":["$","loadImage","file","callback","options","url","img","document","createElement","onerror","event","onload","fetchBlob","blob","createObjectURL","crossOrigin","src","isInstanceOf","_objectURL","readFile","e","target","result","revokeHelper","noRevoke","revokeObjectURL","urlAPI","window","URL","webkitURL","type","obj","Object","prototype","toString","call","transform","data","method","FileReader","fileReader","define","amd","module","exports","factory","require","originalTransform","scale","transformCoordinates","getTransformedOptions","newOptions","i","width","height","aspectRatio","hasOwnProperty","crop","naturalWidth","naturalHeight","maxWidth","maxHeight","renderImageToCanvas","canvas","sourceX","sourceY","sourceWidth","sourceHeight","destX","destY","destWidth","destHeight","getContext","drawImage","hasCanvasOption","scaleUp","Math","max","minWidth","minHeight","scaleDown","min","pixelRatio","downsamplingRatio","tmp","useCanvas","left","top","undefined","right","bottom","contain","cover","style","hasblobSlice","Blob","slice","webkitSlice","mozSlice","blobSlice","this","apply","arguments","metaDataParsers","jpeg","65505","parseMetaData","that","maxMetaDataSize","noMetaData","DataView","size","error","console","log","markerBytes","markerLength","parsers","buffer","dataView","offset","maxOffset","byteLength","headLength","getUint16","length","disableImageHead","imageHead","Uint8Array","subarray","hasMetaOption","meta","fetch","Request","then","response","catch","err","ExifMap","map","Orientation","get","id","getExifThumbnail","hexData","b","getUint8","push","join","exifTagTypes","1","getValue","dataOffset","2","String","fromCharCode","ascii","3","littleEndian","4","getUint32","5","9","getInt32","10","getExifValue","tiffOffset","tagSize","values","str","c","tagType","parseExifTag","tag","exif","parseExifTags","dirOffset","tagsNumber","dirEndOffset","parseExifData","disableExif","thumbnailData","disableExifThumbnail","Thumbnail","disableExifSub","disableExifGps","tags","256","257","34665","34853","40965","258","259","262","274","277","284","530","531","282","283","296","273","278","279","513","514","301","318","319","529","532","306","270","271","272","305","315","33432","36864","40960","40961","40962","40963","42240","37121","37122","37500","37510","40964","36867","36868","37520","37521","37522","33434","33437","34850","34852","34855","34856","34864","34865","34866","34867","34868","34869","37377","37378","37379","37380","37381","37382","37383","37384","37385","37396","37386","41483","41484","41486","41487","41488","41492","41493","41495","41728","41729","41730","41985","41986","41987","41988","41989","41990","41991","41992","41993","41994","41995","41996","42016","42032","42033","42034","42035","42036","42037","0","6","7","8","11","12","13","14","15","16","17","18","19","20","21","22","23","24","25","26","27","28","29","30","31","stringValues","ExposureProgram","MeteringMode","255","LightSource","Flash","32","65","69","71","73","77","79","89","93","95","SensingMethod","SceneCaptureType","SceneType","CustomRendered","WhiteBalance","GainControl","Contrast","Saturation","Sharpness","SubjectDistanceRange","FileSource","ComponentsConfiguration","getText","value","exifMapPrototype","prop","getAll","originalHasCanvasOption","originalHasMetaOption","originalTransformCoordinates","originalGetTransformedOptions","orientation","ctx","styleWidth","styleHeight","translate","rotate","PI","opts"],"mappings":"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","file":"load-image.all.min.js"} \ No newline at end of file diff --git a/node_modules/blueimp-load-image/js/load-image.js b/node_modules/blueimp-load-image/js/load-image.js new file mode 100644 index 000000000..3d3ac9484 --- /dev/null +++ b/node_modules/blueimp-load-image/js/load-image.js @@ -0,0 +1,138 @@ +/* + * JavaScript Load Image + * https://github.com/blueimp/JavaScript-Load-Image + * + * Copyright 2011, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + */ + +/* global define, URL, webkitURL, FileReader */ + +;(function ($) { + 'use strict' + + // Loads an image for a given File object. + // Invokes the callback with an img or optional canvas + // element (if supported by the browser) as parameter: + function loadImage (file, callback, options) { + var img = document.createElement('img') + var url + img.onerror = function (event) { + return loadImage.onerror(img, event, file, callback, options) + } + img.onload = function (event) { + return loadImage.onload(img, event, file, callback, options) + } + if (typeof file === 'string') { + loadImage.fetchBlob(file, function (blob) { + if (blob) { + file = blob + url = loadImage.createObjectURL(file) + } else { + url = file + if (options && options.crossOrigin) { + img.crossOrigin = options.crossOrigin + } + } + img.src = url + }, options) + return img + } else if (loadImage.isInstanceOf('Blob', file) || + // Files are also Blob instances, but some browsers + // (Firefox 3.6) support the File API but not Blobs: + loadImage.isInstanceOf('File', file)) { + url = img._objectURL = loadImage.createObjectURL(file) + if (url) { + img.src = url + return img + } + return loadImage.readFile(file, function (e) { + var target = e.target + if (target && target.result) { + img.src = target.result + } else if (callback) { + callback(e) + } + }) + } + } + // The check for URL.revokeObjectURL fixes an issue with Opera 12, + // which provides URL.createObjectURL but doesn't properly implement it: + var urlAPI = (window.createObjectURL && window) || + (window.URL && URL.revokeObjectURL && URL) || + (window.webkitURL && webkitURL) + + function revokeHelper (img, options) { + if (img._objectURL && !(options && options.noRevoke)) { + loadImage.revokeObjectURL(img._objectURL) + delete img._objectURL + } + } + + // If the callback given to this function returns a blob, it is used as image + // source instead of the original url and overrides the file argument used in + // the onload and onerror event callbacks: + loadImage.fetchBlob = function (url, callback, options) { + callback() + } + + loadImage.isInstanceOf = function (type, obj) { + // Cross-frame instanceof check + return Object.prototype.toString.call(obj) === '[object ' + type + ']' + } + + loadImage.transform = function (img, options, callback, file, data) { + callback(img, data) + } + + loadImage.onerror = function (img, event, file, callback, options) { + revokeHelper(img, options) + if (callback) { + callback.call(img, event) + } + } + + loadImage.onload = function (img, event, file, callback, options) { + revokeHelper(img, options) + if (callback) { + loadImage.transform(img, options, callback, file, {}) + } + } + + loadImage.createObjectURL = function (file) { + return urlAPI ? urlAPI.createObjectURL(file) : false + } + + loadImage.revokeObjectURL = function (url) { + return urlAPI ? urlAPI.revokeObjectURL(url) : false + } + + // Loads a given File object via FileReader interface, + // invokes the callback with the event object (load or error). + // The result can be read via event.target.result: + loadImage.readFile = function (file, callback, method) { + if (window.FileReader) { + var fileReader = new FileReader() + fileReader.onload = fileReader.onerror = callback + method = method || 'readAsDataURL' + if (fileReader[method]) { + fileReader[method](file) + return fileReader + } + } + return false + } + + if (typeof define === 'function' && define.amd) { + define(function () { + return loadImage + }) + } else if (typeof module === 'object' && module.exports) { + module.exports = loadImage + } else { + $.loadImage = loadImage + } +}(window)) diff --git a/node_modules/blueimp-load-image/package.json b/node_modules/blueimp-load-image/package.json new file mode 100644 index 000000000..24e47fa34 --- /dev/null +++ b/node_modules/blueimp-load-image/package.json @@ -0,0 +1,49 @@ +{ + "name": "blueimp-load-image", + "version": "2.12.2", + "title": "JavaScript Load Image", + "description": "JavaScript Load Image is a library to load images provided as File or Blob objects or via URL. It returns an optionally scaled and/or cropped HTML img or canvas element. It also provides a method to parse image meta data to extract Exif tags and thumbnails and to restore the complete image header after resizing.", + "keywords": [ + "javascript", + "load", + "loading", + "image", + "file", + "blob", + "url", + "scale", + "crop", + "img", + "canvas", + "meta", + "exif", + "thumbnail", + "resizing" + ], + "homepage": "https://github.com/blueimp/JavaScript-Load-Image", + "author": { + "name": "Sebastian Tschan", + "url": "https://blueimp.net" + }, + "repository": { + "type": "git", + "url": "git://github.com/blueimp/JavaScript-Load-Image.git" + }, + "license": "MIT", + "devDependencies": { + "phantomjs-prebuilt": "2.1.13", + "mocha-phantomjs-core": "1.3.1", + "standard": "8.3.0", + "uglify-js": "2.7.3" + }, + "scripts": { + "lint": "standard *.js js/*.js test/*.js", + "unit": "phantomjs node_modules/mocha-phantomjs-core/mocha-phantomjs-core.js test/index.html", + "test": "npm run lint && npm run unit", + "build": "cd js && uglifyjs load-image.js load-image-scale.js load-image-meta.js load-image-fetch.js load-image-exif.js load-image-exif-map.js load-image-orientation.js -c -m -o load-image.all.min.js --source-map load-image.all.min.js.map", + "preversion": "npm test", + "version": "npm run build && git add -A js", + "postversion": "git push --tags origin master master:gh-pages && npm publish" + }, + "main": "js/index.js" +} diff --git a/node_modules/blueimp-tmpl/README.md b/node_modules/blueimp-tmpl/README.md new file mode 100644 index 000000000..b64643c1f --- /dev/null +++ b/node_modules/blueimp-tmpl/README.md @@ -0,0 +1,400 @@ +# JavaScript Templates + +## Demo +[JavaScript Templates Demo](https://blueimp.github.io/JavaScript-Templates/) + +## Description +1KB lightweight, fast & powerful JavaScript templating engine with zero +dependencies. Compatible with server-side environments like Node.js, module +loaders like RequireJS, Browserify or webpack and all web browsers. + +## Usage + +### Client-side +Include the (minified) JavaScript Templates script in your HTML markup: + +```html + +``` + +Add a script section with type **"text/x-tmpl"**, a unique **id** property and +your template definition as content: + +```html + +``` + +**"o"** (the lowercase letter) is a reference to the data parameter of the +template function (see the API section on how to modify this identifier). + +In your application code, create a JavaScript object to use as data for the +template: + +```js +var data = { + "title": "JavaScript Templates", + "license": { + "name": "MIT license", + "url": "http://www.opensource.org/licenses/MIT" + }, + "features": [ + "lightweight & fast", + "powerful", + "zero dependencies" + ] +}; +``` + +In a real application, this data could be the result of retrieving a +[JSON](http://json.org/) resource. + +Render the result by calling the **tmpl()** method with the id of the template +and the data object as arguments: + +```js +document.getElementById("result").innerHTML = tmpl("tmpl-demo", data); +``` + +### Server-side + +The following is an example how to use the JavaScript Templates engine on the +server-side with [node.js](http://nodejs.org/). + +Create a new directory and add the **tmpl.js** file. Or alternatively, install +the **blueimp-tmpl** package with [npm](https://www.npmjs.org/): + +```sh +npm install blueimp-tmpl +``` + +Add a file **template.html** with the following content: + +```html + +{%=o.title%} +

{%=o.title%}

+

Features

+
    +{% for (var i=0; i{%=o.features[i]%} +{% } %} +
+``` + +Add a file **server.js** with the following content: + +```js +require("http").createServer(function (req, res) { + var fs = require("fs"), + // The tmpl module exports the tmpl() function: + tmpl = require("./tmpl"), + // Use the following version if you installed the package with npm: + // tmpl = require("blueimp-tmpl"), + // Sample data: + data = { + "title": "JavaScript Templates", + "url": "https://github.com/blueimp/JavaScript-Templates", + "features": [ + "lightweight & fast", + "powerful", + "zero dependencies" + ] + }; + // Override the template loading method: + tmpl.load = function (id) { + var filename = id + ".html"; + console.log("Loading " + filename); + return fs.readFileSync(filename, "utf8"); + }; + res.writeHead(200, {"Content-Type": "text/x-tmpl"}); + // Render the content: + res.end(tmpl("template", data)); +}).listen(8080, "localhost"); +console.log("Server running at http://localhost:8080/"); +``` + +Run the application with the following command: + +```sh +node server.js +``` + +## Requirements +The JavaScript Templates script has zero dependencies. + +## API + +### tmpl() function +The **tmpl()** function is added to the global **window** object and can be +called as global function: + +```js +var result = tmpl("tmpl-demo", data); +``` + +The **tmpl()** function can be called with the id of a template, or with a +template string: + +```js +var result = tmpl("

{%=o.title%}

", data); +``` + +If called without second argument, **tmpl()** returns a reusable template +function: + +```js +var func = tmpl("

{%=o.title%}

"); +document.getElementById("result").innerHTML = func(data); +``` + +### Templates cache +Templates loaded by id are cached in the map **tmpl.cache**: + +```js +var func = tmpl("tmpl-demo"), // Loads and parses the template + cached = typeof tmpl.cache["tmpl-demo"] === "function", // true + result = tmpl("tmpl-demo", data); // Uses cached template function + +tmpl.cache["tmpl-demo"] = null; +result = tmpl("tmpl-demo", data); // Loads and parses the template again +``` + +### Output encoding +The method **tmpl.encode** is used to escape HTML special characters in the +template output: + +```js +var output = tmpl.encode("<>&\"'\x00"); // Renders "<>&"'" +``` + +**tmpl.encode** makes use of the regular expression **tmpl.encReg** and the +encoding map **tmpl.encMap** to match and replace special characters, which can +be modified to change the behavior of the output encoding. +Strings matched by the regular expression, but not found in the encoding map are +removed from the output. This allows for example to automatically trim input +values (removing whitespace from the start and end of the string): + +```js +tmpl.encReg = /(^\s+)|(\s+$)|[<>&"'\x00]/g; +var output = tmpl.encode(" Banana! "); // Renders "Banana" (without whitespace) +``` + +### Local helper variables +The local variables available inside the templates are the following: + +* **o**: The data object given as parameter to the template function +(see the next section on how to modify the parameter name). +* **tmpl**: A reference to the **tmpl** function object. +* **_s**: The string for the rendered result content. +* **_e**: A reference to the **tmpl.encode** method. +* **print**: Helper function to add content to the rendered result string. +* **include**: Helper function to include the return value of a different +template in the result. + +To introduce additional local helper variables, the string **tmpl.helper** can +be extended. The following adds a convenience function for *console.log* and a +streaming function, that streams the template rendering result back to the +callback argument +(note the comma at the beginning of each variable declaration): + +```js +tmpl.helper += ",log=function(){console.log.apply(console, arguments)}" + + ",st='',stream=function(cb){var l=st.length;st=_s;cb( _s.slice(l));}"; +``` + +Those new helper functions could be used to stream the template contents to the +console output: + +```html + +``` + +### Template function argument +The generated template functions accept one argument, which is the data object +given to the **tmpl(id, data)** function. This argument is available inside the +template definitions as parameter **o** (the lowercase letter). + +The argument name can be modified by overriding **tmpl.arg**: + +```js +tmpl.arg = "p"; + +// Renders "

JavaScript Templates

": +var result = tmpl("

{%=p.title%}

", {title: "JavaScript Templates"}); +``` + +### Template parsing +The template contents are matched and replaced using the regular expression +**tmpl.regexp** and the replacement function **tmpl.func**. +The replacement function operates based on the +[parenthesized submatch strings](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String/replace#Specifying_a_function_as_a_parameter). + +To use different tags for the template syntax, override **tmpl.regexp** with a +modified regular expression, by exchanging all occurrences of "{%" and "%}", +e.g. with "[%" and "%]": + +```js +tmpl.regexp = /([\s'\\])(?!(?:[^[]|\[(?!%))*%\])|(?:\[%(=|#)([\s\S]+?)%\])|(\[%)|(%\])/g; +``` + +By default, the plugin preserves whitespace +(newlines, carriage returns, tabs and spaces). +To strip unnecessary whitespace, you can override the **tmpl.func** function, +e.g. with the following code: + +```js +var originalFunc = tmpl.func; +tmpl.func = function (s, p1, p2, p3, p4, p5, offset, str) { + if (p1 && /\s/.test(p1)) { + if (!offset || /\s/.test(str.charAt(offset - 1)) || + /^\s+$/g.test(str.slice(offset))) { + return ''; + } + return ' '; + } + return originalFunc.apply(tmpl, arguments); +}; +``` + +## Templates syntax + +### Interpolation +Print variable with HTML special characters escaped: + +```html +

{%=o.title%}

+``` + +Print variable without escaping: + +```html +

{%#o.user_id%}

+``` + +Print output of function calls: + +```html +Website +``` + +Use dot notation to print nested properties: + +```html +{%=o.author.name%} +``` + +### Evaluation +Use **print(str)** to add escaped content to the output: + +```html +Year: {% var d=new Date(); print(d.getFullYear()); %} +``` + +Use **print(str, true)** to add unescaped content to the output: + +```html +{% print("Fast & powerful", true); %} +``` + +Use **include(str, obj)** to include content from a different template: + +```html +
+{% include('tmpl-link', {name: "Website", url: "https://example.org"}); %} +
+``` + +**If else condition**: + +```html +{% if (o.author.url) { %} + {%=o.author.name%} +{% } else { %} + No author url. +{% } %} +``` + +**For loop**: + +```html +
    +{% for (var i=0; i{%=o.features[i]%} +{% } %} +
+``` + +## Compiled templates +The JavaScript Templates project comes with a compilation script, that allows +you to compile your templates into JavaScript code and combine them with a +minimal Templates runtime into one combined JavaScript file. + +The compilation script is built for [node.js](http://nodejs.org/). +To use it, first install the JavaScript Templates project via +[npm](https://www.npmjs.org/): + +```sh +npm install blueimp-tmpl +``` + +This will put the executable **tmpl.js** into the folder **node_modules/.bin**. +It will also make it available on your PATH if you install the package globally +(by adding the **-g** flag to the install command). + +The **tmpl.js** executable accepts the paths to one or multiple template files +as command line arguments and prints the generated JavaScript code to the +console output. The following command line shows you how to store the generated +code in a new JavaScript file that can be included in your project: + +```sh +tmpl.js index.html > tmpl.js +``` + +The files given as command line arguments to **tmpl.js** can either be pure +template files or HTML documents with embedded template script sections. +For the pure template files, the file names (without extension) serve as +template ids. +The generated file can be included in your project as a replacement for the +original **tmpl.js** runtime. It provides you with the same API and provides a +**tmpl(id, data)** function that accepts the id of one of your templates as +first and a data object as optional second parameter. + +## Tests +The JavaScript Templates project comes with +[Unit Tests](https://en.wikipedia.org/wiki/Unit_testing). +There are two different ways to run the tests: + +* Open test/index.html in your browser or +* run `npm test` in the Terminal in the root path of the repository package. + +The first one tests the browser integration, +the second one the [node.js](http://nodejs.org/) integration. + +## License +The JavaScript Templates script is released under the +[MIT license](http://www.opensource.org/licenses/MIT). diff --git a/node_modules/blueimp-tmpl/js/compile.js b/node_modules/blueimp-tmpl/js/compile.js new file mode 100644 index 000000000..10e45d17f --- /dev/null +++ b/node_modules/blueimp-tmpl/js/compile.js @@ -0,0 +1,80 @@ +#!/usr/bin/env node +/* + * JavaScript Templates Compiler + * https://github.com/blueimp/JavaScript-Templates + * + * Copyright 2011, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * http://www.opensource.org/licenses/MIT + */ + +;(function () { + 'use strict' + var path = require('path') + var tmpl = require(path.join(__dirname, 'tmpl.js')) + var fs = require('fs') + // Retrieve the content of the minimal runtime: + var runtime = fs.readFileSync(path.join(__dirname, 'runtime.js'), 'utf8') + // A regular expression to parse templates from script tags in a HTML page: + var regexp = /([\s\S]+?)<\/script>/gi + // A regular expression to match the helper function names: + var helperRegexp = new RegExp( + tmpl.helper.match(/\w+(?=\s*=\s*function\s*\()/g).join('\\s*\\(|') + '\\s*\\(' + ) + // A list to store the function bodies: + var list = [] + var code + // Extend the Templating engine with a print method for the generated functions: + tmpl.print = function (str) { + // Only add helper functions if they are used inside of the template: + var helper = helperRegexp.test(str) ? tmpl.helper : '' + var body = str.replace(tmpl.regexp, tmpl.func) + if (helper || (/_e\s*\(/.test(body))) { + helper = '_e=tmpl.encode' + helper + ',' + } + return 'function(' + tmpl.arg + ',tmpl){' + + ('var ' + helper + "_s='" + body + "';return _s;") + .split("_s+='';").join('') + '}' + } + // Loop through the command line arguments: + process.argv.forEach(function (file, index) { + var listLength = list.length + var stats + var content + var result + var id + // Skip the first two arguments, which are "node" and the script: + if (index > 1) { + stats = fs.statSync(file) + if (!stats.isFile()) { + console.error(file + ' is not a file.') + return + } + content = fs.readFileSync(file, 'utf8') + while (true) { + // Find templates in script tags: + result = regexp.exec(content) + if (!result) { + break + } + id = result[2] || result[4] + list.push("'" + id + "':" + tmpl.print(result[5])) + } + if (listLength === list.length) { + // No template script tags found, use the complete content: + id = path.basename(file, path.extname(file)) + list.push("'" + id + "':" + tmpl.print(content)) + } + } + }) + if (!list.length) { + console.error('Missing input file.') + return + } + // Combine the generated functions as cache of the minimal runtime: + code = runtime.replace('{}', '{' + list.join(',') + '}') + // Print the resulting code to the console output: + console.log(code) +}()) diff --git a/node_modules/blueimp-tmpl/js/runtime.js b/node_modules/blueimp-tmpl/js/runtime.js new file mode 100644 index 000000000..1effff814 --- /dev/null +++ b/node_modules/blueimp-tmpl/js/runtime.js @@ -0,0 +1,48 @@ +/* + * JavaScript Templates Runtime + * https://github.com/blueimp/JavaScript-Templates + * + * Copyright 2011, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * http://www.opensource.org/licenses/MIT + */ + +/* global define */ + +;(function ($) { + 'use strict' + var tmpl = function (id, data) { + var f = tmpl.cache[id] + return data ? f(data, tmpl) : function (data) { + return f(data, tmpl) + } + } + tmpl.cache = {} + tmpl.encReg = /[<>&"'\x00]/g // eslint-disable-line no-control-regex + tmpl.encMap = { + '<': '<', + '>': '>', + '&': '&', + '"': '"', + "'": ''' + } + tmpl.encode = function (s) { + return (s == null ? '' : '' + s).replace( + tmpl.encReg, + function (c) { + return tmpl.encMap[c] || '' + } + ) + } + if (typeof define === 'function' && define.amd) { + define(function () { + return tmpl + }) + } else if (typeof module === 'object' && module.exports) { + module.exports = tmpl + } else { + $.tmpl = tmpl + } +}(this)) diff --git a/node_modules/blueimp-tmpl/js/tmpl.js b/node_modules/blueimp-tmpl/js/tmpl.js new file mode 100644 index 000000000..8cb6023ff --- /dev/null +++ b/node_modules/blueimp-tmpl/js/tmpl.js @@ -0,0 +1,86 @@ +/* + * JavaScript Templates + * https://github.com/blueimp/JavaScript-Templates + * + * Copyright 2011, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * http://www.opensource.org/licenses/MIT + * + * Inspired by John Resig's JavaScript Micro-Templating: + * http://ejohn.org/blog/javascript-micro-templating/ + */ + +/* global define */ + +;(function ($) { + 'use strict' + var tmpl = function (str, data) { + var f = !/[^\w\-\.:]/.test(str) + ? tmpl.cache[str] = tmpl.cache[str] || tmpl(tmpl.load(str)) + : new Function(// eslint-disable-line no-new-func + tmpl.arg + ',tmpl', + 'var _e=tmpl.encode' + tmpl.helper + ",_s='" + + str.replace(tmpl.regexp, tmpl.func) + "';return _s;" + ) + return data ? f(data, tmpl) : function (data) { + return f(data, tmpl) + } + } + tmpl.cache = {} + tmpl.load = function (id) { + return document.getElementById(id).innerHTML + } + tmpl.regexp = /([\s'\\])(?!(?:[^{]|\{(?!%))*%\})|(?:\{%(=|#)([\s\S]+?)%\})|(\{%)|(%\})/g + tmpl.func = function (s, p1, p2, p3, p4, p5) { + if (p1) { // whitespace, quote and backspace in HTML context + return { + '\n': '\\n', + '\r': '\\r', + '\t': '\\t', + ' ': ' ' + }[p1] || '\\' + p1 + } + if (p2) { // interpolation: {%=prop%}, or unescaped: {%#prop%} + if (p2 === '=') { + return "'+_e(" + p3 + ")+'" + } + return "'+(" + p3 + "==null?'':" + p3 + ")+'" + } + if (p4) { // evaluation start tag: {% + return "';" + } + if (p5) { // evaluation end tag: %} + return "_s+='" + } + } + tmpl.encReg = /[<>&"'\x00]/g // eslint-disable-line no-control-regex + tmpl.encMap = { + '<': '<', + '>': '>', + '&': '&', + '"': '"', + "'": ''' + } + tmpl.encode = function (s) { + return (s == null ? '' : '' + s).replace( + tmpl.encReg, + function (c) { + return tmpl.encMap[c] || '' + } + ) + } + tmpl.arg = 'o' + tmpl.helper = ",print=function(s,e){_s+=e?(s==null?'':s):_e(s);}" + + ',include=function(s,d){_s+=tmpl(s,d);}' + if (typeof define === 'function' && define.amd) { + define(function () { + return tmpl + }) + } else if (typeof module === 'object' && module.exports) { + module.exports = tmpl + } else { + $.tmpl = tmpl + } +}(this)) diff --git a/node_modules/blueimp-tmpl/package.json b/node_modules/blueimp-tmpl/package.json new file mode 100644 index 000000000..63a467d8e --- /dev/null +++ b/node_modules/blueimp-tmpl/package.json @@ -0,0 +1,40 @@ +{ + "name": "blueimp-tmpl", + "version": "3.6.0", + "title": "JavaScript Templates", + "description": "1KB lightweight, fast & powerful JavaScript templating engine with zero dependencies. Compatible with server-side environments like Node.js, module loaders like RequireJS, Browserify or webpack and all web browsers.", + "keywords": [ + "javascript", + "templates", + "templating" + ], + "homepage": "https://github.com/blueimp/JavaScript-Templates", + "author": { + "name": "Sebastian Tschan", + "url": "https://blueimp.net" + }, + "repository": { + "type": "git", + "url": "git://github.com/blueimp/JavaScript-Templates.git" + }, + "license": "MIT", + "devDependencies": { + "chai": "3.5.0", + "mocha": "3.1.0", + "standard": "8.3.0", + "uglify-js": "2.7.3" + }, + "scripts": { + "lint": "standard js/*.js test/*.js", + "unit": "mocha", + "test": "npm run lint && npm run unit", + "build": "cd js && uglifyjs tmpl.js -c -m -o tmpl.min.js --source-map tmpl.min.js.map", + "preversion": "npm test", + "version": "npm run build && git add -A js", + "postversion": "git push --tags origin master master:gh-pages && npm publish" + }, + "bin": { + "tmpl.js": "js/compile.js" + }, + "main": "js/tmpl.js" +} diff --git a/package-lock.json b/package-lock.json index fe97d69bf..e3a294b61 100644 --- a/package-lock.json +++ b/package-lock.json @@ -8,6 +8,7 @@ "@fontsource/raleway": "^4.5.0", "@popperjs/core": "^2.4.4", "ace-builds": "^1.2.8", + "blueimp-file-upload": "^9.22.1", "bulma-scss": "^0.9.4", "c3": "^0.4.11", "clipboard": "^2.0.4", @@ -45,6 +46,37 @@ "resolved": "https://registry.npmjs.org/ace-builds/-/ace-builds-1.2.8.tgz", "integrity": "sha512-L4m91PcWa1Zj4PA+/JflGAlz86mtoZP96vJmfByUmuNgS+b7odNPBfWRY2gOFhy1kh4J9lresLeINN0yQec8hA==" }, + "node_modules/blueimp-canvas-to-blob": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/blueimp-canvas-to-blob/-/blueimp-canvas-to-blob-3.5.0.tgz", + "integrity": "sha512-1Aq2Yn6SUsOERT4Ng7GUWRy6oRvqeNU2Iwhcq5ZH7aoejFkLEKjRx/XcpepfU7IMmj3sONSmiLmSgzj9umGUPw==", + "optional": true + }, + "node_modules/blueimp-file-upload": { + "version": "9.22.1", + "resolved": "https://registry.npmjs.org/blueimp-file-upload/-/blueimp-file-upload-9.22.1.tgz", + "integrity": "sha512-ezGkn/agWUWZOw8mYa5yYC9LvUlrT5bN3zk2fPlpLWgyhbBMz8BSGKO3M48BWlXWAeR+lVtEhy9xiG8FLnHEVw==", + "optionalDependencies": { + "blueimp-canvas-to-blob": "3.5.0", + "blueimp-load-image": "2.12.2", + "blueimp-tmpl": "3.6.0" + } + }, + "node_modules/blueimp-load-image": { + "version": "2.12.2", + "resolved": "https://registry.npmjs.org/blueimp-load-image/-/blueimp-load-image-2.12.2.tgz", + "integrity": "sha512-o6YeeBo0e6g3/T7mPZtED/y/66VdhMxYVEqE5Owl+9Ew0MpLFgFh6humePBAh0JVRfCtK7CHQ7K84S4GIfaZtg==", + "optional": true + }, + "node_modules/blueimp-tmpl": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/blueimp-tmpl/-/blueimp-tmpl-3.6.0.tgz", + "integrity": "sha512-FPbl2VMophcudvT2Li+y10RtKT4l7wBto1NZycXoVQb1JVlo8QbjDgEqL9Ph41/rUl4dTOv3mqWPoxqCHA1b7A==", + "optional": true, + "bin": { + "tmpl.js": "js/compile.js" + } + }, "node_modules/bulma-scss": { "version": "0.9.4", "resolved": "https://registry.npmjs.org/bulma-scss/-/bulma-scss-0.9.4.tgz", @@ -202,6 +234,34 @@ "resolved": "https://registry.npmjs.org/ace-builds/-/ace-builds-1.2.8.tgz", "integrity": "sha512-L4m91PcWa1Zj4PA+/JflGAlz86mtoZP96vJmfByUmuNgS+b7odNPBfWRY2gOFhy1kh4J9lresLeINN0yQec8hA==" }, + "blueimp-canvas-to-blob": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/blueimp-canvas-to-blob/-/blueimp-canvas-to-blob-3.5.0.tgz", + "integrity": "sha512-1Aq2Yn6SUsOERT4Ng7GUWRy6oRvqeNU2Iwhcq5ZH7aoejFkLEKjRx/XcpepfU7IMmj3sONSmiLmSgzj9umGUPw==", + "optional": true + }, + "blueimp-file-upload": { + "version": "9.22.1", + "resolved": "https://registry.npmjs.org/blueimp-file-upload/-/blueimp-file-upload-9.22.1.tgz", + "integrity": "sha512-ezGkn/agWUWZOw8mYa5yYC9LvUlrT5bN3zk2fPlpLWgyhbBMz8BSGKO3M48BWlXWAeR+lVtEhy9xiG8FLnHEVw==", + "requires": { + "blueimp-canvas-to-blob": "3.5.0", + "blueimp-load-image": "2.12.2", + "blueimp-tmpl": "3.6.0" + } + }, + "blueimp-load-image": { + "version": "2.12.2", + "resolved": "https://registry.npmjs.org/blueimp-load-image/-/blueimp-load-image-2.12.2.tgz", + "integrity": "sha512-o6YeeBo0e6g3/T7mPZtED/y/66VdhMxYVEqE5Owl+9Ew0MpLFgFh6humePBAh0JVRfCtK7CHQ7K84S4GIfaZtg==", + "optional": true + }, + "blueimp-tmpl": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/blueimp-tmpl/-/blueimp-tmpl-3.6.0.tgz", + "integrity": "sha512-FPbl2VMophcudvT2Li+y10RtKT4l7wBto1NZycXoVQb1JVlo8QbjDgEqL9Ph41/rUl4dTOv3mqWPoxqCHA1b7A==", + "optional": true + }, "bulma-scss": { "version": "0.9.4", "resolved": "https://registry.npmjs.org/bulma-scss/-/bulma-scss-0.9.4.tgz", diff --git a/package.json b/package.json index 62b043aab..be3af87ef 100644 --- a/package.json +++ b/package.json @@ -3,6 +3,7 @@ "@fontsource/raleway": "^4.5.0", "@popperjs/core": "^2.4.4", "ace-builds": "^1.2.8", + "blueimp-file-upload": "^9.22.1", "bulma-scss": "^0.9.4", "c3": "^0.4.11", "clipboard": "^2.0.4",