[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

/wp-includes/js/ -> wp-api.js (source)

   1  /**
   2   * @output wp-includes/js/wp-api.js
   3   */
   4  
   5  (function( window, undefined ) {
   6  
   7      'use strict';
   8  
   9      /**
  10       * Initialise the WP_API.
  11       */
  12  	function WP_API() {
  13          /** @namespace wp.api.models */
  14          this.models = {};
  15          /** @namespace wp.api.collections */
  16          this.collections = {};
  17          /** @namespace wp.api.views */
  18          this.views = {};
  19      }
  20  
  21      /** @namespace wp */
  22      window.wp            = window.wp || {};
  23      /** @namespace wp.api */
  24      wp.api               = wp.api || new WP_API();
  25      wp.api.versionString = wp.api.versionString || 'wp/v2/';
  26  
  27      // Alias _includes to _.contains, ensuring it is available if lodash is used.
  28      if ( ! _.isFunction( _.includes ) && _.isFunction( _.contains ) ) {
  29        _.includes = _.contains;
  30      }
  31  
  32  })( window );
  33  
  34  (function( window, undefined ) {
  35  
  36      'use strict';
  37  
  38      var pad, r;
  39  
  40      /** @namespace wp */
  41      window.wp = window.wp || {};
  42      /** @namespace wp.api */
  43      wp.api = wp.api || {};
  44      /** @namespace wp.api.utils */
  45      wp.api.utils = wp.api.utils || {};
  46  
  47      /**
  48       * Determine model based on API route.
  49       *
  50       * @param {string} route    The API route.
  51       *
  52       * @return {Backbone Model} The model found at given route. Undefined if not found.
  53       */
  54      wp.api.getModelByRoute = function( route ) {
  55          return _.find( wp.api.models, function( model ) {
  56              return model.prototype.route && route === model.prototype.route.index;
  57          } );
  58      };
  59  
  60      /**
  61       * Determine collection based on API route.
  62       *
  63       * @param {string} route    The API route.
  64       *
  65       * @return {Backbone Model} The collection found at given route. Undefined if not found.
  66       */
  67      wp.api.getCollectionByRoute = function( route ) {
  68          return _.find( wp.api.collections, function( collection ) {
  69              return collection.prototype.route && route === collection.prototype.route.index;
  70          } );
  71      };
  72  
  73  
  74      /**
  75       * ECMAScript 5 shim, adapted from MDN.
  76       * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString
  77       */
  78      if ( ! Date.prototype.toISOString ) {
  79          pad = function( number ) {
  80              r = String( number );
  81              if ( 1 === r.length ) {
  82                  r = '0' + r;
  83              }
  84  
  85              return r;
  86          };
  87  
  88          Date.prototype.toISOString = function() {
  89              return this.getUTCFullYear() +
  90                  '-' + pad( this.getUTCMonth() + 1 ) +
  91                  '-' + pad( this.getUTCDate() ) +
  92                  'T' + pad( this.getUTCHours() ) +
  93                  ':' + pad( this.getUTCMinutes() ) +
  94                  ':' + pad( this.getUTCSeconds() ) +
  95                  '.' + String( ( this.getUTCMilliseconds() / 1000 ).toFixed( 3 ) ).slice( 2, 5 ) +
  96                  'Z';
  97          };
  98      }
  99  
 100      /**
 101       * Parse date into ISO8601 format.
 102       *
 103       * @param {Date} date.
 104       */
 105      wp.api.utils.parseISO8601 = function( date ) {
 106          var timestamp, struct, i, k,
 107              minutesOffset = 0,
 108              numericKeys = [ 1, 4, 5, 6, 7, 10, 11 ];
 109  
 110          /*
 111           * ES5 §15.9.4.2 states that the string should attempt to be parsed as a Date Time String Format string
 112           * before falling back to any implementation-specific date parsing, so that’s what we do, even if native
 113           * implementations could be faster.
 114           */
 115          //              1 YYYY                2 MM       3 DD           4 HH    5 mm       6 ss        7 msec        8 Z 9 ±    10 tzHH    11 tzmm
 116          if ( ( struct = /^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/.exec( date ) ) ) {
 117  
 118              // Avoid NaN timestamps caused by “undefined” values being passed to Date.UTC.
 119              for ( i = 0; ( k = numericKeys[i] ); ++i ) {
 120                  struct[k] = +struct[k] || 0;
 121              }
 122  
 123              // Allow undefined days and months.
 124              struct[2] = ( +struct[2] || 1 ) - 1;
 125              struct[3] = +struct[3] || 1;
 126  
 127              if ( 'Z' !== struct[8]  && undefined !== struct[9] ) {
 128                  minutesOffset = struct[10] * 60 + struct[11];
 129  
 130                  if ( '+' === struct[9] ) {
 131                      minutesOffset = 0 - minutesOffset;
 132                  }
 133              }
 134  
 135              timestamp = Date.UTC( struct[1], struct[2], struct[3], struct[4], struct[5] + minutesOffset, struct[6], struct[7] );
 136          } else {
 137              timestamp = Date.parse ? Date.parse( date ) : NaN;
 138          }
 139  
 140          return timestamp;
 141      };
 142  
 143      /**
 144       * Helper function for getting the root URL.
 145       * @return {[type]} [description]
 146       */
 147      wp.api.utils.getRootUrl = function() {
 148          return window.location.origin ?
 149              window.location.origin + '/' :
 150              window.location.protocol + '//' + window.location.host + '/';
 151      };
 152  
 153      /**
 154       * Helper for capitalizing strings.
 155       */
 156      wp.api.utils.capitalize = function( str ) {
 157          if ( _.isUndefined( str ) ) {
 158              return str;
 159          }
 160          return str.charAt( 0 ).toUpperCase() + str.slice( 1 );
 161      };
 162  
 163      /**
 164       * Helper function that capitalizes the first word and camel cases any words starting
 165       * after dashes, removing the dashes.
 166       */
 167      wp.api.utils.capitalizeAndCamelCaseDashes = function( str ) {
 168          if ( _.isUndefined( str ) ) {
 169              return str;
 170          }
 171          str = wp.api.utils.capitalize( str );
 172  
 173          return wp.api.utils.camelCaseDashes( str );
 174      };
 175  
 176      /**
 177       * Helper function to camel case the letter after dashes, removing the dashes.
 178       */
 179      wp.api.utils.camelCaseDashes = function( str ) {
 180          return str.replace( /-([a-z])/g, function( g ) {
 181              return g[ 1 ].toUpperCase();
 182          } );
 183      };
 184  
 185      /**
 186       * Extract a route part based on negative index.
 187       *
 188       * @param {string}   route          The endpoint route.
 189       * @param {number}   part           The number of parts from the end of the route to retrieve. Default 1.
 190       *                                  Example route `/a/b/c`: part 1 is `c`, part 2 is `b`, part 3 is `a`.
 191       * @param {string}  [versionString] Version string, defaults to `wp.api.versionString`.
 192       * @param {boolean} [reverse]       Whether to reverse the order when extracting the route part. Optional, default false.
 193       */
 194      wp.api.utils.extractRoutePart = function( route, part, versionString, reverse ) {
 195          var routeParts;
 196  
 197          part = part || 1;
 198          versionString = versionString || wp.api.versionString;
 199  
 200          // Remove versions string from route to avoid returning it.
 201          if ( 0 === route.indexOf( '/' + versionString ) ) {
 202              route = route.substr( versionString.length + 1 );
 203          }
 204  
 205          routeParts = route.split( '/' );
 206          if ( reverse ) {
 207              routeParts = routeParts.reverse();
 208          }
 209          if ( _.isUndefined( routeParts[ --part ] ) ) {
 210              return '';
 211          }
 212          return routeParts[ part ];
 213      };
 214  
 215      /**
 216       * Extract a parent name from a passed route.
 217       *
 218       * @param {string} route The route to extract a name from.
 219       */
 220      wp.api.utils.extractParentName = function( route ) {
 221          var name,
 222              lastSlash = route.lastIndexOf( '_id>[\\d]+)/' );
 223  
 224          if ( lastSlash < 0 ) {
 225              return '';
 226          }
 227          name = route.substr( 0, lastSlash - 1 );
 228          name = name.split( '/' );
 229          name.pop();
 230          name = name.pop();
 231          return name;
 232      };
 233  
 234      /**
 235       * Add args and options to a model prototype from a route's endpoints.
 236       *
 237       * @param {Array}  routeEndpoints Array of route endpoints.
 238       * @param {Object} modelInstance  An instance of the model (or collection)
 239       *                                to add the args to.
 240       */
 241      wp.api.utils.decorateFromRoute = function( routeEndpoints, modelInstance ) {
 242  
 243          /**
 244           * Build the args based on route endpoint data.
 245           */
 246          _.each( routeEndpoints, function( routeEndpoint ) {
 247  
 248              // Add post and edit endpoints as model args.
 249              if ( _.includes( routeEndpoint.methods, 'POST' ) || _.includes( routeEndpoint.methods, 'PUT' ) ) {
 250  
 251                  // Add any non-empty args, merging them into the args object.
 252                  if ( ! _.isEmpty( routeEndpoint.args ) ) {
 253  
 254                      // Set as default if no args yet.
 255                      if ( _.isEmpty( modelInstance.prototype.args ) ) {
 256                          modelInstance.prototype.args = routeEndpoint.args;
 257                      } else {
 258  
 259                          // We already have args, merge these new args in.
 260                          modelInstance.prototype.args = _.extend( modelInstance.prototype.args, routeEndpoint.args );
 261                      }
 262                  }
 263              } else {
 264  
 265                  // Add GET method as model options.
 266                  if ( _.includes( routeEndpoint.methods, 'GET' ) ) {
 267  
 268                      // Add any non-empty args, merging them into the defaults object.
 269                      if ( ! _.isEmpty( routeEndpoint.args ) ) {
 270  
 271                          // Set as default if no defaults yet.
 272                          if ( _.isEmpty( modelInstance.prototype.options ) ) {
 273                              modelInstance.prototype.options = routeEndpoint.args;
 274                          } else {
 275  
 276                              // We already have options, merge these new args in.
 277                              modelInstance.prototype.options = _.extend( modelInstance.prototype.options, routeEndpoint.args );
 278                          }
 279                      }
 280  
 281                  }
 282              }
 283  
 284          } );
 285  
 286      };
 287  
 288      /**
 289       * Add mixins and helpers to models depending on their defaults.
 290       *
 291       * @param {Backbone Model} model          The model to attach helpers and mixins to.
 292       * @param {string}         modelClassName The classname of the constructed model.
 293       * @param {Object}            loadingObjects An object containing the models and collections we are building.
 294       */
 295      wp.api.utils.addMixinsAndHelpers = function( model, modelClassName, loadingObjects ) {
 296  
 297          var hasDate = false,
 298  
 299              /**
 300               * Array of parseable dates.
 301               *
 302               * @type {string[]}.
 303               */
 304              parseableDates = [ 'date', 'modified', 'date_gmt', 'modified_gmt' ],
 305  
 306              /**
 307               * Mixin for all content that is time stamped.
 308               *
 309               * This mixin converts between mysql timestamps and JavaScript Dates when syncing a model
 310               * to or from the server. For example, a date stored as `2015-12-27T21:22:24` on the server
 311               * gets expanded to `Sun Dec 27 2015 14:22:24 GMT-0700 (MST)` when the model is fetched.
 312               *
 313               * @type {{toJSON: toJSON, parse: parse}}.
 314               */
 315              TimeStampedMixin = {
 316  
 317                  /**
 318                   * Prepare a JavaScript Date for transmitting to the server.
 319                   *
 320                   * This helper function accepts a field and Date object. It converts the passed Date
 321                   * to an ISO string and sets that on the model field.
 322                   *
 323                   * @param {Date}   date   A JavaScript date object. WordPress expects dates in UTC.
 324                   * @param {string} field  The date field to set. One of 'date', 'date_gmt', 'date_modified'
 325                   *                        or 'date_modified_gmt'. Optional, defaults to 'date'.
 326                   */
 327                  setDate: function( date, field ) {
 328                      var theField = field || 'date';
 329  
 330                      // Don't alter non-parsable date fields.
 331                      if ( _.indexOf( parseableDates, theField ) < 0 ) {
 332                          return false;
 333                      }
 334  
 335                      this.set( theField, date.toISOString() );
 336                  },
 337  
 338                  /**
 339                   * Get a JavaScript Date from the passed field.
 340                   *
 341                   * WordPress returns 'date' and 'date_modified' in the timezone of the server as well as
 342                   * UTC dates as 'date_gmt' and 'date_modified_gmt'. Draft posts do not include UTC dates.
 343                   *
 344                   * @param {string} field  The date field to set. One of 'date', 'date_gmt', 'date_modified'
 345                   *                        or 'date_modified_gmt'. Optional, defaults to 'date'.
 346                   */
 347                  getDate: function( field ) {
 348                      var theField   = field || 'date',
 349                          theISODate = this.get( theField );
 350  
 351                      // Only get date fields and non-null values.
 352                      if ( _.indexOf( parseableDates, theField ) < 0 || _.isNull( theISODate ) ) {
 353                          return false;
 354                      }
 355  
 356                      return new Date( wp.api.utils.parseISO8601( theISODate ) );
 357                  }
 358              },
 359  
 360              /**
 361               * Build a helper function to retrieve related model.
 362               *
 363               * @param {string} parentModel      The parent model.
 364               * @param {number} modelId          The model ID if the object to request
 365               * @param {string} modelName        The model name to use when constructing the model.
 366               * @param {string} embedSourcePoint Where to check the embedds object for _embed data.
 367               * @param {string} embedCheckField  Which model field to check to see if the model has data.
 368               *
 369               * @return {Deferred.promise}        A promise which resolves to the constructed model.
 370               */
 371              buildModelGetter = function( parentModel, modelId, modelName, embedSourcePoint, embedCheckField ) {
 372                  var getModel, embeddeds, attributes, deferred;
 373  
 374                  deferred  = jQuery.Deferred();
 375                  embeddeds = parentModel.get( '_embedded' ) || {};
 376  
 377                  // Verify that we have a valid object id.
 378                  if ( ! _.isNumber( modelId ) || 0 === modelId ) {
 379                      deferred.reject();
 380                      return deferred;
 381                  }
 382  
 383                  // If we have embedded object data, use that when constructing the getModel.
 384                  if ( embeddeds[ embedSourcePoint ] ) {
 385                      attributes = _.findWhere( embeddeds[ embedSourcePoint ], { id: modelId } );
 386                  }
 387  
 388                  // Otherwise use the modelId.
 389                  if ( ! attributes ) {
 390                      attributes = { id: modelId };
 391                  }
 392  
 393                  // Create the new getModel model.
 394                  getModel = new wp.api.models[ modelName ]( attributes );
 395  
 396                  if ( ! getModel.get( embedCheckField ) ) {
 397                      getModel.fetch( {
 398                          success: function( getModel ) {
 399                              deferred.resolve( getModel );
 400                          },
 401                          error: function( getModel, response ) {
 402                              deferred.reject( response );
 403                          }
 404                      } );
 405                  } else {
 406                      // Resolve with the embedded model.
 407                      deferred.resolve( getModel );
 408                  }
 409  
 410                  // Return a promise.
 411                  return deferred.promise();
 412              },
 413  
 414              /**
 415               * Build a helper to retrieve a collection.
 416               *
 417               * @param {string} parentModel      The parent model.
 418               * @param {string} collectionName   The name to use when constructing the collection.
 419               * @param {string} embedSourcePoint Where to check the embedds object for _embed data.
 420               * @param {string} embedIndex       An addiitonal optional index for the _embed data.
 421               *
 422               * @return {Deferred.promise} A promise which resolves to the constructed collection.
 423               */
 424              buildCollectionGetter = function( parentModel, collectionName, embedSourcePoint, embedIndex ) {
 425                  /**
 426                   * Returns a promise that resolves to the requested collection
 427                   *
 428                   * Uses the embedded data if available, otherwises fetches the
 429                   * data from the server.
 430                   *
 431                   * @return {Deferred.promise} promise Resolves to a wp.api.collections[ collectionName ]
 432                   * collection.
 433                   */
 434                  var postId, embeddeds, getObjects,
 435                      classProperties = '',
 436                      properties      = '',
 437                      deferred        = jQuery.Deferred();
 438  
 439                  postId    = parentModel.get( 'id' );
 440                  embeddeds = parentModel.get( '_embedded' ) || {};
 441  
 442                  // Verify that we have a valid post ID.
 443                  if ( ! _.isNumber( postId ) || 0 === postId ) {
 444                      deferred.reject();
 445                      return deferred;
 446                  }
 447  
 448                  // If we have embedded getObjects data, use that when constructing the getObjects.
 449                  if ( ! _.isUndefined( embedSourcePoint ) && ! _.isUndefined( embeddeds[ embedSourcePoint ] ) ) {
 450  
 451                      // Some embeds also include an index offset, check for that.
 452                      if ( _.isUndefined( embedIndex ) ) {
 453  
 454                          // Use the embed source point directly.
 455                          properties = embeddeds[ embedSourcePoint ];
 456                      } else {
 457  
 458                          // Add the index to the embed source point.
 459                          properties = embeddeds[ embedSourcePoint ][ embedIndex ];
 460                      }
 461                  } else {
 462  
 463                      // Otherwise use the postId.
 464                      classProperties = { parent: postId };
 465                  }
 466  
 467                  // Create the new getObjects collection.
 468                  getObjects = new wp.api.collections[ collectionName ]( properties, classProperties );
 469  
 470                  // If we didn’t have embedded getObjects, fetch the getObjects data.
 471                  if ( _.isUndefined( getObjects.models[0] ) ) {
 472                      getObjects.fetch( {
 473                          success: function( getObjects ) {
 474  
 475                              // Add a helper 'parent_post' attribute onto the model.
 476                              setHelperParentPost( getObjects, postId );
 477                              deferred.resolve( getObjects );
 478                          },
 479                          error: function( getModel, response ) {
 480                              deferred.reject( response );
 481                          }
 482                      } );
 483                  } else {
 484  
 485                      // Add a helper 'parent_post' attribute onto the model.
 486                      setHelperParentPost( getObjects, postId );
 487                      deferred.resolve( getObjects );
 488                  }
 489  
 490                  // Return a promise.
 491                  return deferred.promise();
 492  
 493              },
 494  
 495              /**
 496               * Set the model post parent.
 497               */
 498              setHelperParentPost = function( collection, postId ) {
 499  
 500                  // Attach post_parent id to the collection.
 501                  _.each( collection.models, function( model ) {
 502                      model.set( 'parent_post', postId );
 503                  } );
 504              },
 505  
 506              /**
 507               * Add a helper function to handle post Meta.
 508               */
 509              MetaMixin = {
 510  
 511                  /**
 512                   * Get meta by key for a post.
 513                   *
 514                   * @param {string} key The meta key.
 515                   *
 516                   * @return {Object} The post meta value.
 517                   */
 518                  getMeta: function( key ) {
 519                      var metas = this.get( 'meta' );
 520                      return metas[ key ];
 521                  },
 522  
 523                  /**
 524                   * Get all meta key/values for a post.
 525                   *
 526                   * @return {Object} The post metas, as a key value pair object.
 527                   */
 528                  getMetas: function() {
 529                      return this.get( 'meta' );
 530                  },
 531  
 532                  /**
 533                   * Set a group of meta key/values for a post.
 534                   *
 535                   * @param {Object} meta The post meta to set, as key/value pairs.
 536                   */
 537                  setMetas: function( meta ) {
 538                      var metas = this.get( 'meta' );
 539                      _.extend( metas, meta );
 540                      this.set( 'meta', metas );
 541                  },
 542  
 543                  /**
 544                   * Set a single meta value for a post, by key.
 545                   *
 546                   * @param {string} key   The meta key.
 547                   * @param {Object} value The meta value.
 548                   */
 549                  setMeta: function( key, value ) {
 550                      var metas = this.get( 'meta' );
 551                      metas[ key ] = value;
 552                      this.set( 'meta', metas );
 553                  }
 554              },
 555  
 556              /**
 557               * Add a helper function to handle post Revisions.
 558               */
 559              RevisionsMixin = {
 560                  getRevisions: function() {
 561                      return buildCollectionGetter( this, 'PostRevisions' );
 562                  }
 563              },
 564  
 565              /**
 566               * Add a helper function to handle post Tags.
 567               */
 568              TagsMixin = {
 569  
 570                  /**
 571                   * Get the tags for a post.
 572                   *
 573                   * @return {Deferred.promise} promise Resolves to an array of tags.
 574                   */
 575                  getTags: function() {
 576                      var tagIds = this.get( 'tags' ),
 577                          tags  = new wp.api.collections.Tags();
 578  
 579                      // Resolve with an empty array if no tags.
 580                      if ( _.isEmpty( tagIds ) ) {
 581                          return jQuery.Deferred().resolve( [] );
 582                      }
 583  
 584                      return tags.fetch( { data: { include: tagIds } } );
 585                  },
 586  
 587                  /**
 588                   * Set the tags for a post.
 589                   *
 590                   * Accepts an array of tag slugs, or a Tags collection.
 591                   *
 592                   * @param {Array|Backbone.Collection} tags The tags to set on the post.
 593                   *
 594                   */
 595                  setTags: function( tags ) {
 596                      var allTags, newTag,
 597                          self = this,
 598                          newTags = [];
 599  
 600                      if ( _.isString( tags ) ) {
 601                          return false;
 602                      }
 603  
 604                      // If this is an array of slugs, build a collection.
 605                      if ( _.isArray( tags ) ) {
 606  
 607                          // Get all the tags.
 608                          allTags = new wp.api.collections.Tags();
 609                          allTags.fetch( {
 610                              data:    { per_page: 100 },
 611                              success: function( alltags ) {
 612  
 613                                  // Find the passed tags and set them up.
 614                                  _.each( tags, function( tag ) {
 615                                      newTag = new wp.api.models.Tag( alltags.findWhere( { slug: tag } ) );
 616  
 617                                      // Tie the new tag to the post.
 618                                      newTag.set( 'parent_post', self.get( 'id' ) );
 619  
 620                                      // Add the new tag to the collection.
 621                                      newTags.push( newTag );
 622                                  } );
 623                                  tags = new wp.api.collections.Tags( newTags );
 624                                  self.setTagsWithCollection( tags );
 625                              }
 626                          } );
 627  
 628                      } else {
 629                          this.setTagsWithCollection( tags );
 630                      }
 631                  },
 632  
 633                  /**
 634                   * Set the tags for a post.
 635                   *
 636                   * Accepts a Tags collection.
 637                   *
 638                   * @param {Array|Backbone.Collection} tags The tags to set on the post.
 639                   *
 640                   */
 641                  setTagsWithCollection: function( tags ) {
 642  
 643                      // Pluck out the category IDs.
 644                      this.set( 'tags', tags.pluck( 'id' ) );
 645                      return this.save();
 646                  }
 647              },
 648  
 649              /**
 650               * Add a helper function to handle post Categories.
 651               */
 652              CategoriesMixin = {
 653  
 654                  /**
 655                   * Get a the categories for a post.
 656                   *
 657                   * @return {Deferred.promise} promise Resolves to an array of categories.
 658                   */
 659                  getCategories: function() {
 660                      var categoryIds = this.get( 'categories' ),
 661                          categories  = new wp.api.collections.Categories();
 662  
 663                      // Resolve with an empty array if no categories.
 664                      if ( _.isEmpty( categoryIds ) ) {
 665                          return jQuery.Deferred().resolve( [] );
 666                      }
 667  
 668                      return categories.fetch( { data: { include: categoryIds } } );
 669                  },
 670  
 671                  /**
 672                   * Set the categories for a post.
 673                   *
 674                   * Accepts an array of category slugs, or a Categories collection.
 675                   *
 676                   * @param {Array|Backbone.Collection} categories The categories to set on the post.
 677                   *
 678                   */
 679                  setCategories: function( categories ) {
 680                      var allCategories, newCategory,
 681                          self = this,
 682                          newCategories = [];
 683  
 684                      if ( _.isString( categories ) ) {
 685                          return false;
 686                      }
 687  
 688                      // If this is an array of slugs, build a collection.
 689                      if ( _.isArray( categories ) ) {
 690  
 691                          // Get all the categories.
 692                          allCategories = new wp.api.collections.Categories();
 693                          allCategories.fetch( {
 694                              data:    { per_page: 100 },
 695                              success: function( allcats ) {
 696  
 697                                  // Find the passed categories and set them up.
 698                                  _.each( categories, function( category ) {
 699                                      newCategory = new wp.api.models.Category( allcats.findWhere( { slug: category } ) );
 700  
 701                                      // Tie the new category to the post.
 702                                      newCategory.set( 'parent_post', self.get( 'id' ) );
 703  
 704                                      // Add the new category to the collection.
 705                                      newCategories.push( newCategory );
 706                                  } );
 707                                  categories = new wp.api.collections.Categories( newCategories );
 708                                  self.setCategoriesWithCollection( categories );
 709                              }
 710                          } );
 711  
 712                      } else {
 713                          this.setCategoriesWithCollection( categories );
 714                      }
 715  
 716                  },
 717  
 718                  /**
 719                   * Set the categories for a post.
 720                   *
 721                   * Accepts Categories collection.
 722                   *
 723                   * @param {Array|Backbone.Collection} categories The categories to set on the post.
 724                   *
 725                   */
 726                  setCategoriesWithCollection: function( categories ) {
 727  
 728                      // Pluck out the category IDs.
 729                      this.set( 'categories', categories.pluck( 'id' ) );
 730                      return this.save();
 731                  }
 732              },
 733  
 734              /**
 735               * Add a helper function to retrieve the author user model.
 736               */
 737              AuthorMixin = {
 738                  getAuthorUser: function() {
 739                      return buildModelGetter( this, this.get( 'author' ), 'User', 'author', 'name' );
 740                  }
 741              },
 742  
 743              /**
 744               * Add a helper function to retrieve the featured media.
 745               */
 746              FeaturedMediaMixin = {
 747                  getFeaturedMedia: function() {
 748                      return buildModelGetter( this, this.get( 'featured_media' ), 'Media', 'wp:featuredmedia', 'source_url' );
 749                  }
 750              };
 751  
 752          // Exit if we don't have valid model defaults.
 753          if ( _.isUndefined( model.prototype.args ) ) {
 754              return model;
 755          }
 756  
 757          // Go thru the parsable date fields, if our model contains any of them it gets the TimeStampedMixin.
 758          _.each( parseableDates, function( theDateKey ) {
 759              if ( ! _.isUndefined( model.prototype.args[ theDateKey ] ) ) {
 760                  hasDate = true;
 761              }
 762          } );
 763  
 764          // Add the TimeStampedMixin for models that contain a date field.
 765          if ( hasDate ) {
 766              model = model.extend( TimeStampedMixin );
 767          }
 768  
 769          // Add the AuthorMixin for models that contain an author.
 770          if ( ! _.isUndefined( model.prototype.args.author ) ) {
 771              model = model.extend( AuthorMixin );
 772          }
 773  
 774          // Add the FeaturedMediaMixin for models that contain a featured_media.
 775          if ( ! _.isUndefined( model.prototype.args.featured_media ) ) {
 776              model = model.extend( FeaturedMediaMixin );
 777          }
 778  
 779          // Add the CategoriesMixin for models that support categories collections.
 780          if ( ! _.isUndefined( model.prototype.args.categories ) ) {
 781              model = model.extend( CategoriesMixin );
 782          }
 783  
 784          // Add the MetaMixin for models that support meta.
 785          if ( ! _.isUndefined( model.prototype.args.meta ) ) {
 786              model = model.extend( MetaMixin );
 787          }
 788  
 789          // Add the TagsMixin for models that support tags collections.
 790          if ( ! _.isUndefined( model.prototype.args.tags ) ) {
 791              model = model.extend( TagsMixin );
 792          }
 793  
 794          // Add the RevisionsMixin for models that support revisions collections.
 795          if ( ! _.isUndefined( loadingObjects.collections[ modelClassName + 'Revisions' ] ) ) {
 796              model = model.extend( RevisionsMixin );
 797          }
 798  
 799          return model;
 800      };
 801  
 802  })( window );
 803  
 804  /* global wpApiSettings:false */
 805  
 806  // Suppress warning about parse function's unused "options" argument:
 807  /* jshint unused:false */
 808  (function() {
 809  
 810      'use strict';
 811  
 812      var wpApiSettings = window.wpApiSettings || {},
 813      trashableTypes    = [ 'Comment', 'Media', 'Comment', 'Post', 'Page', 'Status', 'Taxonomy', 'Type' ];
 814  
 815      /**
 816       * Backbone base model for all models.
 817       */
 818      wp.api.WPApiBaseModel = Backbone.Model.extend(
 819          /** @lends WPApiBaseModel.prototype  */
 820          {
 821  
 822              // Initialize the model.
 823              initialize: function() {
 824  
 825                  /**
 826                  * Types that don't support trashing require passing ?force=true to delete.
 827                  *
 828                  */
 829                  if ( -1 === _.indexOf( trashableTypes, this.name ) ) {
 830                      this.requireForceForDelete = true;
 831                  }
 832              },
 833  
 834              /**
 835               * Set nonce header before every Backbone sync.
 836               *
 837               * @param {string} method.
 838               * @param {Backbone.Model} model.
 839               * @param {{beforeSend}, *} options.
 840               * @return {*}.
 841               */
 842              sync: function( method, model, options ) {
 843                  var beforeSend;
 844  
 845                  options = options || {};
 846  
 847                  // Remove date_gmt if null.
 848                  if ( _.isNull( model.get( 'date_gmt' ) ) ) {
 849                      model.unset( 'date_gmt' );
 850                  }
 851  
 852                  // Remove slug if empty.
 853                  if ( _.isEmpty( model.get( 'slug' ) ) ) {
 854                      model.unset( 'slug' );
 855                  }
 856  
 857                  if ( _.isFunction( model.nonce ) && ! _.isEmpty( model.nonce() ) ) {
 858                      beforeSend = options.beforeSend;
 859  
 860                      // @todo Enable option for jsonp endpoints.
 861                      // options.dataType = 'jsonp';
 862  
 863                      // Include the nonce with requests.
 864                      options.beforeSend = function( xhr ) {
 865                          xhr.setRequestHeader( 'X-WP-Nonce', model.nonce() );
 866  
 867                          if ( beforeSend ) {
 868                              return beforeSend.apply( this, arguments );
 869                          }
 870                      };
 871  
 872                      // Update the nonce when a new nonce is returned with the response.
 873                      options.complete = function( xhr ) {
 874                          var returnedNonce = xhr.getResponseHeader( 'X-WP-Nonce' );
 875  
 876                          if ( returnedNonce && _.isFunction( model.nonce ) && model.nonce() !== returnedNonce ) {
 877                              model.endpointModel.set( 'nonce', returnedNonce );
 878                          }
 879                      };
 880                  }
 881  
 882                  // Add '?force=true' to use delete method when required.
 883                  if ( this.requireForceForDelete && 'delete' === method ) {
 884                      model.url = model.url() + '?force=true';
 885                  }
 886                  return Backbone.sync( method, model, options );
 887              },
 888  
 889              /**
 890               * Save is only allowed when the PUT OR POST methods are available for the endpoint.
 891               */
 892              save: function( attrs, options ) {
 893  
 894                  // Do we have the put method, then execute the save.
 895                  if ( _.includes( this.methods, 'PUT' ) || _.includes( this.methods, 'POST' ) ) {
 896  
 897                      // Proxy the call to the original save function.
 898                      return Backbone.Model.prototype.save.call( this, attrs, options );
 899                  } else {
 900  
 901                      // Otherwise bail, disallowing action.
 902                      return false;
 903                  }
 904              },
 905  
 906              /**
 907               * Delete is only allowed when the DELETE method is available for the endpoint.
 908               */
 909              destroy: function( options ) {
 910  
 911                  // Do we have the DELETE method, then execute the destroy.
 912                  if ( _.includes( this.methods, 'DELETE' ) ) {
 913  
 914                      // Proxy the call to the original save function.
 915                      return Backbone.Model.prototype.destroy.call( this, options );
 916                  } else {
 917  
 918                      // Otherwise bail, disallowing action.
 919                      return false;
 920                  }
 921              }
 922  
 923          }
 924      );
 925  
 926      /**
 927       * API Schema model. Contains meta information about the API.
 928       */
 929      wp.api.models.Schema = wp.api.WPApiBaseModel.extend(
 930          /** @lends Schema.prototype  */
 931          {
 932              defaults: {
 933                  _links: {},
 934                  namespace: null,
 935                  routes: {}
 936              },
 937  
 938              initialize: function( attributes, options ) {
 939                  var model = this;
 940                  options = options || {};
 941  
 942                  wp.api.WPApiBaseModel.prototype.initialize.call( model, attributes, options );
 943  
 944                  model.apiRoot = options.apiRoot || wpApiSettings.root;
 945                  model.versionString = options.versionString || wpApiSettings.versionString;
 946              },
 947  
 948              url: function() {
 949                  return this.apiRoot + this.versionString;
 950              }
 951          }
 952      );
 953  })();
 954  
 955  ( function() {
 956  
 957      'use strict';
 958  
 959      var wpApiSettings = window.wpApiSettings || {};
 960  
 961      /**
 962       * Contains basic collection functionality such as pagination.
 963       */
 964      wp.api.WPApiBaseCollection = Backbone.Collection.extend(
 965          /** @lends BaseCollection.prototype  */
 966          {
 967  
 968              /**
 969               * Setup default state.
 970               */
 971              initialize: function( models, options ) {
 972                  this.state = {
 973                      data: {},
 974                      currentPage: null,
 975                      totalPages: null,
 976                      totalObjects: null
 977                  };
 978                  if ( _.isUndefined( options ) ) {
 979                      this.parent = '';
 980                  } else {
 981                      this.parent = options.parent;
 982                  }
 983              },
 984  
 985              /**
 986               * Extend Backbone.Collection.sync to add nince and pagination support.
 987               *
 988               * Set nonce header before every Backbone sync.
 989               *
 990               * @param {string} method.
 991               * @param {Backbone.Model} model.
 992               * @param {{success}, *} options.
 993               * @return {*}.
 994               */
 995              sync: function( method, model, options ) {
 996                  var beforeSend, success,
 997                      self = this;
 998  
 999                  options = options || {};
1000  
1001                  if ( _.isFunction( model.nonce ) && ! _.isEmpty( model.nonce() ) ) {
1002                      beforeSend = options.beforeSend;
1003  
1004                      // Include the nonce with requests.
1005                      options.beforeSend = function( xhr ) {
1006                          xhr.setRequestHeader( 'X-WP-Nonce', model.nonce() );
1007  
1008                          if ( beforeSend ) {
1009                              return beforeSend.apply( self, arguments );
1010                          }
1011                      };
1012  
1013                      // Update the nonce when a new nonce is returned with the response.
1014                      options.complete = function( xhr ) {
1015                          var returnedNonce = xhr.getResponseHeader( 'X-WP-Nonce' );
1016  
1017                          if ( returnedNonce && _.isFunction( model.nonce ) && model.nonce() !== returnedNonce ) {
1018                              model.endpointModel.set( 'nonce', returnedNonce );
1019                          }
1020                      };
1021                  }
1022  
1023                  // When reading, add pagination data.
1024                  if ( 'read' === method ) {
1025                      if ( options.data ) {
1026                          self.state.data = _.clone( options.data );
1027  
1028                          delete self.state.data.page;
1029                      } else {
1030                          self.state.data = options.data = {};
1031                      }
1032  
1033                      if ( 'undefined' === typeof options.data.page ) {
1034                          self.state.currentPage  = null;
1035                          self.state.totalPages   = null;
1036                          self.state.totalObjects = null;
1037                      } else {
1038                          self.state.currentPage = options.data.page - 1;
1039                      }
1040  
1041                      success = options.success;
1042                      options.success = function( data, textStatus, request ) {
1043                          if ( ! _.isUndefined( request ) ) {
1044                              self.state.totalPages   = parseInt( request.getResponseHeader( 'x-wp-totalpages' ), 10 );
1045                              self.state.totalObjects = parseInt( request.getResponseHeader( 'x-wp-total' ), 10 );
1046                          }
1047  
1048                          if ( null === self.state.currentPage ) {
1049                              self.state.currentPage = 1;
1050                          } else {
1051                              self.state.currentPage++;
1052                          }
1053  
1054                          if ( success ) {
1055                              return success.apply( this, arguments );
1056                          }
1057                      };
1058                  }
1059  
1060                  // Continue by calling Bacckbone's sync.
1061                  return Backbone.sync( method, model, options );
1062              },
1063  
1064              /**
1065               * Fetches the next page of objects if a new page exists.
1066               *
1067               * @param {data: {page}} options.
1068               * @return {*}.
1069               */
1070              more: function( options ) {
1071                  options = options || {};
1072                  options.data = options.data || {};
1073  
1074                  _.extend( options.data, this.state.data );
1075  
1076                  if ( 'undefined' === typeof options.data.page ) {
1077                      if ( ! this.hasMore() ) {
1078                          return false;
1079                      }
1080  
1081                      if ( null === this.state.currentPage || this.state.currentPage <= 1 ) {
1082                          options.data.page = 2;
1083                      } else {
1084                          options.data.page = this.state.currentPage + 1;
1085                      }
1086                  }
1087  
1088                  return this.fetch( options );
1089              },
1090  
1091              /**
1092               * Returns true if there are more pages of objects available.
1093               *
1094               * @return {null|boolean}
1095               */
1096              hasMore: function() {
1097                  if ( null === this.state.totalPages ||
1098                       null === this.state.totalObjects ||
1099                       null === this.state.currentPage ) {
1100                      return null;
1101                  } else {
1102                      return ( this.state.currentPage < this.state.totalPages );
1103                  }
1104              }
1105          }
1106      );
1107  
1108  } )();
1109  
1110  ( function() {
1111  
1112      'use strict';
1113  
1114      var Endpoint, initializedDeferreds = {},
1115          wpApiSettings = window.wpApiSettings || {};
1116  
1117      /** @namespace wp */
1118      window.wp = window.wp || {};
1119  
1120      /** @namespace wp.api */
1121      wp.api    = wp.api || {};
1122  
1123      // If wpApiSettings is unavailable, try the default.
1124      if ( _.isEmpty( wpApiSettings ) ) {
1125          wpApiSettings.root = window.location.origin + '/wp-json/';
1126      }
1127  
1128      Endpoint = Backbone.Model.extend(/** @lends Endpoint.prototype */{
1129          defaults: {
1130              apiRoot: wpApiSettings.root,
1131              versionString: wp.api.versionString,
1132              nonce: null,
1133              schema: null,
1134              models: {},
1135              collections: {}
1136          },
1137  
1138          /**
1139           * Initialize the Endpoint model.
1140           */
1141          initialize: function() {
1142              var model = this, deferred;
1143  
1144              Backbone.Model.prototype.initialize.apply( model, arguments );
1145  
1146              deferred = jQuery.Deferred();
1147              model.schemaConstructed = deferred.promise();
1148  
1149              model.schemaModel = new wp.api.models.Schema( null, {
1150                  apiRoot:       model.get( 'apiRoot' ),
1151                  versionString: model.get( 'versionString' ),
1152                  nonce:         model.get( 'nonce' )
1153              } );
1154  
1155              // When the model loads, resolve the promise.
1156              model.schemaModel.once( 'change', function() {
1157                  model.constructFromSchema();
1158                  deferred.resolve( model );
1159              } );
1160  
1161              if ( model.get( 'schema' ) ) {
1162  
1163                  // Use schema supplied as model attribute.
1164                  model.schemaModel.set( model.schemaModel.parse( model.get( 'schema' ) ) );
1165              } else if (
1166                  ! _.isUndefined( sessionStorage ) &&
1167                  ( _.isUndefined( wpApiSettings.cacheSchema ) || wpApiSettings.cacheSchema ) &&
1168                  sessionStorage.getItem( 'wp-api-schema-model' + model.get( 'apiRoot' ) + model.get( 'versionString' ) )
1169              ) {
1170  
1171                  // Used a cached copy of the schema model if available.
1172                  model.schemaModel.set( model.schemaModel.parse( JSON.parse( sessionStorage.getItem( 'wp-api-schema-model' + model.get( 'apiRoot' ) + model.get( 'versionString' ) ) ) ) );
1173              } else {
1174                  model.schemaModel.fetch( {
1175                      /**
1176                       * When the server returns the schema model data, store the data in a sessionCache so we don't
1177                       * have to retrieve it again for this session. Then, construct the models and collections based
1178                       * on the schema model data.
1179                       *
1180                       * @ignore
1181                       */
1182                      success: function( newSchemaModel ) {
1183  
1184                          // Store a copy of the schema model in the session cache if available.
1185                          if ( ! _.isUndefined( sessionStorage ) && ( _.isUndefined( wpApiSettings.cacheSchema ) || wpApiSettings.cacheSchema ) ) {
1186                              try {
1187                                  sessionStorage.setItem( 'wp-api-schema-model' + model.get( 'apiRoot' ) + model.get( 'versionString' ), JSON.stringify( newSchemaModel ) );
1188                              } catch ( error ) {
1189  
1190                                  // Fail silently, fixes errors in safari private mode.
1191                              }
1192                          }
1193                      },
1194  
1195                      // Log the error condition.
1196                      error: function( err ) {
1197                          window.console.log( err );
1198                      }
1199                  } );
1200              }
1201          },
1202  
1203          constructFromSchema: function() {
1204              var routeModel = this, modelRoutes, collectionRoutes, schemaRoot, loadingObjects,
1205  
1206              /**
1207               * Set up the model and collection name mapping options. As the schema is built, the
1208               * model and collection names will be adjusted if they are found in the mapping object.
1209               *
1210               * Localizing a variable wpApiSettings.mapping will over-ride the default mapping options.
1211               *
1212               */
1213              mapping = wpApiSettings.mapping || {
1214                  models: {
1215                      'Categories':      'Category',
1216                      'Comments':        'Comment',
1217                      'Pages':           'Page',
1218                      'PagesMeta':       'PageMeta',
1219                      'PagesRevisions':  'PageRevision',
1220                      'Posts':           'Post',
1221                      'PostsCategories': 'PostCategory',
1222                      'PostsRevisions':  'PostRevision',
1223                      'PostsTags':       'PostTag',
1224                      'Schema':          'Schema',
1225                      'Statuses':        'Status',
1226                      'Tags':            'Tag',
1227                      'Taxonomies':      'Taxonomy',
1228                      'Types':           'Type',
1229                      'Users':           'User'
1230                  },
1231                  collections: {
1232                      'PagesMeta':       'PageMeta',
1233                      'PagesRevisions':  'PageRevisions',
1234                      'PostsCategories': 'PostCategories',
1235                      'PostsMeta':       'PostMeta',
1236                      'PostsRevisions':  'PostRevisions',
1237                      'PostsTags':       'PostTags'
1238                  }
1239              },
1240  
1241              modelEndpoints = routeModel.get( 'modelEndpoints' ),
1242              modelRegex     = new RegExp( '(?:.*[+)]|\/(' + modelEndpoints.join( '|' ) + '))$' );
1243  
1244              /**
1245               * Iterate thru the routes, picking up models and collections to build. Builds two arrays,
1246               * one for models and one for collections.
1247               */
1248              modelRoutes      = [];
1249              collectionRoutes = [];
1250              schemaRoot       = routeModel.get( 'apiRoot' ).replace( wp.api.utils.getRootUrl(), '' );
1251              loadingObjects   = {};
1252  
1253              /**
1254               * Tracking objects for models and collections.
1255               */
1256              loadingObjects.models      = {};
1257              loadingObjects.collections = {};
1258  
1259              _.each( routeModel.schemaModel.get( 'routes' ), function( route, index ) {
1260  
1261                  // Skip the schema root if included in the schema.
1262                  if ( index !== routeModel.get( ' versionString' ) &&
1263                          index !== schemaRoot &&
1264                          index !== ( '/' + routeModel.get( 'versionString' ).slice( 0, -1 ) )
1265                  ) {
1266  
1267                      // Single items end with a regex, or a special case word.
1268                      if ( modelRegex.test( index ) ) {
1269                          modelRoutes.push( { index: index, route: route } );
1270                      } else {
1271  
1272                          // Collections end in a name.
1273                          collectionRoutes.push( { index: index, route: route } );
1274                      }
1275                  }
1276              } );
1277  
1278              /**
1279               * Construct the models.
1280               *
1281               * Base the class name on the route endpoint.
1282               */
1283              _.each( modelRoutes, function( modelRoute ) {
1284  
1285                  // Extract the name and any parent from the route.
1286                  var modelClassName,
1287                      routeName  = wp.api.utils.extractRoutePart( modelRoute.index, 2, routeModel.get( 'versionString' ), true ),
1288                      parentName = wp.api.utils.extractRoutePart( modelRoute.index, 1, routeModel.get( 'versionString' ), false ),
1289                      routeEnd   = wp.api.utils.extractRoutePart( modelRoute.index, 1, routeModel.get( 'versionString' ), true );
1290  
1291                  // Clear the parent part of the rouite if its actually the version string.
1292                  if ( parentName === routeModel.get( 'versionString' ) ) {
1293                      parentName = '';
1294                  }
1295  
1296                  // Handle the special case of the 'me' route.
1297                  if ( 'me' === routeEnd ) {
1298                      routeName = 'me';
1299                  }
1300  
1301                  // If the model has a parent in its route, add that to its class name.
1302                  if ( '' !== parentName && parentName !== routeName ) {
1303                      modelClassName = wp.api.utils.capitalizeAndCamelCaseDashes( parentName ) + wp.api.utils.capitalizeAndCamelCaseDashes( routeName );
1304                      modelClassName = mapping.models[ modelClassName ] || modelClassName;
1305                      loadingObjects.models[ modelClassName ] = wp.api.WPApiBaseModel.extend( {
1306  
1307                          // Return a constructed url based on the parent and id.
1308                          url: function() {
1309                              var url =
1310                                  routeModel.get( 'apiRoot' ) +
1311                                  routeModel.get( 'versionString' ) +
1312                                  parentName +  '/' +
1313                                      ( ( _.isUndefined( this.get( 'parent' ) ) || 0 === this.get( 'parent' ) ) ?
1314                                          ( _.isUndefined( this.get( 'parent_post' ) ) ? '' : this.get( 'parent_post' ) + '/' ) :
1315                                          this.get( 'parent' ) + '/' ) +
1316                                  routeName;
1317  
1318                              if ( ! _.isUndefined( this.get( 'id' ) ) ) {
1319                                  url +=  '/' + this.get( 'id' );
1320                              }
1321                              return url;
1322                          },
1323  
1324                          // Track nonces on the Endpoint 'routeModel'.
1325                          nonce: function() {
1326                              return routeModel.get( 'nonce' );
1327                          },
1328  
1329                          endpointModel: routeModel,
1330  
1331                          // Include a reference to the original route object.
1332                          route: modelRoute,
1333  
1334                          // Include a reference to the original class name.
1335                          name: modelClassName,
1336  
1337                          // Include the array of route methods for easy reference.
1338                          methods: modelRoute.route.methods,
1339  
1340                          // Include the array of route endpoints for easy reference.
1341                          endpoints: modelRoute.route.endpoints
1342                      } );
1343                  } else {
1344  
1345                      // This is a model without a parent in its route.
1346                      modelClassName = wp.api.utils.capitalizeAndCamelCaseDashes( routeName );
1347                      modelClassName = mapping.models[ modelClassName ] || modelClassName;
1348                      loadingObjects.models[ modelClassName ] = wp.api.WPApiBaseModel.extend( {
1349  
1350                          // Function that returns a constructed url based on the ID.
1351                          url: function() {
1352                              var url = routeModel.get( 'apiRoot' ) +
1353                                  routeModel.get( 'versionString' ) +
1354                                  ( ( 'me' === routeName ) ? 'users/me' : routeName );
1355  
1356                              if ( ! _.isUndefined( this.get( 'id' ) ) ) {
1357                                  url +=  '/' + this.get( 'id' );
1358                              }
1359                              return url;
1360                          },
1361  
1362                          // Track nonces at the Endpoint level.
1363                          nonce: function() {
1364                              return routeModel.get( 'nonce' );
1365                          },
1366  
1367                          endpointModel: routeModel,
1368  
1369                          // Include a reference to the original route object.
1370                          route: modelRoute,
1371  
1372                          // Include a reference to the original class name.
1373                          name: modelClassName,
1374  
1375                          // Include the array of route methods for easy reference.
1376                          methods: modelRoute.route.methods,
1377  
1378                          // Include the array of route endpoints for easy reference.
1379                          endpoints: modelRoute.route.endpoints
1380                      } );
1381                  }
1382  
1383                  // Add defaults to the new model, pulled form the endpoint.
1384                  wp.api.utils.decorateFromRoute(
1385                      modelRoute.route.endpoints,
1386                      loadingObjects.models[ modelClassName ],
1387                      routeModel.get( 'versionString' )
1388                  );
1389  
1390              } );
1391  
1392              /**
1393               * Construct the collections.
1394               *
1395               * Base the class name on the route endpoint.
1396               */
1397              _.each( collectionRoutes, function( collectionRoute ) {
1398  
1399                  // Extract the name and any parent from the route.
1400                  var collectionClassName, modelClassName,
1401                          routeName  = collectionRoute.index.slice( collectionRoute.index.lastIndexOf( '/' ) + 1 ),
1402                          parentName = wp.api.utils.extractRoutePart( collectionRoute.index, 1, routeModel.get( 'versionString' ), false );
1403  
1404                  // If the collection has a parent in its route, add that to its class name.
1405                  if ( '' !== parentName && parentName !== routeName && routeModel.get( 'versionString' ) !== parentName ) {
1406  
1407                      collectionClassName = wp.api.utils.capitalizeAndCamelCaseDashes( parentName ) + wp.api.utils.capitalizeAndCamelCaseDashes( routeName );
1408                      modelClassName      = mapping.models[ collectionClassName ] || collectionClassName;
1409                      collectionClassName = mapping.collections[ collectionClassName ] || collectionClassName;
1410                      loadingObjects.collections[ collectionClassName ] = wp.api.WPApiBaseCollection.extend( {
1411  
1412                          // Function that returns a constructed url passed on the parent.
1413                          url: function() {
1414                              return routeModel.get( 'apiRoot' ) + routeModel.get( 'versionString' ) +
1415                                      parentName + '/' + this.parent + '/' +
1416                                      routeName;
1417                          },
1418  
1419                          // Specify the model that this collection contains.
1420                          model: function( attrs, options ) {
1421                              return new loadingObjects.models[ modelClassName ]( attrs, options );
1422                          },
1423  
1424                          // Track nonces at the Endpoint level.
1425                          nonce: function() {
1426                              return routeModel.get( 'nonce' );
1427                          },
1428  
1429                          endpointModel: routeModel,
1430  
1431                          // Include a reference to the original class name.
1432                          name: collectionClassName,
1433  
1434                          // Include a reference to the original route object.
1435                          route: collectionRoute,
1436  
1437                          // Include the array of route methods for easy reference.
1438                          methods: collectionRoute.route.methods
1439                      } );
1440                  } else {
1441  
1442                      // This is a collection without a parent in its route.
1443                      collectionClassName = wp.api.utils.capitalizeAndCamelCaseDashes( routeName );
1444                      modelClassName      = mapping.models[ collectionClassName ] || collectionClassName;
1445                      collectionClassName = mapping.collections[ collectionClassName ] || collectionClassName;
1446                      loadingObjects.collections[ collectionClassName ] = wp.api.WPApiBaseCollection.extend( {
1447  
1448                          // For the url of a root level collection, use a string.
1449                          url: function() {
1450                              return routeModel.get( 'apiRoot' ) + routeModel.get( 'versionString' ) + routeName;
1451                          },
1452  
1453                          // Specify the model that this collection contains.
1454                          model: function( attrs, options ) {
1455                              return new loadingObjects.models[ modelClassName ]( attrs, options );
1456                          },
1457  
1458                          // Track nonces at the Endpoint level.
1459                          nonce: function() {
1460                              return routeModel.get( 'nonce' );
1461                          },
1462  
1463                          endpointModel: routeModel,
1464  
1465                          // Include a reference to the original class name.
1466                          name: collectionClassName,
1467  
1468                          // Include a reference to the original route object.
1469                          route: collectionRoute,
1470  
1471                          // Include the array of route methods for easy reference.
1472                          methods: collectionRoute.route.methods
1473                      } );
1474                  }
1475  
1476                  // Add defaults to the new model, pulled form the endpoint.
1477                  wp.api.utils.decorateFromRoute( collectionRoute.route.endpoints, loadingObjects.collections[ collectionClassName ] );
1478              } );
1479  
1480              // Add mixins and helpers for each of the models.
1481              _.each( loadingObjects.models, function( model, index ) {
1482                  loadingObjects.models[ index ] = wp.api.utils.addMixinsAndHelpers( model, index, loadingObjects );
1483              } );
1484  
1485              // Set the routeModel models and collections.
1486              routeModel.set( 'models', loadingObjects.models );
1487              routeModel.set( 'collections', loadingObjects.collections );
1488  
1489          }
1490  
1491      } );
1492  
1493      wp.api.endpoints = new Backbone.Collection();
1494  
1495      /**
1496       * Initialize the wp-api, optionally passing the API root.
1497       *
1498       * @param {Object} [args]
1499       * @param {string} [args.nonce] The nonce. Optional, defaults to wpApiSettings.nonce.
1500       * @param {string} [args.apiRoot] The api root. Optional, defaults to wpApiSettings.root.
1501       * @param {string} [args.versionString] The version string. Optional, defaults to wpApiSettings.root.
1502       * @param {Object} [args.schema] The schema. Optional, will be fetched from API if not provided.
1503       */
1504      wp.api.init = function( args ) {
1505          var endpoint, attributes = {}, deferred, promise;
1506  
1507          args                      = args || {};
1508          attributes.nonce          = _.isString( args.nonce ) ? args.nonce : ( wpApiSettings.nonce || '' );
1509          attributes.apiRoot        = args.apiRoot || wpApiSettings.root || '/wp-json';
1510          attributes.versionString  = args.versionString || wpApiSettings.versionString || 'wp/v2/';
1511          attributes.schema         = args.schema || null;
1512          attributes.modelEndpoints = args.modelEndpoints || [ 'me', 'settings' ];
1513          if ( ! attributes.schema && attributes.apiRoot === wpApiSettings.root && attributes.versionString === wpApiSettings.versionString ) {
1514              attributes.schema = wpApiSettings.schema;
1515          }
1516  
1517          if ( ! initializedDeferreds[ attributes.apiRoot + attributes.versionString ] ) {
1518  
1519              // Look for an existing copy of this endpoint.
1520              endpoint = wp.api.endpoints.findWhere( { 'apiRoot': attributes.apiRoot, 'versionString': attributes.versionString } );
1521              if ( ! endpoint ) {
1522                  endpoint = new Endpoint( attributes );
1523              }
1524              deferred = jQuery.Deferred();
1525              promise = deferred.promise();
1526  
1527              endpoint.schemaConstructed.done( function( resolvedEndpoint ) {
1528                  wp.api.endpoints.add( resolvedEndpoint );
1529  
1530                  // Map the default endpoints, extending any already present items (including Schema model).
1531                  wp.api.models      = _.extend( wp.api.models, resolvedEndpoint.get( 'models' ) );
1532                  wp.api.collections = _.extend( wp.api.collections, resolvedEndpoint.get( 'collections' ) );
1533                  deferred.resolve( resolvedEndpoint );
1534              } );
1535              initializedDeferreds[ attributes.apiRoot + attributes.versionString ] = promise;
1536          }
1537          return initializedDeferreds[ attributes.apiRoot + attributes.versionString ];
1538      };
1539  
1540      /**
1541       * Construct the default endpoints and add to an endpoints collection.
1542       */
1543  
1544      // The wp.api.init function returns a promise that will resolve with the endpoint once it is ready.
1545      wp.api.loadPromise = wp.api.init();
1546  
1547  } )();


Generated : Sat Sep 26 08:20:01 2020 Cross-referenced by PHPXref