572 lines
16 KiB
JavaScript
572 lines
16 KiB
JavaScript
/* global pluploadL10n, plupload, _wpPluploadSettings */
|
|
|
|
/**
|
|
* @namespace wp
|
|
*/
|
|
window.wp = window.wp || {};
|
|
|
|
( function( exports, $ ) {
|
|
var Uploader;
|
|
|
|
if ( typeof _wpPluploadSettings === 'undefined' ) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* A WordPress uploader.
|
|
*
|
|
* The Plupload library provides cross-browser uploader UI integration.
|
|
* This object bridges the Plupload API to integrate uploads into the
|
|
* WordPress back end and the WordPress media experience.
|
|
*
|
|
* @class
|
|
* @memberOf wp
|
|
* @alias wp.Uploader
|
|
*
|
|
* @param {object} options The options passed to the new plupload instance.
|
|
* @param {object} options.container The id of uploader container.
|
|
* @param {object} options.browser The id of button to trigger the file select.
|
|
* @param {object} options.dropzone The id of file drop target.
|
|
* @param {object} options.plupload An object of parameters to pass to the plupload instance.
|
|
* @param {object} options.params An object of parameters to pass to $_POST when uploading the file.
|
|
* Extends this.plupload.multipart_params under the hood.
|
|
*/
|
|
Uploader = function( options ) {
|
|
var self = this,
|
|
isIE, // Not used, back-compat.
|
|
elements = {
|
|
container: 'container',
|
|
browser: 'browse_button',
|
|
dropzone: 'drop_element'
|
|
},
|
|
tryAgainCount = {},
|
|
tryAgain,
|
|
key,
|
|
error,
|
|
fileUploaded;
|
|
|
|
this.supports = {
|
|
upload: Uploader.browser.supported
|
|
};
|
|
|
|
this.supported = this.supports.upload;
|
|
|
|
if ( ! this.supported ) {
|
|
return;
|
|
}
|
|
|
|
// Arguments to send to pluplad.Uploader().
|
|
// Use deep extend to ensure that multipart_params and other objects are cloned.
|
|
this.plupload = $.extend( true, { multipart_params: {} }, Uploader.defaults );
|
|
this.container = document.body; // Set default container.
|
|
|
|
/*
|
|
* Extend the instance with options.
|
|
*
|
|
* Use deep extend to allow options.plupload to override individual
|
|
* default plupload keys.
|
|
*/
|
|
$.extend( true, this, options );
|
|
|
|
// Proxy all methods so this always refers to the current instance.
|
|
for ( key in this ) {
|
|
if ( typeof this[ key ] === 'function' ) {
|
|
this[ key ] = $.proxy( this[ key ], this );
|
|
}
|
|
}
|
|
|
|
// Ensure all elements are jQuery elements and have id attributes,
|
|
// then set the proper plupload arguments to the ids.
|
|
for ( key in elements ) {
|
|
if ( ! this[ key ] ) {
|
|
continue;
|
|
}
|
|
|
|
this[ key ] = $( this[ key ] ).first();
|
|
|
|
if ( ! this[ key ].length ) {
|
|
delete this[ key ];
|
|
continue;
|
|
}
|
|
|
|
if ( ! this[ key ].prop('id') ) {
|
|
this[ key ].prop( 'id', '__wp-uploader-id-' + Uploader.uuid++ );
|
|
}
|
|
|
|
this.plupload[ elements[ key ] ] = this[ key ].prop('id');
|
|
}
|
|
|
|
// If the uploader has neither a browse button nor a dropzone, bail.
|
|
if ( ! ( this.browser && this.browser.length ) && ! ( this.dropzone && this.dropzone.length ) ) {
|
|
return;
|
|
}
|
|
|
|
// Initialize the plupload instance.
|
|
this.uploader = new plupload.Uploader( this.plupload );
|
|
delete this.plupload;
|
|
|
|
// Set default params and remove this.params alias.
|
|
this.param( this.params || {} );
|
|
delete this.params;
|
|
|
|
/**
|
|
* Attempt to create image sub-sizes when an image was uploaded successfully
|
|
* but the server responded with HTTP 5xx error.
|
|
*
|
|
* @since 5.3.0
|
|
*
|
|
* @param {string} message Error message.
|
|
* @param {object} data Error data from Plupload.
|
|
* @param {plupload.File} file File that was uploaded.
|
|
*/
|
|
tryAgain = function( message, data, file ) {
|
|
var times, id;
|
|
|
|
if ( ! data || ! data.responseHeaders ) {
|
|
error( pluploadL10n.http_error_image, data, file, 'no-retry' );
|
|
return;
|
|
}
|
|
|
|
id = data.responseHeaders.match( /x-wp-upload-attachment-id:\s*(\d+)/i );
|
|
|
|
if ( id && id[1] ) {
|
|
id = id[1];
|
|
} else {
|
|
error( pluploadL10n.http_error_image, data, file, 'no-retry' );
|
|
return;
|
|
}
|
|
|
|
times = tryAgainCount[ file.id ];
|
|
|
|
if ( times && times > 4 ) {
|
|
/*
|
|
* The file may have been uploaded and attachment post created,
|
|
* but post-processing and resizing failed...
|
|
* Do a cleanup then tell the user to scale down the image and upload it again.
|
|
*/
|
|
$.ajax({
|
|
type: 'post',
|
|
url: ajaxurl,
|
|
dataType: 'json',
|
|
data: {
|
|
action: 'media-create-image-subsizes',
|
|
_wpnonce: _wpPluploadSettings.defaults.multipart_params._wpnonce,
|
|
attachment_id: id,
|
|
_wp_upload_failed_cleanup: true,
|
|
}
|
|
});
|
|
|
|
error( message, data, file, 'no-retry' );
|
|
return;
|
|
}
|
|
|
|
if ( ! times ) {
|
|
tryAgainCount[ file.id ] = 1;
|
|
} else {
|
|
tryAgainCount[ file.id ] = ++times;
|
|
}
|
|
|
|
// Another request to try to create the missing image sub-sizes.
|
|
$.ajax({
|
|
type: 'post',
|
|
url: ajaxurl,
|
|
dataType: 'json',
|
|
data: {
|
|
action: 'media-create-image-subsizes',
|
|
_wpnonce: _wpPluploadSettings.defaults.multipart_params._wpnonce,
|
|
attachment_id: id,
|
|
}
|
|
}).done( function( response ) {
|
|
if ( response.success ) {
|
|
fileUploaded( self.uploader, file, response );
|
|
} else {
|
|
if ( response.data && response.data.message ) {
|
|
message = response.data.message;
|
|
}
|
|
|
|
error( message, data, file, 'no-retry' );
|
|
}
|
|
}).fail( function( jqXHR ) {
|
|
// If another HTTP 5xx error, try try again...
|
|
if ( jqXHR.status >= 500 && jqXHR.status < 600 ) {
|
|
tryAgain( message, data, file );
|
|
return;
|
|
}
|
|
|
|
error( message, data, file, 'no-retry' );
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Custom error callback.
|
|
*
|
|
* Add a new error to the errors collection, so other modules can track
|
|
* and display errors. @see wp.Uploader.errors.
|
|
*
|
|
* @param {string} message Error message.
|
|
* @param {object} data Error data from Plupload.
|
|
* @param {plupload.File} file File that was uploaded.
|
|
* @param {string} retry Whether to try again to create image sub-sizes. Passing 'no-retry' will prevent it.
|
|
*/
|
|
error = function( message, data, file, retry ) {
|
|
var isImage = file.type && file.type.indexOf( 'image/' ) === 0,
|
|
status = data && data.status;
|
|
|
|
// If the file is an image and the error is HTTP 5xx try to create sub-sizes again.
|
|
if ( retry !== 'no-retry' && isImage && status >= 500 && status < 600 ) {
|
|
tryAgain( message, data, file );
|
|
return;
|
|
}
|
|
|
|
if ( file.attachment ) {
|
|
file.attachment.destroy();
|
|
}
|
|
|
|
Uploader.errors.unshift({
|
|
message: message || pluploadL10n.default_error,
|
|
data: data,
|
|
file: file
|
|
});
|
|
|
|
self.error( message, data, file );
|
|
};
|
|
|
|
/**
|
|
* After a file is successfully uploaded, update its model.
|
|
*
|
|
* @param {plupload.Uploader} up Uploader instance.
|
|
* @param {plupload.File} file File that was uploaded.
|
|
* @param {Object} response Object with response properties.
|
|
*/
|
|
fileUploaded = function( up, file, response ) {
|
|
var complete;
|
|
|
|
// Remove the "uploading" UI elements.
|
|
_.each( ['file','loaded','size','percent'], function( key ) {
|
|
file.attachment.unset( key );
|
|
} );
|
|
|
|
file.attachment.set( _.extend( response.data, { uploading: false } ) );
|
|
|
|
wp.media.model.Attachment.get( response.data.id, file.attachment );
|
|
|
|
complete = Uploader.queue.all( function( attachment ) {
|
|
return ! attachment.get( 'uploading' );
|
|
});
|
|
|
|
if ( complete ) {
|
|
Uploader.queue.reset();
|
|
}
|
|
|
|
self.success( file.attachment );
|
|
}
|
|
|
|
/**
|
|
* After the Uploader has been initialized, initialize some behaviors for the dropzone.
|
|
*
|
|
* @param {plupload.Uploader} uploader Uploader instance.
|
|
*/
|
|
this.uploader.bind( 'init', function( uploader ) {
|
|
var timer, active, dragdrop,
|
|
dropzone = self.dropzone;
|
|
|
|
dragdrop = self.supports.dragdrop = uploader.features.dragdrop && ! Uploader.browser.mobile;
|
|
|
|
// Generate drag/drop helper classes.
|
|
if ( ! dropzone ) {
|
|
return;
|
|
}
|
|
|
|
dropzone.toggleClass( 'supports-drag-drop', !! dragdrop );
|
|
|
|
if ( ! dragdrop ) {
|
|
return dropzone.unbind('.wp-uploader');
|
|
}
|
|
|
|
// 'dragenter' doesn't fire correctly, simulate it with a limited 'dragover'.
|
|
dropzone.on( 'dragover.wp-uploader', function() {
|
|
if ( timer ) {
|
|
clearTimeout( timer );
|
|
}
|
|
|
|
if ( active ) {
|
|
return;
|
|
}
|
|
|
|
dropzone.trigger('dropzone:enter').addClass('drag-over');
|
|
active = true;
|
|
});
|
|
|
|
dropzone.on('dragleave.wp-uploader, drop.wp-uploader', function() {
|
|
/*
|
|
* Using an instant timer prevents the drag-over class
|
|
* from being quickly removed and re-added when elements
|
|
* inside the dropzone are repositioned.
|
|
*
|
|
* @see https://core.trac.wordpress.org/ticket/21705
|
|
*/
|
|
timer = setTimeout( function() {
|
|
active = false;
|
|
dropzone.trigger('dropzone:leave').removeClass('drag-over');
|
|
}, 0 );
|
|
});
|
|
|
|
self.ready = true;
|
|
$(self).trigger( 'uploader:ready' );
|
|
});
|
|
|
|
this.uploader.bind( 'postinit', function( up ) {
|
|
up.refresh();
|
|
self.init();
|
|
});
|
|
|
|
this.uploader.init();
|
|
|
|
if ( this.browser ) {
|
|
this.browser.on( 'mouseenter', this.refresh );
|
|
} else {
|
|
this.uploader.disableBrowse( true );
|
|
}
|
|
|
|
$( self ).on( 'uploader:ready', function() {
|
|
$( '.moxie-shim-html5 input[type="file"]' )
|
|
.attr( {
|
|
tabIndex: '-1',
|
|
'aria-hidden': 'true'
|
|
} );
|
|
} );
|
|
|
|
/**
|
|
* After files were filtered and added to the queue, create a model for each.
|
|
*
|
|
* @param {plupload.Uploader} up Uploader instance.
|
|
* @param {Array} files Array of file objects that were added to queue by the user.
|
|
*/
|
|
this.uploader.bind( 'FilesAdded', function( up, files ) {
|
|
_.each( files, function( file ) {
|
|
var attributes, image;
|
|
|
|
// Ignore failed uploads.
|
|
if ( plupload.FAILED === file.status ) {
|
|
return;
|
|
}
|
|
|
|
if ( file.type === 'image/heic' && up.settings.heic_upload_error ) {
|
|
// Show error but do not block uploading.
|
|
Uploader.errors.unshift({
|
|
message: pluploadL10n.unsupported_image,
|
|
data: {},
|
|
file: file
|
|
});
|
|
}
|
|
|
|
// Generate attributes for a new `Attachment` model.
|
|
attributes = _.extend({
|
|
file: file,
|
|
uploading: true,
|
|
date: new Date(),
|
|
filename: file.name,
|
|
menuOrder: 0,
|
|
uploadedTo: wp.media.model.settings.post.id
|
|
}, _.pick( file, 'loaded', 'size', 'percent' ) );
|
|
|
|
// Handle early mime type scanning for images.
|
|
image = /(?:jpe?g|png|gif)$/i.exec( file.name );
|
|
|
|
// For images set the model's type and subtype attributes.
|
|
if ( image ) {
|
|
attributes.type = 'image';
|
|
|
|
// `jpeg`, `png` and `gif` are valid subtypes.
|
|
// `jpg` is not, so map it to `jpeg`.
|
|
attributes.subtype = ( 'jpg' === image[0] ) ? 'jpeg' : image[0];
|
|
}
|
|
|
|
// Create a model for the attachment, and add it to the Upload queue collection
|
|
// so listeners to the upload queue can track and display upload progress.
|
|
file.attachment = wp.media.model.Attachment.create( attributes );
|
|
Uploader.queue.add( file.attachment );
|
|
|
|
self.added( file.attachment );
|
|
});
|
|
|
|
up.refresh();
|
|
up.start();
|
|
});
|
|
|
|
this.uploader.bind( 'UploadProgress', function( up, file ) {
|
|
file.attachment.set( _.pick( file, 'loaded', 'percent' ) );
|
|
self.progress( file.attachment );
|
|
});
|
|
|
|
/**
|
|
* After a file is successfully uploaded, update its model.
|
|
*
|
|
* @param {plupload.Uploader} up Uploader instance.
|
|
* @param {plupload.File} file File that was uploaded.
|
|
* @param {Object} response Object with response properties.
|
|
* @return {mixed}
|
|
*/
|
|
this.uploader.bind( 'FileUploaded', function( up, file, response ) {
|
|
|
|
try {
|
|
response = JSON.parse( response.response );
|
|
} catch ( e ) {
|
|
return error( pluploadL10n.default_error, e, file );
|
|
}
|
|
|
|
if ( ! _.isObject( response ) || _.isUndefined( response.success ) ) {
|
|
return error( pluploadL10n.default_error, null, file );
|
|
} else if ( ! response.success ) {
|
|
return error( response.data && response.data.message, response.data, file );
|
|
}
|
|
|
|
// Success. Update the UI with the new attachment.
|
|
fileUploaded( up, file, response );
|
|
});
|
|
|
|
/**
|
|
* When plupload surfaces an error, send it to the error handler.
|
|
*
|
|
* @param {plupload.Uploader} up Uploader instance.
|
|
* @param {Object} pluploadError Contains code, message and sometimes file and other details.
|
|
*/
|
|
this.uploader.bind( 'Error', function( up, pluploadError ) {
|
|
var message = pluploadL10n.default_error,
|
|
key;
|
|
|
|
// Check for plupload errors.
|
|
for ( key in Uploader.errorMap ) {
|
|
if ( pluploadError.code === plupload[ key ] ) {
|
|
message = Uploader.errorMap[ key ];
|
|
|
|
if ( typeof message === 'function' ) {
|
|
message = message( pluploadError.file, pluploadError );
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
error( message, pluploadError, pluploadError.file );
|
|
up.refresh();
|
|
});
|
|
|
|
};
|
|
|
|
// Adds the 'defaults' and 'browser' properties.
|
|
$.extend( Uploader, _wpPluploadSettings );
|
|
|
|
Uploader.uuid = 0;
|
|
|
|
// Map Plupload error codes to user friendly error messages.
|
|
Uploader.errorMap = {
|
|
'FAILED': pluploadL10n.upload_failed,
|
|
'FILE_EXTENSION_ERROR': pluploadL10n.invalid_filetype,
|
|
'IMAGE_FORMAT_ERROR': pluploadL10n.not_an_image,
|
|
'IMAGE_MEMORY_ERROR': pluploadL10n.image_memory_exceeded,
|
|
'IMAGE_DIMENSIONS_ERROR': pluploadL10n.image_dimensions_exceeded,
|
|
'GENERIC_ERROR': pluploadL10n.upload_failed,
|
|
'IO_ERROR': pluploadL10n.io_error,
|
|
'SECURITY_ERROR': pluploadL10n.security_error,
|
|
|
|
'FILE_SIZE_ERROR': function( file ) {
|
|
return pluploadL10n.file_exceeds_size_limit.replace( '%s', file.name );
|
|
},
|
|
|
|
'HTTP_ERROR': function( file ) {
|
|
if ( file.type && file.type.indexOf( 'image/' ) === 0 ) {
|
|
return pluploadL10n.http_error_image;
|
|
}
|
|
|
|
return pluploadL10n.http_error;
|
|
},
|
|
};
|
|
|
|
$.extend( Uploader.prototype, /** @lends wp.Uploader.prototype */{
|
|
/**
|
|
* Acts as a shortcut to extending the uploader's multipart_params object.
|
|
*
|
|
* param( key )
|
|
* Returns the value of the key.
|
|
*
|
|
* param( key, value )
|
|
* Sets the value of a key.
|
|
*
|
|
* param( map )
|
|
* Sets values for a map of data.
|
|
*/
|
|
param: function( key, value ) {
|
|
if ( arguments.length === 1 && typeof key === 'string' ) {
|
|
return this.uploader.settings.multipart_params[ key ];
|
|
}
|
|
|
|
if ( arguments.length > 1 ) {
|
|
this.uploader.settings.multipart_params[ key ] = value;
|
|
} else {
|
|
$.extend( this.uploader.settings.multipart_params, key );
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Make a few internal event callbacks available on the wp.Uploader object
|
|
* to change the Uploader internals if absolutely necessary.
|
|
*/
|
|
init: function() {},
|
|
error: function() {},
|
|
success: function() {},
|
|
added: function() {},
|
|
progress: function() {},
|
|
complete: function() {},
|
|
refresh: function() {
|
|
var node, attached, container, id;
|
|
|
|
if ( this.browser ) {
|
|
node = this.browser[0];
|
|
|
|
// Check if the browser node is in the DOM.
|
|
while ( node ) {
|
|
if ( node === document.body ) {
|
|
attached = true;
|
|
break;
|
|
}
|
|
node = node.parentNode;
|
|
}
|
|
|
|
/*
|
|
* If the browser node is not attached to the DOM,
|
|
* use a temporary container to house it, as the browser button shims
|
|
* require the button to exist in the DOM at all times.
|
|
*/
|
|
if ( ! attached ) {
|
|
id = 'wp-uploader-browser-' + this.uploader.id;
|
|
|
|
container = $( '#' + id );
|
|
if ( ! container.length ) {
|
|
container = $('<div class="wp-uploader-browser" />').css({
|
|
position: 'fixed',
|
|
top: '-1000px',
|
|
left: '-1000px',
|
|
height: 0,
|
|
width: 0
|
|
}).attr( 'id', 'wp-uploader-browser-' + this.uploader.id ).appendTo('body');
|
|
}
|
|
|
|
container.append( this.browser );
|
|
}
|
|
}
|
|
|
|
this.uploader.refresh();
|
|
}
|
|
});
|
|
|
|
// Create a collection of attachments in the upload queue,
|
|
// so that other modules can track and display upload progress.
|
|
Uploader.queue = new wp.media.model.Attachments( [], { query: false });
|
|
|
|
// Create a collection to collect errors incurred while attempting upload.
|
|
Uploader.errors = new Backbone.Collection();
|
|
|
|
exports.Uploader = Uploader;
|
|
})( wp, jQuery );
|