Update more-routing for md-settings

third_party/polymer/v0_8/components-chromium/more-routing/route-extracted.js

 
 (function(scope) {
 var MoreRouting = scope.MoreRouting = scope.MoreRouting || {};
 MoreRouting.Route = Route;
 
 // Note that this can differ from the part separator defined by the driver. The
 // driver's separator is used when parsing/generating URLs given to the client,
 // whereas this one is for route definitions.
 var PART_SEPARATOR    = '/';
 var PARAM_SENTINEL    = ':';
 var SEPARATOR_CLEANER = /\/\/+/g;
 
 /**
  * TODO(nevir): Docs.
  */
 function Route(path, parent) {
+  // For `MoreRouting.Emitter`; Emits changes for `active`.
+  this.__listeners = [];
+
   this.path     = path;
   this.parent   = parent;
   this.fullPath = path;
   this.compiled = this._compile(this.path);
   this.active   = false;
   this.driver   = null;
 
+  var params = MoreRouting.Params(namedParams(this.compiled), this.parent && this.parent.params);
+  params.__subscribe(this._navigateToParams.bind(this));
+  Object.defineProperty(this, 'params', {
+    get: function() { return params; },
+    set: function() { throw new Error('Route#params cannot be overwritten'); },
+  });
+
   this.parts    = [];
   this.children = [];
 
   // Param values matching the current URL, or an empty object if not `active`.
   //
   // To make data "binding" easy, `Route` guarantees that `params` will always
   // be the same object; just make a reference to it.
   if (this.parent) {
-    this.params = Object.create(this.parent.params);
     this.parent.children.push(this);
     this.fullPath  = this.parent.fullPath + this.fullPath;
     this.depth     = this.parent.depth + this.compiled.length;
     this.numParams = this.parent.numParams + countParams(this.compiled);
   } else {
-    this.params    = {};
     this.depth     = this.compiled.length;
     this.numParams = countParams(this.compiled);
   }
+}
+Route.prototype = Object.create(MoreRouting.Emitter);
 
-  this._paramObserver = new ObjectObserver(this.params);
-  this._paramObserver.open(this._navigateToParams.bind(this));
-}
+Object.defineProperty(Route.prototype, 'active', {
+  get: function() {
+    return this._active;
+  },
+  set: function(value) {
+    if (value !== this._active);
+    this._active = value;
+    this.__notify('active', value);
+  },
+});
 
 Route.isPath = function isPath(pathOrName) {
   return pathOrName.indexOf(PART_SEPARATOR) === 0;
 };
 
 Route.joinPath = function joinPath(paths) {
   var joined = Array.prototype.join.call(arguments, PART_SEPARATOR);
   joined = joined.replace(SEPARATOR_CLEANER, PART_SEPARATOR);
 
   var minLength = joined.length - PART_SEPARATOR.length;
@@ skipping 52 matching lines @@
 
 /**
  * Called by the driver whenever it has detected a change to the URL.
  *
  * @param {Array.<String>|null} parts The parts of the URL, or null if the
  *     route should be disabled.
  */
 Route.prototype.processPathParts = function processPathParts(parts) {
   this.parts  = parts;
   this.active = this.matchesPathParts(parts);
+
+  // We don't want to notify of these changes; they'd be no-op noise.
+  this.params.__silent = true;
+
   if (this.active) {
     var keys = Object.keys(this.params);
     for (var i = 0; i < keys.length; i++) {
       delete this.params[keys[i]];
     }
     for (var i = 0, config; config = this.compiled[i]; i++) {
       if (config.type === 'param') {
         this.params[config.name] = parts[i];
       }
     }
   } else {
     for (key in this.params) {
       this.params[key] = undefined;
     }
   }
-  this._paramObserver.discardChanges();
+
+  delete this.params.__silent;
 };
 
 Route.prototype.matchesPathParts = function matchesPathParts(parts) {
   if (!parts) return false;
   if (parts.length < this.compiled.length) return false;
   for (var i = 0, config; config = this.compiled[i]; i++) {
     if (config.type === 'static' && parts[i] !== config.part) {
       return false;
     }
   }
@@ skipping 29 matching lines @@
   if (!parts) return;
   this.driver.navigateToParts(parts);
 };
 
 function countParams(compiled) {
   return compiled.reduce(function(count, part) {
     return count + (part.type === 'param' ? 1 : 0);
   }, 0);
 }
 
+function namedParams(compiled) {
+  var result = [];
+  compiled.forEach(function(part) {
+    if (part.type === 'static') return;
+    result.push(part.name);
+  });
+  return result;
+}
+
 })(window);