Function performUpdate

packages/reactive-element/src/reactive-element.ts:1429–1520

* Performs an element update. Note, if an exception is thrown during the * update, `firstUpdated` and `updated` will not be called. * * Call `performUpdate()` to immediately process a pending update. This should * generally not be needed, but it can be done in rare cases when you need to

()

   * @category updates
   */
  protected performUpdate(): void {
    // Abort any update if one is not pending when this is called.
    // This can happen if `performUpdate` is called early to "flush"
    // the update.
    if (!this.isUpdatePending) {
      return;
    }
    debugLogEvent?.({kind: 'update'});
    if (!this.hasUpdated) {
      // Create renderRoot before first update. This occurs in `connectedCallback`
      // but is done here to support out of tree calls to `enableUpdating`/`performUpdate`.
      (this as Mutable<typeof this, 'renderRoot'>).renderRoot ??=
        this.createRenderRoot();
      if (DEV_MODE) {
        // Produce warning if any reactive properties on the prototype are
        // shadowed by class fields. Instance fields set before upgrade are
        // deleted by this point, so any own property is caused by class field
        // initialization in the constructor.
        const ctor = this.constructor as typeof ReactiveElement;
        const shadowedProperties = [...ctor.elementProperties.keys()].filter(
          (p) => this.hasOwnProperty(p) && p in getPrototypeOf(this)
        );
        if (shadowedProperties.length) {
          throw new Error(
            `The following properties on element ${this.localName} will not ` +
              `trigger updates as expected because they are set using class ` +
              `fields: ${shadowedProperties.join(', ')}. ` +
              `Native class fields and some compiled output will overwrite ` +
              `accessors used for detecting changes. See ` +
              `https://lit.dev/msg/class-field-shadowing ` +
              `for more information.`
          );
        }
      }
      // Mixin instance properties once, if they exist.
      if (this.__instanceProperties) {
        // TODO (justinfagnani): should we use the stored value? Could a new value
        // have been set since we stored the own property value?
        for (const [p, value] of this.__instanceProperties) {
          this[p as keyof this] = value as this[keyof this];
        }
        this.__instanceProperties = undefined;
      }
      // Trigger initial value reflection and populate the initial
      // `changedProperties` map, but only for the case of properties created
      // via `createProperty` on accessors, which will not have already
      // populated the `changedProperties` map since they are not set.
      // We can't know if these accessors had initializers, so we just set
      // them anyway - a difference from experimental decorators on fields and
      // standard decorators on auto-accessors.
      // For context see:
      // https://github.com/lit/lit/pull/4183#issuecomment-1711959635
      const elementProperties = (this.constructor as typeof ReactiveElement)
        .elementProperties;
      if (elementProperties.size > 0) {
        for (const [p, options] of elementProperties) {
          const {wrapped} = options;
          const value = this[p as keyof this];