When navigating on a different route but the same component is used, Vue.js Will not update the instance data, so we have to update $data ourselves
4745
function fixPrepatch(to, ___) {
  var _this3 = this;

  if (this._hashChanged) return;

  __WEBPACK_IMPORTED_MODULE_6_vue__["default"].nextTick(function () {
    var instances = Object(__WEBPACK_IMPORTED_MODULE_9__utils__["g" /* getMatchedComponentsInstances */])(to);

    _lastComponentsFiles = instances.map(function (instance, i) {
      if (!instance) return '';

      if (_lastPaths[i] === instance.constructor._path && typeof instance.constructor.options.data === 'function') {
        var newData = instance.constructor.options.data.call(instance);
        for (var key in newData) {
          __WEBPACK_IMPORTED_MODULE_6_vue__["default"].set(instance.$data, key, newData[key]);
        }
      }

      return instance.constructor.options.__file;
    });

    // Hide error component if no error
    if (_this3._hadError && _this3._dateLastError === _this3.$options._nuxt.dateErr) {
      _this3.error();
    }

    // Set layout
    var layout = _this3.$options._nuxt.err ? __WEBPACK_IMPORTED_MODULE_8__index__["a" /* NuxtError */].layout : to.matched[0].components.default.options.layout;
    if (typeof layout === 'function') {
      layout = layout(_this3._context);
    }
    _this3.setLayout(layout);

    // Hot reloading
    setTimeout(function () {
      return hotReloadAPI(_this3);
    }, 100);
  });
}
550083
function() {
        var editDataSource = this.getProperty( 'editDataSource' );
        var destinationDataSource = this.getProperty( 'destinationDataSource' );
        var destinationProperty = this.getProperty( 'destinationProperty' );

        if( this._isObjectDataSource( editDataSource ) ) {
            var editedItem = editDataSource.getSelectedItem();
            var originItem = destinationDataSource.getProperty( destinationProperty );

            if( this._isRootElementPath( destinationProperty ) ) {
                this._overrideOriginItem( originItem, editedItem );
                destinationDataSource._includeItemToModifiedSet( originItem );
                destinationDataSource.saveItem( originItem, function() {
                    destinationDataSource.updateItems();
                } );
            } else {
                destinationDataSource.setProperty( destinationProperty, editedItem );
            }

        } else {
            destinationDataSource.updateItems();
        }
    }
111043
function (route, data) {
            var count = 0,
                i = 0,
                defaults = {};
            // look at default values, if they match ...
            for (var name in route.defaults) {
                if (route.defaults[name] === data[name]) {
                    // mark as matched
                    defaults[name] = 1;
                    count++;
                }
            }
            for (; i < route.names.length; i++) {
                if (!data.hasOwnProperty(route.names[i])) {
                    return -1;
                }
                if (!defaults[route.names[i]]) {
                    count++;
                }

            }

            return count;
        }
649936
private void doUpdateComponent() throws PageException {

	admin.updateComponentDeepSearch(getBoolObject("admin", action, "deepSearch"));
	admin.updateBaseComponent(getString("admin", action, "baseComponentTemplateCFML"), getString("admin", action, "baseComponentTemplateLucee"));
	admin.updateComponentDumpTemplate(getString("admin", action, "componentDumpTemplate"));
	admin.updateComponentDataMemberDefaultAccess(getString("admin", action, "componentDataMemberDefaultAccess"));
	admin.updateTriggerDataMember(getBoolObject("admin", action, "triggerDataMember"));
	admin.updateComponentUseShadow(getBoolObject("admin", action, "useShadow"));
	admin.updateComponentDefaultImport(getString("admin", action, "componentDefaultImport"));
	admin.updateComponentLocalSearch(getBoolObject("admin", action, "componentLocalSearch"));
	admin.updateComponentPathCache(getBoolObject("admin", action, "componentPathCache"));
	store();
	adminSync.broadcast(attributes, config);
    }
1304744
function(entityData) {
    // Avoid updating components if the entity data received did not come from the current owner.
    if (entityData.lastOwnerTime < this.lastOwnerTime ||
          (this.lastOwnerTime === entityData.lastOwnerTime && this.data.owner > entityData.owner)) {
      return;
    }

    if (this.data.owner !== entityData.owner) {
      var wasMine = this.isMine();
      this.lastOwnerTime = entityData.lastOwnerTime;

      const oldOwner = this.data.owner;
      const newOwner = entityData.owner;
      if (wasMine) {
        this.onOwnershipLostEvent.newOwner = newOwner;
        this.el.emit(this.OWNERSHIP_LOST, this.onOwnershipLostEvent);
      }
      this.onOwnershipChangedEvent.oldOwner = oldOwner;
      this.onOwnershipChangedEvent.newOwner = newOwner;
      this.el.emit(this.OWNERSHIP_CHANGED, this.onOwnershipChangedEvent);

      this.el.setAttribute('networked', { owner: entityData.owner });
    }
    this.updateComponents(entityData.components);
  }
1282379
function (oEvt) {
				// navigate to entity
				var sType = oEvt.getSource().data("type");
				this.getRouter().navTo("entity", {id: sType}, false);
			}
1217077
def on_property_change(self, name, old_value, new_value):
        # pylint: disable=W0613
        
        if name in self._keys:
            try:
                if self.update_filter():
                    # This is a key for the filter and the filter has changed
                    # => Force the handler to update its dependency
                    self._reset()
            except ValueError:
                # Invalid filter: clear all references, this will invalidate
                # the component
                for svc_ref in self.get_bindings():
                    self.on_service_departure(svc_ref)
