card-mod-format 0.14.1 → 0.15.0

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

@@ -0,0 +1,101 @@
+/*
+ * 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
+ */
+
+/* global define, require */
+
+(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;
+      }
+    }
+  });
+});

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

@@ -0,0 +1,347 @@
+/*
+ * 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
+ */
+
+/* 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',
+      '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';
+
+  // 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'
+    }
+  );
+
+  // 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
+    },
+
+    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();
+      },
+
+      // 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;
+      },
+
+      // 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)
+                  );
+                }
+              }
+              // 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,
+          // 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;
+      }
+    }
+  });
+});

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

@@ -0,0 +1,170 @@
+/*
+ * 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
+ */
+
+/* global define, require */
+
+(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,
+        // eslint-disable-next-line new-cap
+        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) {
+            // eslint-disable-next-line new-cap
+            return $.Deferred().rejectWith(that, [originalData]).promise();
+          }
+          return that.processActions[settings.action].call(
+            that,
+            data,
+            settings
+          );
+        };
+        chain = chain[that._promisePipe](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 processing 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) {
+                // eslint-disable-next-line new-cap
+                return $.Deferred().rejectWith(that, [data]).promise();
+              }
+              return that._processFile(opts, data);
+            };
+          opts.index = index;
+          that._processing += 1;
+          that._processingQueue = that._processingQueue[that._promisePipe](
+            func,
+            func
+          ).always(function () {
+            that._processing -= 1;
+            if (that._processing === 0) {
+              that._trigger('processstop');
+            }
+          });
+        });
+      }
+      return this._processingQueue;
+    },
+
+    _create: function () {
+      this._super();
+      this._processing = 0;
+      // eslint-disable-next-line new-cap
+      this._processingQueue = $.Deferred().resolveWith(this).promise();
+    }
+  });
+});