card-mod-script 0.13.4 → 0.14.0

data/vendor/jquery_file_upload/js/jquery.fileupload-image.js

@@ -9,318 +9,339 @@
  * https://opensource.org/licenses/MIT
  */
 
-/* jshint nomen:false */
-/* global define, require, window, Blob */
+/* global define, require */
 
-;(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'
-        }
+(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',
+      'load-image-orientation',
+      '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-load-image/js/load-image-orientation'),
+      require('blueimp-canvas-to-blob'),
+      require('./jquery.fileupload-process')
     );
+  } else {
+    // Browser globals:
+    factory(window.jQuery, window.loadImage);
+  }
+})(function ($, loadImage) {
+  'use strict';
 
-    // 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;
-            },
+  // Prepend to the default processQueue:
+  $.blueimp.fileupload.prototype.options.processQueue.unshift(
+    {
+      action: 'loadImageMetaData',
+      maxMetaDataSize: '@',
+      disableImageHead: '@',
+      disableMetaDataParsers: '@',
+      disableExif: '@',
+      disableExifOffsets: '@',
+      includeExifTags: '@',
+      excludeExifTags: '@',
+      disableIptc: '@',
+      disableIptcOffsets: '@',
+      includeIptcTags: '@',
+      excludeIptcTags: '@',
+      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',
+      imageSmoothingQuality: '@imageSmoothingQuality'
+    },
+    {
+      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'
+    }
+  );
 
-            // 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();
-            },
+  // 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: true,
+      // 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
+    },
 
-            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();
+    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],
+          // eslint-disable-next-line new-cap
+          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();
+      },
 
-            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;
-            },
+      // 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;
+        }
+        // eslint-disable-next-line no-param-reassign
+        options = $.extend({ canvas: true }, options);
+        var that = this,
+          // eslint-disable-next-line new-cap
+          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,
+          thumbnailBlob;
+        if (data.exif && options.thumbnail) {
+          thumbnail = data.exif.get('Thumbnail');
+          thumbnailBlob = thumbnail && thumbnail.get('Blob');
+          if (thumbnailBlob) {
+            options.orientation = data.exif.get('Orientation');
+            loadImage(thumbnailBlob, resolve, options);
+            return dfd.promise();
+          }
+        }
+        if (data.orientation) {
+          // Prevent orienting the same image twice:
+          delete options.orientation;
+        } else {
+          data.orientation = options.orientation || loadImage.orientation;
+        }
+        if (img) {
+          resolve(loadImage.scale(img, options, data));
+          return dfd.promise();
+        }
+        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;
+      // 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],
+          // eslint-disable-next-line new-cap
+          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)
+                  );
                 }
-                return data;
+              }
+              // 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();
+      },
 
-            deleteImageReferences: function (data, options) {
-                if (!options.disabled) {
-                    delete data.img;
-                    delete data.canvas;
-                    delete data.preview;
-                    delete data.imageHead;
-                }
-                return data;
-            }
+      loadImageMetaData: function (data, options) {
+        if (options.disabled) {
+          return data;
+        }
+        var that = this,
+          // eslint-disable-next-line new-cap
+          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 that = this,
+          file = data.files[data.index],
+          // eslint-disable-next-line new-cap
+          dfd = $.Deferred();
+        if (data.orientation === true && data.exifOffsets) {
+          // Reset Exif Orientation data:
+          loadImage.writeExifData(data.imageHead, data, 'Orientation', 1);
         }
+        loadImage.replaceHead(file, data.imageHead, function (blob) {
+          blob.name = file.name;
+          data.files[data.index] = blob;
+          dfd.resolveWith(that, [data]);
+        });
+        return dfd.promise();
+      },
 
-    });
+      // 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;
+      }
+    }
+  });
+});