1372196
function () {
      if (this.edirty) {
          var en=this.attEltNodes;
          if (en) {
              for (var i=0,sz=en.length; sz>i; i++) {
                  en[i].refresh();
              }
              // if content changed we have to rebuild childElements
              this.retrieveAttElements();
              this.initChildComponents();
          }
          // Change content of the controller
          json.set(this.controller,"$content",this.getControllerContent());

          this.edirty=false;
      }
      // warning: the following refresh may change the component type and
      // as such ctlWrapper could become null if new component is a template
      $CptNode.refresh.call(this);
      if (this.ctlWrapper) {
        // refresh cpt through $refresh if need be
        this.ctlWrapper.refresh();
      }
  }
590118
function postpatch(oldVnode, vnode) {
  const oldData = oldVnode.data
  const newData = vnode.data

  // Server side rendering: Reconcilating with a server-rendered node will have skipped calling insert()
  if (!oldData.component) {
    insert(vnode)
  }

  // oldData wouldn't have a component reference set if it came from the server (it's first set in insert())
  const component = oldData.component || newData.component
  const oldProps = component.props
  const newProps = newData.component.props

  // Update the original component with any property that may have changed during this render pass
  component.props = newProps

  newData.component = component

  // If the props changed, render immediately as we are already
  // in the render context of our parent
  if (!shallowEqual(oldProps, newProps)) {

    component.lifecycle.propsChanging = true
    component.lifecycle.propsChanged(newProps)
    component.lifecycle.propsChanging = false

    renderComponentNow(component)
  }
}
1184027
function () {
      var atts = this.atts, att, eh = this.eh, pvs = this.parent.vscope;
      if (atts) {
          // this template has no controller
          // let's propagate the new attribute values to the current scope
          var vscope = this.vscope;
          for (var i = 0, sz = this.atts.length; sz > i; i++) {
              att = atts[i];
              json.set(vscope, att.name, att.getValue(eh, pvs, null));
          }
      }
  }
1235526
protected function updateRouterBindings()
    {
        foreach ($this->getRouterBindings() as $key => $binding) {
            $this->app['api.router.adapter']->getRouter()->bind($key, $binding);
        }
    }
900806
function update(v, i, params, {oldValue}) {
      switch (i) {
      case 'children': _unobserveChildren(oldValue); _observeChildren(v); break;
      case 'attrs':    _unobserveAttrs   (oldValue); _observeAttrs   (v); break;
      }
    }
952893
function gotNavigation(results) {
  console.log('gotNavigation', results, browser);
  var browser;
  if (results.navigator === 'treemap') {
    browser = browseTreemap;
  } else if (results.navigator === 'facet') {
    browser = browseFacet;
  } else if (results.navigator === 'cluster') {
    browser = browseCluster;
  } else if (results.navigator === 'debug') {
    browser = browseDebug;
  }
  if (browser) {
    $('.browse.sidebar').sidebar('show');
    $('#browse').html();
    browser.render('#browse', results, resultView, context);
  } else {
    $('.browse.sidebar').sidebar('hide');
  }
}
273631
function bindToConsole (instance) {
  if (!instance) return
  if (!isBrowser) return

  const id = instance.__VUE_DEVTOOLS_UID__
  const index = consoleBoundInstances.indexOf(id)
  if (index > -1) {
    consoleBoundInstances.splice(index, 1)
  } else {
    consoleBoundInstances.pop()
  }

  consoleBoundInstances.unshift(id)
  for (var i = 0; i < 5; i++) {
    window['$vm' + i] = instanceMap.get(consoleBoundInstances[i])
  }
  window.$vm = instance
}
1199215
function() {
        var e = $(this);
        var thing_id = e.data("thing");
        var attribute_code = e.data("attribute");

        var transporter = js.transport.connect(thing_id, "istate");
        transporter.on_update(function(d) {
            var value = d[attribute_code];
            if (value === undefined) {
                return;
            }

            try {
                e.find('button').removeClass("selected");
                e.find('button[data-value="' + value + '"]').addClass("selected");
            } catch(x) {
                console.log("#", "interactors.enumeration", x);
            }
        });
    }
208259
def update
      @route_name ||= @controller_name ||= controller_name

      if @thing.update(thing_params)
        redirect_to things_path(@route_name), notice: "#{@controller_name.titleize} successfully updated."
      else
        @model = @thing.model_name.name.constantize
        render 'admin/edit'
      end
    end
732269
function updatePossibleNavigations(element) {
  let canSelectNext;
  let canSelectPrevious;
  const items = element.items;
  if (items == null || items.length === 0) {
    // No items to select.
    canSelectNext = false;
    canSelectPrevious = false;
  } if (element.selectionWraps) {
    // Since there are items, can always go next/previous.
    canSelectNext = true;
    canSelectPrevious = true;
  } else {
    const index = element.selectedIndex;
    if (index < 0 && items.length > 0) {
      // Special case. If there are items but no selection, declare that it's
      // always possible to go next/previous to create a selection.
      canSelectNext = true;
      canSelectPrevious = true;
    } else {
      // Normal case: we have an index in a list that has items.
      canSelectPrevious = (index > 0);
      canSelectNext = (index < items.length - 1);
    }
  }
  if (element.canSelectNext !== canSelectNext) {
    element.canSelectNext = canSelectNext;
  }
  if (element.canSelectPrevious !== canSelectPrevious) {
    element.canSelectPrevious = canSelectPrevious;
  }
}