wp-includes/js/media-models.js

   1 window.wp = window.wp || {};
   2
   3 (function($){
   4         var Attachment, Attachments, Query, compare, l10n, media;
   5
   6         /**
   7          * wp.media( attributes )
   8          *
   9          * Handles the default media experience. Automatically creates
  10          * and opens a media frame, and returns the result.
  11          * Does nothing if the controllers do not exist.
  12          *
  13          * @param  {object} attributes The properties passed to the main media controller.
  14          * @return {object}            A media workflow.
  15          */
  16         media = wp.media = function( attributes ) {
  17                 var MediaFrame = media.view.MediaFrame,
  18                         frame;
  19
  20                 if ( ! MediaFrame )
  21                         return;
  22
  23                 attributes = _.defaults( attributes || {}, {
  24                         frame: 'select'
  25                 });
  26
  27                 if ( 'select' === attributes.frame && MediaFrame.Select )
  28                         frame = new MediaFrame.Select( attributes );
  29                 else if ( 'post' === attributes.frame && MediaFrame.Post )
  30                         frame = new MediaFrame.Post( attributes );
  31
  32                 delete attributes.frame;
  33
  34                 return frame;
  35         };
  36
  37         _.extend( media, { model: {}, view: {}, controller: {}, frames: {} });
  38
  39         // Link any localized strings.
  40         l10n = media.model.l10n = typeof _wpMediaModelsL10n === 'undefined' ? {} : _wpMediaModelsL10n;
  41
  42         // Link any settings.
  43         media.model.settings = l10n.settings || {};
  44         delete l10n.settings;
  45
  46         /**
  47          * ========================================================================
  48          * UTILITIES
  49          * ========================================================================
  50          */
  51
  52         /**
  53          * A basic comparator.
  54          *
  55          * @param  {mixed}  a  The primary parameter to compare.
  56          * @param  {mixed}  b  The primary parameter to compare.
  57          * @param  {string} ac The fallback parameter to compare, a's cid.
  58          * @param  {string} bc The fallback parameter to compare, b's cid.
  59          * @return {number}    -1: a should come before b.
  60          *                      0: a and b are of the same rank.
  61          *                      1: b should come before a.
  62          */
  63         compare = function( a, b, ac, bc ) {
  64                 if ( _.isEqual( a, b ) )
  65                         return ac === bc ? 0 : (ac > bc ? -1 : 1);
  66                 else
  67                         return a > b ? -1 : 1;
  68         };
  69
  70         _.extend( media, {
  71                 /**
  72                  * media.template( id )
  73                  *
  74                  * Fetches a template by id.
  75                  * See wp.template() in `wp-includes/js/wp-util.js`.
  76                  */
  77                 template: wp.template,
  78
  79                 /**
  80                  * media.post( [action], [data] )
  81                  *
  82                  * Sends a POST request to WordPress.
  83                  * See wp.ajax.post() in `wp-includes/js/wp-util.js`.
  84                  */
  85                 post: wp.ajax.post,
  86
  87                 /**
  88                  * media.ajax( [action], [options] )
  89                  *
  90                  * Sends an XHR request to WordPress.
  91                  * See wp.ajax.send() in `wp-includes/js/wp-util.js`.
  92                  */
  93                 ajax: wp.ajax.send,
  94
  95                 // Scales a set of dimensions to fit within bounding dimensions.
  96                 fit: function( dimensions ) {
  97                         var width     = dimensions.width,
  98                                 height    = dimensions.height,
  99                                 maxWidth  = dimensions.maxWidth,
 100                                 maxHeight = dimensions.maxHeight,
 101                                 constraint;
 102
 103                         // Compare ratios between the two values to determine which
 104                         // max to constrain by. If a max value doesn't exist, then the
 105                         // opposite side is the constraint.
 106                         if ( ! _.isUndefined( maxWidth ) && ! _.isUndefined( maxHeight ) ) {
 107                                 constraint = ( width / height > maxWidth / maxHeight ) ? 'width' : 'height';
 108                         } else if ( _.isUndefined( maxHeight ) ) {
 109                                 constraint = 'width';
 110                         } else if (  _.isUndefined( maxWidth ) && height > maxHeight ) {
 111                                 constraint = 'height';
 112                         }
 113
 114                         // If the value of the constrained side is larger than the max,
 115                         // then scale the values. Otherwise return the originals; they fit.
 116                         if ( 'width' === constraint && width > maxWidth ) {
 117                                 return {
 118                                         width : maxWidth,
 119                                         height: Math.round( maxWidth * height / width )
 120                                 };
 121                         } else if ( 'height' === constraint && height > maxHeight ) {
 122                                 return {
 123                                         width : Math.round( maxHeight * width / height ),
 124                                         height: maxHeight
 125                                 };
 126                         } else {
 127                                 return {
 128                                         width : width,
 129                                         height: height
 130                                 };
 131                         }
 132                 },
 133
 134                 // Truncates a string by injecting an ellipsis into the middle.
 135                 // Useful for filenames.
 136                 truncate: function( string, length, replacement ) {
 137                         length = length || 30;
 138                         replacement = replacement || '&hellip;';
 139
 140                         if ( string.length <= length )
 141                                 return string;
 142
 143                         return string.substr( 0, length / 2 ) + replacement + string.substr( -1 * length / 2 );
 144                 }
 145         });
 146
 147
 148         /**
 149          * ========================================================================
 150          * MODELS
 151          * ========================================================================
 152          */
 153
 154          /**
 155           * wp.media.attachment
 156           */
 157          media.attachment = function( id ) {
 158                 return Attachment.get( id );
 159          };
 160
 161         /**
 162          * wp.media.model.Attachment
 163          */
 164         Attachment = media.model.Attachment = Backbone.Model.extend({
 165                 sync: function( method, model, options ) {
 166                         // If the attachment does not yet have an `id`, return an instantly
 167                         // rejected promise. Otherwise, all of our requests will fail.
 168                         if ( _.isUndefined( this.id ) )
 169                                 return $.Deferred().rejectWith( this ).promise();
 170
 171                         // Overload the `read` request so Attachment.fetch() functions correctly.
 172                         if ( 'read' === method ) {
 173                                 options = options || {};
 174                                 options.context = this;
 175                                 options.data = _.extend( options.data || {}, {
 176                                         action: 'get-attachment',
 177                                         id: this.id
 178                                 });
 179                                 return media.ajax( options );
 180
 181                         // Overload the `update` request so properties can be saved.
 182                         } else if ( 'update' === method ) {
 183                                 // If we do not have the necessary nonce, fail immeditately.
 184                                 if ( ! this.get('nonces') || ! this.get('nonces').update )
 185                                         return $.Deferred().rejectWith( this ).promise();
 186
 187                                 options = options || {};
 188                                 options.context = this;
 189
 190                                 // Set the action and ID.
 191                                 options.data = _.extend( options.data || {}, {
 192                                         action:  'save-attachment',
 193                                         id:      this.id,
 194                                         nonce:   this.get('nonces').update,
 195                                         post_id: media.model.settings.post.id
 196                                 });
 197
 198                                 // Record the values of the changed attributes.
 199                                 if ( model.hasChanged() ) {
 200                                         options.data.changes = {};
 201
 202                                         _.each( model.changed, function( value, key ) {
 203                                                 options.data.changes[ key ] = this.get( key );
 204                                         }, this );
 205                                 }
 206
 207                                 return media.ajax( options );
 208
 209                         // Overload the `delete` request so attachments can be removed.
 210                         // This will permanently delete an attachment.
 211                         } else if ( 'delete' === method ) {
 212                                 options = options || {};
 213
 214                                 if ( ! options.wait )
 215                                         this.destroyed = true;
 216
 217                                 options.context = this;
 218                                 options.data = _.extend( options.data || {}, {
 219                                         action:   'delete-post',
 220                                         id:       this.id,
 221                                         _wpnonce: this.get('nonces')['delete']
 222                                 });
 223
 224                                 return media.ajax( options ).done( function() {
 225                                         this.destroyed = true;
 226                                 }).fail( function() {
 227                                         this.destroyed = false;
 228                                 });
 229
 230                         // Otherwise, fall back to `Backbone.sync()`.
 231                         } else {
 232                                 return Backbone.Model.prototype.sync.apply( this, arguments );
 233                         }
 234                 },
 235
 236                 parse: function( resp, xhr ) {
 237                         if ( ! resp )
 238                                 return resp;
 239
 240                         // Convert date strings into Date objects.
 241                         resp.date = new Date( resp.date );
 242                         resp.modified = new Date( resp.modified );
 243                         return resp;
 244                 },
 245
 246                 saveCompat: function( data, options ) {
 247                         var model = this;
 248
 249                         // If we do not have the necessary nonce, fail immeditately.
 250                         if ( ! this.get('nonces') || ! this.get('nonces').update )
 251                                 return $.Deferred().rejectWith( this ).promise();
 252
 253                         return media.post( 'save-attachment-compat', _.defaults({
 254                                 id:      this.id,
 255                                 nonce:   this.get('nonces').update,
 256                                 post_id: media.model.settings.post.id
 257                         }, data ) ).done( function( resp, status, xhr ) {
 258                                 model.set( model.parse( resp, xhr ), options );
 259                         });
 260                 }
 261         }, {
 262                 create: function( attrs ) {
 263                         return Attachments.all.push( attrs );
 264                 },
 265
 266                 get: _.memoize( function( id, attachment ) {
 267                         return Attachments.all.push( attachment || { id: id } );
 268                 })
 269         });
 270
 271         /**
 272          * wp.media.model.Attachments
 273          */
 274         Attachments = media.model.Attachments = Backbone.Collection.extend({
 275                 model: Attachment,
 276
 277                 initialize: function( models, options ) {
 278                         options = options || {};
 279
 280                         this.props   = new Backbone.Model();
 281                         this.filters = options.filters || {};
 282
 283                         // Bind default `change` events to the `props` model.
 284                         this.props.on( 'change', this._changeFilteredProps, this );
 285
 286                         this.props.on( 'change:order',   this._changeOrder,   this );
 287                         this.props.on( 'change:orderby', this._changeOrderby, this );
 288                         this.props.on( 'change:query',   this._changeQuery,   this );
 289
 290                         // Set the `props` model and fill the default property values.
 291                         this.props.set( _.defaults( options.props || {} ) );
 292
 293                         // Observe another `Attachments` collection if one is provided.
 294                         if ( options.observe )
 295                                 this.observe( options.observe );
 296                 },
 297
 298                 // Automatically sort the collection when the order changes.
 299                 _changeOrder: function( model, order ) {
 300                         if ( this.comparator )
 301                                 this.sort();
 302                 },
 303
 304                 // Set the default comparator only when the `orderby` property is set.
 305                 _changeOrderby: function( model, orderby ) {
 306                         // If a different comparator is defined, bail.
 307                         if ( this.comparator && this.comparator !== Attachments.comparator )
 308                                 return;
 309
 310                         if ( orderby && 'post__in' !== orderby )
 311                                 this.comparator = Attachments.comparator;
 312                         else
 313                                 delete this.comparator;
 314                 },
 315
 316                 // If the `query` property is set to true, query the server using
 317                 // the `props` values, and sync the results to this collection.
 318                 _changeQuery: function( model, query ) {
 319                         if ( query ) {
 320                                 this.props.on( 'change', this._requery, this );
 321                                 this._requery();
 322                         } else {
 323                                 this.props.off( 'change', this._requery, this );
 324                         }
 325                 },
 326
 327                 _changeFilteredProps: function( model, options ) {
 328                         // If this is a query, updating the collection will be handled by
 329                         // `this._requery()`.
 330                         if ( this.props.get('query') )
 331                                 return;
 332
 333                         var changed = _.chain( model.changed ).map( function( t, prop ) {
 334                                 var filter = Attachments.filters[ prop ],
 335                                         term = model.get( prop );
 336
 337                                 if ( ! filter )
 338                                         return;
 339
 340                                 if ( term && ! this.filters[ prop ] )
 341                                         this.filters[ prop ] = filter;
 342                                 else if ( ! term && this.filters[ prop ] === filter )
 343                                         delete this.filters[ prop ];
 344                                 else
 345                                         return;
 346
 347                                 // Record the change.
 348                                 return true;
 349                         }, this ).any().value();
 350
 351                         if ( ! changed )
 352                                 return;
 353
 354                         // If no `Attachments` model is provided to source the searches
 355                         // from, then automatically generate a source from the existing
 356                         // models.
 357                         if ( ! this._source )
 358                                 this._source = new Attachments( this.models );
 359
 360                         this.reset( this._source.filter( this.validator, this ) );
 361                 },
 362
 363                 validateDestroyed: false,
 364
 365                 validator: function( attachment ) {
 366                         if ( ! this.validateDestroyed && attachment.destroyed )
 367                                 return false;
 368                         return _.all( this.filters, function( filter, key ) {
 369                                 return !! filter.call( this, attachment );
 370                         }, this );
 371                 },
 372
 373                 validate: function( attachment, options ) {
 374                         var valid = this.validator( attachment ),
 375                                 hasAttachment = !! this.get( attachment.cid );
 376
 377                         if ( ! valid && hasAttachment )
 378                                 this.remove( attachment, options );
 379                         else if ( valid && ! hasAttachment )
 380                                 this.add( attachment, options );
 381
 382                         return this;
 383                 },
 384
 385                 validateAll: function( attachments, options ) {
 386                         options = options || {};
 387
 388                         _.each( attachments.models, function( attachment ) {
 389                                 this.validate( attachment, { silent: true });
 390                         }, this );
 391
 392                         if ( ! options.silent )
 393                                 this.trigger( 'reset', this, options );
 394
 395                         return this;
 396                 },
 397
 398                 observe: function( attachments ) {
 399                         this.observers = this.observers || [];
 400                         this.observers.push( attachments );
 401
 402                         attachments.on( 'add change remove', this._validateHandler, this );
 403                         attachments.on( 'reset', this._validateAllHandler, this );
 404                         this.validateAll( attachments );
 405                         return this;
 406                 },
 407
 408                 unobserve: function( attachments ) {
 409                         if ( attachments ) {
 410                                 attachments.off( null, null, this );
 411                                 this.observers = _.without( this.observers, attachments );
 412
 413                         } else {
 414                                 _.each( this.observers, function( attachments ) {
 415                                         attachments.off( null, null, this );
 416                                 }, this );
 417                                 delete this.observers;
 418                         }
 419
 420                         return this;
 421                 },
 422
 423                 _validateHandler: function( attachment, attachments, options ) {
 424                         // If we're not mirroring this `attachments` collection,
 425                         // only retain the `silent` option.
 426                         options = attachments === this.mirroring ? options : {
 427                                 silent: options && options.silent
 428                         };
 429
 430                         return this.validate( attachment, options );
 431                 },
 432
 433                 _validateAllHandler: function( attachments, options ) {
 434                         return this.validateAll( attachments, options );
 435                 },
 436
 437                 mirror: function( attachments ) {
 438                         if ( this.mirroring && this.mirroring === attachments )
 439                                 return this;
 440
 441                         this.unmirror();
 442                         this.mirroring = attachments;
 443
 444                         // Clear the collection silently. A `reset` event will be fired
 445                         // when `observe()` calls `validateAll()`.
 446                         this.reset( [], { silent: true } );
 447                         this.observe( attachments );
 448
 449                         return this;
 450                 },
 451
 452                 unmirror: function() {
 453                         if ( ! this.mirroring )
 454                                 return;
 455
 456                         this.unobserve( this.mirroring );
 457                         delete this.mirroring;
 458                 },
 459
 460                 more: function( options ) {
 461                         var deferred = $.Deferred(),
 462                                 mirroring = this.mirroring,
 463                                 attachments = this;
 464
 465                         if ( ! mirroring || ! mirroring.more )
 466                                 return deferred.resolveWith( this ).promise();
 467
 468                         // If we're mirroring another collection, forward `more` to
 469                         // the mirrored collection. Account for a race condition by
 470                         // checking if we're still mirroring that collection when
 471                         // the request resolves.
 472                         mirroring.more( options ).done( function() {
 473                                 if ( this === attachments.mirroring )
 474                                         deferred.resolveWith( this );
 475                         });
 476
 477                         return deferred.promise();
 478                 },
 479
 480                 hasMore: function() {
 481                         return this.mirroring ? this.mirroring.hasMore() : false;
 482                 },
 483
 484                 parse: function( resp, xhr ) {
 485                         if ( ! _.isArray( resp ) )
 486                                 resp = [resp];
 487
 488                         return _.map( resp, function( attrs ) {
 489                                 var id, attachment, newAttributes;
 490
 491                                 if ( attrs instanceof Backbone.Model ) {
 492                                         id = attrs.get( 'id' );
 493                                         attrs = attrs.attributes;
 494                                 } else {
 495                                         id = attrs.id;
 496                                 }
 497
 498                                 attachment = Attachment.get( id );
 499                                 newAttributes = attachment.parse( attrs, xhr );
 500
 501                                 if ( ! _.isEqual( attachment.attributes, newAttributes ) )
 502                                         attachment.set( newAttributes );
 503
 504                                 return attachment;
 505                         });
 506                 },
 507
 508                 _requery: function() {
 509                         if ( this.props.get('query') )
 510                                 this.mirror( Query.get( this.props.toJSON() ) );
 511                 },
 512
 513                 // If this collection is sorted by `menuOrder`, recalculates and saves
 514                 // the menu order to the database.
 515                 saveMenuOrder: function() {
 516                         if ( 'menuOrder' !== this.props.get('orderby') )
 517                                 return;
 518
 519                         // Removes any uploading attachments, updates each attachment's
 520                         // menu order, and returns an object with an { id: menuOrder }
 521                         // mapping to pass to the request.
 522                         var attachments = this.chain().filter( function( attachment ) {
 523                                 return ! _.isUndefined( attachment.id );
 524                         }).map( function( attachment, index ) {
 525                                 // Indices start at 1.
 526                                 index = index + 1;
 527                                 attachment.set( 'menuOrder', index );
 528                                 return [ attachment.id, index ];
 529                         }).object().value();
 530
 531                         if ( _.isEmpty( attachments ) )
 532                                 return;
 533
 534                         return media.post( 'save-attachment-order', {
 535                                 nonce:       media.model.settings.post.nonce,
 536                                 post_id:     media.model.settings.post.id,
 537                                 attachments: attachments
 538                         });
 539                 }
 540         }, {
 541                 comparator: function( a, b, options ) {
 542                         var key   = this.props.get('orderby'),
 543                                 order = this.props.get('order') || 'DESC',
 544                                 ac    = a.cid,
 545                                 bc    = b.cid;
 546
 547                         a = a.get( key );
 548                         b = b.get( key );
 549
 550                         if ( 'date' === key || 'modified' === key ) {
 551                                 a = a || new Date();
 552                                 b = b || new Date();
 553                         }
 554
 555                         // If `options.ties` is set, don't enforce the `cid` tiebreaker.
 556                         if ( options && options.ties )
 557                                 ac = bc = null;
 558
 559                         return ( 'DESC' === order ) ? compare( a, b, ac, bc ) : compare( b, a, bc, ac );
 560                 },
 561
 562                 filters: {
 563                         // Note that this client-side searching is *not* equivalent
 564                         // to our server-side searching.
 565                         search: function( attachment ) {
 566                                 if ( ! this.props.get('search') )
 567                                         return true;
 568
 569                                 return _.any(['title','filename','description','caption','name'], function( key ) {
 570                                         var value = attachment.get( key );
 571                                         return value && -1 !== value.search( this.props.get('search') );
 572                                 }, this );
 573                         },
 574
 575                         type: function( attachment ) {
 576                                 var type = this.props.get('type');
 577                                 return ! type || -1 !== type.indexOf( attachment.get('type') );
 578                         },
 579
 580                         uploadedTo: function( attachment ) {
 581                                 var uploadedTo = this.props.get('uploadedTo');
 582                                 if ( _.isUndefined( uploadedTo ) )
 583                                         return true;
 584
 585                                 return uploadedTo === attachment.get('uploadedTo');
 586                         }
 587                 }
 588         });
 589
 590         Attachments.all = new Attachments();
 591
 592         /**
 593          * wp.media.query
 594          */
 595         media.query = function( props ) {
 596                 return new Attachments( null, {
 597                         props: _.extend( _.defaults( props || {}, { orderby: 'date' } ), { query: true } )
 598                 });
 599         };
 600
 601         /**
 602          * wp.media.model.Query
 603          *
 604          * A set of attachments that corresponds to a set of consecutively paged
 605          * queries on the server.
 606          *
 607          * Note: Do NOT change this.args after the query has been initialized.
 608          *       Things will break.
 609          */
 610         Query = media.model.Query = Attachments.extend({
 611                 initialize: function( models, options ) {
 612                         var allowed;
 613
 614                         options = options || {};
 615                         Attachments.prototype.initialize.apply( this, arguments );
 616
 617                         this.args     = options.args;
 618                         this._hasMore = true;
 619                         this.created  = new Date();
 620
 621                         this.filters.order = function( attachment ) {
 622                                 var orderby = this.props.get('orderby'),
 623                                         order = this.props.get('order');
 624
 625                                 if ( ! this.comparator )
 626                                         return true;
 627
 628                                 // We want any items that can be placed before the last
 629                                 // item in the set. If we add any items after the last
 630                                 // item, then we can't guarantee the set is complete.
 631                                 if ( this.length ) {
 632                                         return 1 !== this.comparator( attachment, this.last(), { ties: true });
 633
 634                                 // Handle the case where there are no items yet and
 635                                 // we're sorting for recent items. In that case, we want
 636                                 // changes that occurred after we created the query.
 637                                 } else if ( 'DESC' === order && ( 'date' === orderby || 'modified' === orderby ) ) {
 638                                         return attachment.get( orderby ) >= this.created;
 639
 640                                 // If we're sorting by menu order and we have no items,
 641                                 // accept any items that have the default menu order (0).
 642                                 } else if ( 'ASC' === order && 'menuOrder' === orderby ) {
 643                                         return attachment.get( orderby ) === 0;
 644                                 }
 645
 646                                 // Otherwise, we don't want any items yet.
 647                                 return false;
 648                         };
 649
 650                         // Observe the central `wp.Uploader.queue` collection to watch for
 651                         // new matches for the query.
 652                         //
 653                         // Only observe when a limited number of query args are set. There
 654                         // are no filters for other properties, so observing will result in
 655                         // false positives in those queries.
 656                         allowed = [ 's', 'order', 'orderby', 'posts_per_page', 'post_mime_type', 'post_parent' ];
 657                         if ( wp.Uploader && _( this.args ).chain().keys().difference( allowed ).isEmpty().value() )
 658                                 this.observe( wp.Uploader.queue );
 659                 },
 660
 661                 hasMore: function() {
 662                         return this._hasMore;
 663                 },
 664
 665                 more: function( options ) {
 666                         var query = this;
 667
 668                         if ( this._more && 'pending' === this._more.state() )
 669                                 return this._more;
 670
 671                         if ( ! this.hasMore() )
 672                                 return $.Deferred().resolveWith( this ).promise();
 673
 674                         options = options || {};
 675                         options.remove = false;
 676
 677                         return this._more = this.fetch( options ).done( function( resp ) {
 678                                 if ( _.isEmpty( resp ) || -1 === this.args.posts_per_page || resp.length < this.args.posts_per_page )
 679                                         query._hasMore = false;
 680                         });
 681                 },
 682
 683                 sync: function( method, model, options ) {
 684                         var fallback;
 685
 686                         // Overload the read method so Attachment.fetch() functions correctly.
 687                         if ( 'read' === method ) {
 688                                 options = options || {};
 689                                 options.context = this;
 690                                 options.data = _.extend( options.data || {}, {
 691                                         action:  'query-attachments',
 692                                         post_id: media.model.settings.post.id
 693                                 });
 694
 695                                 // Clone the args so manipulation is non-destructive.
 696                                 args = _.clone( this.args );
 697
 698                                 // Determine which page to query.
 699                                 if ( -1 !== args.posts_per_page )
 700                                         args.paged = Math.floor( this.length / args.posts_per_page ) + 1;
 701
 702                                 options.data.query = args;
 703                                 return media.ajax( options );
 704
 705                         // Otherwise, fall back to Backbone.sync()
 706                         } else {
 707                                 fallback = Attachments.prototype.sync ? Attachments.prototype : Backbone;
 708                                 return fallback.sync.apply( this, arguments );
 709                         }
 710                 }
 711         }, {
 712                 defaultProps: {
 713                         orderby: 'date',
 714                         order:   'DESC'
 715                 },
 716
 717                 defaultArgs: {
 718                         posts_per_page: 40
 719                 },
 720
 721                 orderby: {
 722                         allowed:  [ 'name', 'author', 'date', 'title', 'modified', 'uploadedTo', 'id', 'post__in', 'menuOrder' ],
 723                         valuemap: {
 724                                 'id':         'ID',
 725                                 'uploadedTo': 'parent',
 726                                 'menuOrder':  'menu_order ID'
 727                         }
 728                 },
 729
 730                 propmap: {
 731                         'search':    's',
 732                         'type':      'post_mime_type',
 733                         'perPage':   'posts_per_page',
 734                         'menuOrder': 'menu_order',
 735                         'uploadedTo': 'post_parent'
 736                 },
 737
 738                 // Caches query objects so queries can be easily reused.
 739                 get: (function(){
 740                         var queries = [];
 741
 742                         return function( props, options ) {
 743                                 var args     = {},
 744                                         orderby  = Query.orderby,
 745                                         defaults = Query.defaultProps,
 746                                         query;
 747
 748                                 // Remove the `query` property. This isn't linked to a query,
 749                                 // this *is* the query.
 750                                 delete props.query;
 751
 752                                 // Fill default args.
 753                                 _.defaults( props, defaults );
 754
 755                                 // Normalize the order.
 756                                 props.order = props.order.toUpperCase();
 757                                 if ( 'DESC' !== props.order && 'ASC' !== props.order )
 758                                         props.order = defaults.order.toUpperCase();
 759
 760                                 // Ensure we have a valid orderby value.
 761                                 if ( ! _.contains( orderby.allowed, props.orderby ) )
 762                                         props.orderby = defaults.orderby;
 763
 764                                 // Generate the query `args` object.
 765                                 // Correct any differing property names.
 766                                 _.each( props, function( value, prop ) {
 767                                         if ( _.isNull( value ) )
 768                                                 return;
 769
 770                                         args[ Query.propmap[ prop ] || prop ] = value;
 771                                 });
 772
 773                                 // Fill any other default query args.
 774                                 _.defaults( args, Query.defaultArgs );
 775
 776                                 // `props.orderby` does not always map directly to `args.orderby`.
 777                                 // Substitute exceptions specified in orderby.keymap.
 778                                 args.orderby = orderby.valuemap[ props.orderby ] || props.orderby;
 779
 780                                 // Search the query cache for matches.
 781                                 query = _.find( queries, function( query ) {
 782                                         return _.isEqual( query.args, args );
 783                                 });
 784
 785                                 // Otherwise, create a new query and add it to the cache.
 786                                 if ( ! query ) {
 787                                         query = new Query( [], _.extend( options || {}, {
 788                                                 props: props,
 789                                                 args:  args
 790                                         } ) );
 791                                         queries.push( query );
 792                                 }
 793
 794                                 return query;
 795                         };
 796                 }())
 797         });
 798
 799         /**
 800          * wp.media.model.Selection
 801          *
 802          * Used to manage a selection of attachments in the views.
 803          */
 804         media.model.Selection = Attachments.extend({
 805                 initialize: function( models, options ) {
 806                         Attachments.prototype.initialize.apply( this, arguments );
 807                         this.multiple = options && options.multiple;
 808
 809                         // Refresh the `single` model whenever the selection changes.
 810                         // Binds `single` instead of using the context argument to ensure
 811                         // it receives no parameters.
 812                         this.on( 'add remove reset', _.bind( this.single, this, false ) );
 813                 },
 814
 815                 // Override the selection's add method.
 816                 // If the workflow does not support multiple
 817                 // selected attachments, reset the selection.
 818                 add: function( models, options ) {
 819                         if ( ! this.multiple )
 820                                 this.remove( this.models );
 821
 822                         return Attachments.prototype.add.call( this, models, options );
 823                 },
 824
 825                 single: function( model ) {
 826                         var previous = this._single;
 827
 828                         // If a `model` is provided, use it as the single model.
 829                         if ( model )
 830                                 this._single = model;
 831
 832                         // If the single model isn't in the selection, remove it.
 833                         if ( this._single && ! this.get( this._single.cid ) )
 834                                 delete this._single;
 835
 836                         this._single = this._single || this.last();
 837
 838                         // If single has changed, fire an event.
 839                         if ( this._single !== previous ) {
 840                                 if ( previous ) {
 841                                         previous.trigger( 'selection:unsingle', previous, this );
 842
 843                                         // If the model was already removed, trigger the collection
 844                                         // event manually.
 845                                         if ( ! this.get( previous.cid ) )
 846                                                 this.trigger( 'selection:unsingle', previous, this );
 847                                 }
 848                                 if ( this._single )
 849                                         this._single.trigger( 'selection:single', this._single, this );
 850                         }
 851
 852                         // Return the single model, or the last model as a fallback.
 853                         return this._single;
 854                 }
 855         });
 856
 857         // Clean up. Prevents mobile browsers caching
 858         $(window).on('unload', function(){
 859                 window.wp = null;
 860         });
 861
 862 }(jQuery));