Method validateAsync

modules/core/ValidationSystem.js:522–576

* validateAsync * Validates anything that has changed in the head graph since the last time it was run. * (head graph contains user's edits) * Returns a Promise fulfilled when the validation has completed and then emits a `validated` event. * This may take time but happen in the backgrou

()

   * @return  {Promise}  Promise fulfilled when validation is completed.
   */
  validateAsync() {
    const context = this.context;
    const editor = context.systems.editor;
    this._completeDiff = editor.difference().complete();

    if (editor.canRestoreBackup) return Promise.resolve();   // Wait to see if the user wants to restore their backup
    if (this._validationPromise) return this._validationPromise;   // Validation already in progress

    const baseGraph = editor.base.graph;
    const stableGraph = editor.stable.graph;
    const previousGraph = this._head.graph ?? baseGraph;   // the previously validated graph

    // User has not edited, or undone back to the base state, reset head cache
    if (stableGraph === baseGraph) {
      this._head = new ValidationCache('head');
      this._head.graph = stableGraph;
      this._resolvedIssueIDs.clear();
      this.emit('validated');
      return Promise.resolve();
    }

    // We are caught up to the stable graph
    if (stableGraph === previousGraph) {
      this.emit('validated');
      return Promise.resolve();
    }

    // If we get here, stable !== previous, so it's time to validate the stable graph..
    this._head.graph = stableGraph;   // take snapshot
    const incrementalDiff = new Difference(previousGraph, stableGraph);
    let entityIDs = [ ...incrementalDiff.complete().keys() ];
    entityIDs = this._head.withAllRelatedEntities(entityIDs);  // expand set

    if (!entityIDs.size) {    // nothing to do - committed a no-op edit?
      this.emit('validated');
      return Promise.resolve();
    }

    this._validationPromise = this._validateEntitiesAsync(this._head, entityIDs)
      .then(() => this._updateResolvedIssues(entityIDs))
      .then(() => this.emit('validated'))
      .catch(e => console.error(e))  // eslint-disable-line
      .then(() => {
        this._validationPromise = null;

        // Check if `stable` has changed while we were validating, and run it again to catch up if needed...
        const stableGraph = editor.stable.graph;
        const previousGraph = this._head.graph;
        if (stableGraph !== previousGraph) {
          this.validateAsync();  // recurse
        }
      });

    return this._validationPromise;
  }


  /**