The information provided here is accurate in indicating that AngularJS lacks awareness of the method, necessitating the need to inform Angular about any updated values.

In my opinion, I prefer utilizing $q for handling asynchronous actions instead of relying on await as it aligns with "The Angular way".

It's quite simple to wrap non-Angular methods with $q. For instance, this is how I wrap all Google Maps functions, as they consistently require passing a callback function for completion notification.

function doAThing()
{
    var defer = $q.defer();
    // Note that this method takes a `parameter` and a callback function
    someMethod(parameter, (someValue) => {
        $q.resolve(someValue)
    });

    return defer.promise;
}

You can then implement it like this

this.doAThing().then(someValue => {
    this.memberValue = someValue;
});

Alternatively, if you opt to continue using await, there is an improved approach over employing $apply, which involves utilizing $digest. Like so

async testAsync() {
   await this.$timeout(2000);
   this.text = "Changed";
   $scope.$digest(); <-- This leads to much faster processing :)
}

In this scenario, $scope.$digest proves more effective than $scope.$apply because the latter performs dirty checking (Angular's change detection mechanism) on all bound values across all scopes, potentially bearing performance costs - particularly noticeable when dealing with numerous bindings. However, $scope.$digest restricts its checking to bound values within the current $scope, enhancing performance significantly.

If you want to streamline this process, you can utilize the angular-async-await extension:

class SomeController {
  constructor($async) {
    this.testAsync = $async(this.testAsync.bind(this));
  }

  async testAsync() { ... }
}

The main purpose of this extension is to wrap promise-returning functions with a wrapper that triggers $rootScope.$apply() after execution. This ensures proper synchronization.

Attempting to automatically trigger digestion on an async function would require complex manipulations within both the framework and underlying Promise implementation. Consequently, this is not supported for native async functions as it relies on internal mechanisms rather than the global Promise. Controlled behavior is preferred over automatic actions in such scenarios.

To manage multiple calls to testAsync efficiently without causing unnecessary digest cycles, it is advisable to apply $async solely to the parent function testsAsync:

class SomeController {
  constructor($async) {
    this.testsAsync = $async(this.testsAsync.bind(this));
  }

  private async testAsync() { ... }

  async testsAsync() {
    await Promise.all([this.testAsync(1), this.testAsync(2), ...]);
    ...
  }
}

After thoroughly examining the code at angular-async-await, it appears that they are relying on $rootScope.$apply() to process the expression once the asynchronous promise is resolved.

However, this approach may not be optimal. By utilizing AngularJS's original $q and implementing a small workaround, you can achieve superior performance.

To start, create a function (such as a factory or method)

// inject $q ...
const resolver = (asyncFunc) => {
    const deferred = $q.defer();
    asyncFunc()
      .then(deferred.resolve)
      .catch(deferred.reject);
    return deferred.promise;
}

Now, you can incorporate this function into your services, for example.

getUserInfo = () => {

  return resolver(async() => {

    const userInfo = await fetch(...);
    const userAddress = await fetch (...);

    return {userInfo, userAddress};
  });
};

This method is just as efficient as using AngularJS $q, but with less code involved.

If you want to see the desired behavior in action, check out this fiddle I created: Promises with AngularJS. It includes Promises that resolve after 1000ms, an async function, and a Promise.race, all achieved with just 4 digest cycles (check the console).

Summarizing the goal:

• The aim was to utilize async functions without relying on third-party libraries like $async
• To automatically trigger the minimum required digest cycles

How did we accomplish this?

In ES6, the introduction of Proxy brought about valuable new possibilities. This allowed us to wrap a Promise within a Proxy object, which triggers a digest cycle only when necessary upon resolution or rejection.

This innovative approach integrates seamlessly as a runtime change within AngularJS:

function($rootScope) {
  function triggerDigestIfNeeded() {
    $rootScope.$applyAsync();
  };

  Promise = new Proxy(Promise, {
    construct(target, argumentsList) {
      return (() => {
        const promise = new target(...argumentsList);

        promise.then((value) => {
          triggerDigestIfNeeded();

          return value;
        }, (reason) => {
          triggerDigestIfNeeded();

          return reason;
        });

        return promise;
      })();
    }
  });
}

By leveraging Promises at the core of asynchronous functions, our objective was met succinctly through minimal code snippets. Moreover, one can now seamlessly incorporate native Promises into AngularJS!

Update: The use of Proxy is not mandatory, as observed here where the same outcome is achievable using plain JavaScript:

Promise = ((Promise) => {
  const NewPromise = function(fn) {
    const promise = new Promise(fn);

    promise.then((value) => {
      triggerDigestIfNeeded();

      return value;
    }, (reason) => {
      triggerDigestIfNeeded();

      return reason;
    });

    return promise;
  };

  // Clone the prototype
  NewPromise.prototype = Promise.prototype;

  // Copy all writable instance properties
  for (const propertyName of Object.getOwnPropertyNames(Promise)) {
    const propDesc = Object.getOwnPropertyDescriptor(Promise, propertyName);

    if (propDesc.writable) {
      NewPromise[propertyName] = Promise[propertyName];
    }
  }

  return NewPromise;
})(Promise) as any;

According to @basarat, the native ES6 Promise does not have knowledge of the digest cycle.

To work around this, you can instruct Typescript to utilize the $q service promise instead of the native ES6 promise.

This method eliminates the need to call $scope.$apply()

angular.module('myApp')
    .run(['$window', '$q', ($window, $q) =>  {
        $window.Promise = $q;
    }]);

If you are transitioning from AngularJS to Angular using ngUpgrade (refer to https://angular.io/guide/upgrade#upgrading-with-ngupgrade):

Since Zone.js updates native Promises, it is advisable to convert all $q-based AngularJS promises to native Promises. This is because Angular automatically triggers a $digest when the microtask queue is cleared (such as when a Promise is resolved).

Even if your plan does not involve upgrading to Angular, you can still incorporate Zone.js into your project and set up a similar hook like ngUpgrade for improved functionality.

Is there a way to avoid having to constantly use $scope.$apply() in my code?

The reason for this is that TypeScript relies on the default browser implementation of native Promise, which Angular 1.x does not recognize. To ensure proper dirty checking, all asynchronous functions outside of Angular's control must manually trigger a digest cycle.

In agreement with @basarat, the traditional ES6 Promise does not have knowledge of the digest cycle. You need to use a promise in the following way:

async runAsyncTest() {
 await this.$timeout(2000).toPromise()
      .then(response => this.text = "Updated");
 }

Angular faces the challenge of not being able to detect when the native Promise is completed. In order to address this issue, all async functions generate a new Promise.

An effective workaround could involve:

window.Promise = $q;

This approach enables TypeScript/Babel to utilize angular promises instead. Is it a foolproof solution? I cannot fully guarantee its safety yet - ongoing tests are still in progress.