@angular-wave/angular.ts 0.7.7 → 0.8.0

package/src/router/url/url-service.js

@@ -12,46 +12,44 @@ import { stripLastPathElement } from "../../shared/strings.js";
 import { UrlMatcher } from "./url-matcher.js";
 import { ParamFactory } from "../params/param-factory.js";
 import { UrlRuleFactory } from "./url-rule.js";
+import { getBaseHref } from "../../shared/dom.js";
+import { $injectTokens as $t, provider } from "../../injection-tokens.js";
 
 /**
  * API for URL management
  */
 export class UrlService {
-  static $inject = [
-    "$locationProvider",
-    "$stateProvider",
-    "$routerGlobalsProvider",
-    "$urlConfigProvider",
-  ];
+  static $inject = provider([
+    $t.$location,
+    $t.$state,
+    $t.$routerGlobals,
+    $t.$urlConfig,
+  ]);
+
+  /** @type {import("../../services/location/location").Location} */
+  $location;
 
   /**
-   * @param {import("../../core/location/location").LocationProvider} $locationProvider
+   * @param {import("../../services/location/location").LocationProvider} $locationProvider
    * @param {import("../../router/state/state-service.js").StateProvider} stateService
-   * @param globals
+   * @param {import("../../router/globals.js").RouterGlobals} globals
    * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
    */
   constructor($locationProvider, stateService, globals, urlConfigProvider) {
+    this.$locationProvider = $locationProvider;
     this.stateService = stateService;
     this.stateService.urlService = this; // circular wiring
-    this.$locationProvider = $locationProvider;
-
-    this.$location = undefined;
-    this.$browser = undefined;
 
     /** Provides services related to the URL */
     this.urlRuleFactory = new UrlRuleFactory(this, this.stateService, globals);
 
     /**
      * The nested [[UrlRules]] API for managing URL rules and rewrites
-     *
-     * See: [[UrlRules]] for details
      * @type {UrlRules}
      */
     this.rules = new UrlRules(this.urlRuleFactory);
     /**
      * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
-     *
-     * See: [[UrlConfig]] for details
      * @type {import("./url-config.js").UrlConfigProvider}
      */
     this.config = urlConfigProvider;
@@ -59,72 +57,69 @@ export class UrlService {
     /** Creates a new [[Param]] for a given location (DefType) */
     this.paramFactory = new ParamFactory(this.config);
 
-    /**
-     * Gets the path part of the current url
-     *
-     * If the current URL is `/some/path?query=value#anchor`, this returns `/some/path`
-     *
-     * @return the path portion of the url
-     */
-    this.path = () => this.$location.path();
-    /**
-     * Gets the search part of the current url as an object
-     *
-     * If the current URL is `/some/path?query=value#anchor`, this returns `{ query: 'value' }`
-     *
-     * @return the search (query) portion of the url, as an object
-     */
-    this.search = () => this.$location.search();
-    /**
-     * Gets the hash part of the current url
-     *
-     * If the current URL is `/some/path?query=value#anchor`, this returns `anchor`
-     *
-     * @return the hash (anchor) portion of the url
-     */
-    this.hash = () => this.$location.hash();
-
     this._urlListeners = [];
   }
 
+  /**
+   * Gets the path part of the current url
+   *
+   * If the current URL is `/some/path?query=value#anchor`, this returns `/some/path`
+   *
+   * @return {string} the path portion of the url
+   */
+  getPath() {
+    return this.$location.getPath();
+  }
+
+  /**
+   * Gets the search part of the current url as an object
+   *
+   * If the current URL is `/some/path?query=value#anchor`, this returns `{ query: 'value' }`
+   *
+   * @return {Object} the search (query) portion of the url, as an object
+   */
+  getSearch() {
+    return this.$location.getSearch();
+  }
+  /**
+   * Gets the hash part of the current url
+   *
+   * If the current URL is `/some/path?query=value#anchor`, this returns `anchor`
+   *
+   * @return {string} the hash (anchor) portion of the url
+   */
+  getHash() {
+    return this.$location.getHash();
+  }
+
   $get = [
-    "$location",
-    "$browser",
-    "$rootScope",
+    $t.$location,
+    $t.$rootScope,
     /**
      *
-     * @param {import('../../core/location/location.js').Location} $location
-     * @param {import('../../services/browser.js').Browser} $browser
+     * @param {import('../../services/location/location.js').Location} $location
      * @param {import('../../core/scope/scope.js').Scope} $rootScope
      * @returns {UrlService}
      */
-    ($location, $browser, $rootScope) => {
+    ($location, $rootScope) => {
       this.$location = $location;
-      this.$browser = $browser;
       $rootScope.$on("$locationChangeSuccess", (evt) => {
         this._urlListeners.forEach((fn) => {
           fn(evt);
         });
       });
-      this.listen();
+      this.listen(true);
       return this;
     },
   ];
 
   /**
-   * @returns {boolean}
+   * @returns {string}
    */
-  html5Mode() {
-    return (
-      this.$locationProvider.getHtml5Mode().enabled &&
-      typeof history !== "undefined"
-    );
-  }
-
   baseHref() {
     return (
       this._baseHref ||
-      (this._baseHref = this.$browser.baseHref() || window.location.pathname)
+      (this._baseHref = getBaseHref() || window.location.pathname)
     );
   }
 
@@ -175,20 +170,18 @@ export class UrlService {
    * @param {string} [newUrl] The new value for the URL.
    *               This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.
    *               It should not include the protocol, site, port, or base path of an absolute HREF.
-   * @param {boolean} [replace] When true, replaces the current history entry (instead of appending it) with this new url
    * @param {any} [state] The history's state object, i.e., pushState (if the LocationServices implementation supports it)
    *
    * @return the url (after potentially being processed)
    */
-  url(newUrl, replace = false, state) {
-    if (isDefined(newUrl)) this.$location.url(newUrl);
-    if (replace) this.$location.replace();
-    if (state) this.$location.state(state);
-    return this.$location.url();
+  url(newUrl, state) {
+    if (isDefined(newUrl)) this.$location.setUrl(newUrl);
+    if (state) this.$location.setState(state);
+    return this.$location.getUrl();
   }
 
   /**
-   * @internal
+   * @private
    *
    * Registers a low level url change handler
    *
@@ -199,8 +192,8 @@ export class UrlService {
    * let deregisterFn = locationServices.onChange((evt) => console.log("url change", evt));
    * ```
    *
-   * @param callback a function that will be called when the url is changing
-   * @return a function that de-registers the callback
+   * @param {Function} callback a function that will be called when the url is changing
+   * @return {Function} a function that de-registers the callback
    */
   onChange(callback) {
     this._urlListeners.push(callback);
@@ -208,13 +201,21 @@ export class UrlService {
   }
 
   /**
-   * Gets the current URL parts
+   * Gets the current URL parts.
+   *
+   * Returns an object with the `path`, `search`, and `hash` components
+   * of the current browser location.
    *
-   * This method returns the different parts of the current URL (the [[path]], [[search]], and [[hash]]) as a [[UrlParts]] object.
+   * @returns {import("../../services/location/interface.ts").UrlParts} The current URL's path, search, and hash.
    */
   parts() {
-    return { path: this.path(), search: this.search(), hash: this.hash() };
+    return {
+      path: this.$location.getPath(),
+      search: this.$location.getSearch(),
+      hash: this.$location.getHash(),
+    };
   }
+
   /**
    * Activates the best rule for the current URL
    *
@@ -238,16 +239,16 @@ export class UrlService {
     if (evt && evt.defaultPrevented) return;
     const stateService = this.stateService;
     const url = {
-      path: this.path(),
-      search: this.search(),
-      hash: this.hash(),
+      path: this.$location.getPath(),
+      search: this.$location.getSearch(),
+      hash: this.$location.getHash(),
     };
     /**
      * @type {*}
      */
     const best = this.match(url);
     const applyResult = pattern([
-      [isString, (newurl) => this.url(newurl, true)],
+      [isString, (newurl) => this.url(newurl)],
       [
         TargetState.isDef,
         (def) => stateService.go(def.state, def.params, def.options),
@@ -280,7 +281,7 @@ export class UrlService {
    * });
    * ```
    *
-   * @param enabled `true` or `false` to start or stop listening to URL changes
+   * @param {boolean} enabled `true` or `false` to start or stop listening to URL changes
    */
   listen(enabled) {
     if (enabled === false) {
@@ -358,7 +359,7 @@ export class UrlService {
    * ```js
    * matcher = $umf.compile("/about/:person");
    * params = { person: "bob" };
-   * $bob = $urlService.href(matcher, params);
+   * $bob = $url.href(matcher, params);
    * // $bob == "/about/bob";
    * ```
    *
@@ -374,22 +375,18 @@ export class UrlService {
     let url = urlMatcher.format(params);
     if (url == null) return null;
     options = options || { absolute: false };
-    const isHtml5 = this.html5Mode();
-    if (!isHtml5 && url !== null) {
-      url = "#" + this.$locationProvider.getHashPrefix() + url;
+    const isHtml5 = this.$locationProvider.html5ModeConf.enabled;
+    if (!isHtml5) {
+      url = "#" + this.$locationProvider.hashPrefixConf + url;
     }
     url = appendBasePath(url, isHtml5, options.absolute, this.baseHref());
     if (!options.absolute || !url) {
       return url;
     }
     const slash = !isHtml5 && url ? "/" : "";
-    const cfgPort = this.$location.port();
-    const port = cfgPort === 80 || cfgPort === 443 ? "" : ":" + cfgPort;
     return [
-      this.$location.protocol(),
-      "://",
-      this.$location.host(),
-      port,
+      `${window.location.protocol}//`,
+      window.location.host,
       slash,
       url,
     ].join("");

package/src/router/url/url-service.spec.js

@@ -1,5 +1,5 @@
 import { dealoc } from "../../shared/dom.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { map, find } from "../../shared/common.js";
 
 describe("UrlMatcher", () => {
@@ -15,8 +15,8 @@ describe("UrlMatcher", () => {
       "defaultModule",
     ]);
 
-    $injector.invoke(($urlService, _$location_) => {
-      $url = $urlService;
+    $injector.invoke((_$url_, _$location_) => {
+      $url = _$url_;
       $location = _$location_;
     });
   });
@@ -359,7 +359,7 @@ describe("UrlMatcher", () => {
       expect(matcher).not.toBe(base);
     });
 
-    it("should respect $urlServiceProvider.strictMode", () => {
+    it("should respect $urlProvider.strictMode", () => {
       let m = $url.compile("/");
       $url.config.strictMode(false);
       m = m.append($url.compile("foo"));
@@ -367,7 +367,7 @@ describe("UrlMatcher", () => {
       expect(m.exec("/foo/")).toEqual({});
     });
 
-    it("should respect $urlServiceProvider.caseInsensitive", () => {
+    it("should respect $urlProvider.caseInsensitive", () => {
       let m = $url.compile("/");
       $url.config.caseInsensitive(true);
       m = m.append($url.compile("foo"));
@@ -375,7 +375,7 @@ describe("UrlMatcher", () => {
       expect(m.exec("/FOO")).toEqual({});
     });
 
-    it("should respect $urlServiceProvider.caseInsensitive when validating regex params", () => {
+    it("should respect $urlProvider.caseInsensitive when validating regex params", () => {
       let m = $url.compile("/");
       $url.config.caseInsensitive(true);
       m = m.append($url.compile("foo/{param:bar}"));
@@ -441,15 +441,21 @@ describe("UrlMatcher", () => {
       });
 
       $url.url("/foo");
-      expect(m.exec($url.path(), $url.search())).toEqual({ param1: undefined });
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
+        param1: undefined,
+      });
       $url.url("/foo?param1=bar");
-      expect(m.exec($url.path(), $url.search())).toEqual({ param1: "bar" }); // auto unwrap
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
+        param1: "bar",
+      }); // auto unwrap
       $url.url("/foo?param1=");
-      expect(m.exec($url.path(), $url.search())).toEqual({ param1: undefined });
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
+        param1: undefined,
+      });
       $url.url("/foo?param1=bar&param1=baz");
-      if (Array.isArray($url.search()))
+      if (Array.isArray($url.getSearch()))
         // conditional for angular 1.0.8
-        expect(m.exec($url.path(), $url.search())).toEqual({
+        expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
           param1: ["bar", "baz"],
         });
 
@@ -485,15 +491,21 @@ describe("UrlMatcher", () => {
       });
 
       $url.url("/foo");
-      expect(m.exec($url.path(), $url.search())).toEqual({ param1: undefined });
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
+        param1: undefined,
+      });
       $url.url("/foo?param1=");
-      expect(m.exec($url.path(), $url.search())).toEqual({ param1: undefined });
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
+        param1: undefined,
+      });
       $url.url("/foo?param1=bar");
-      expect(m.exec($url.path(), $url.search())).toEqual({ param1: ["bar"] });
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
+        param1: ["bar"],
+      });
       $url.url("/foo?param1=bar&param1=baz");
-      if (Array.isArray($url.search()))
+      if (Array.isArray($url.getSearch()))
         // conditional for angular 1.0.8
-        expect(m.exec($url.path(), $url.search())).toEqual({
+        expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
           param1: ["bar", "baz"],
         });
 
@@ -512,16 +524,16 @@ describe("UrlMatcher", () => {
       expect(m.exec("/foo")).toEqual({ "param1[]": undefined });
 
       $url.url("/foo?param1[]=bar");
-      expect(m.exec($url.path(), $url.search())).toEqual({
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
         "param1[]": ["bar"],
       });
       expect(m.format({ "param1[]": "bar" })).toBe("/foo?param1[]=bar");
       expect(m.format({ "param1[]": ["bar"] })).toBe("/foo?param1[]=bar");
 
       $url.url("/foo?param1[]=bar&param1[]=baz");
-      if (Array.isArray($url.search()))
+      if (Array.isArray($url.getSearch()))
         // conditional for angular 1.0.8
-        expect(m.exec($url.path(), $url.search())).toEqual({
+        expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
           "param1[]": ["bar", "baz"],
         });
       expect(m.format({ "param1[]": ["bar", "baz"] })).toBe(
@@ -575,14 +587,16 @@ describe("UrlMatcher", () => {
       expect(m.exec("/foo")).toEqual({ param1: undefined });
 
       $url.url("/foo?param1=bar");
-      expect(m.exec($url.path(), $url.search())).toEqual({ param1: "bar" });
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
+        param1: "bar",
+      });
       expect(m.format({ param1: "bar" })).toBe("/foo?param1=bar");
       expect(m.format({ param1: ["bar"] })).toBe("/foo?param1=bar");
 
       $url.url("/foo?param1=bar&param1=baz");
-      if (Array.isArray($url.search()))
+      if (Array.isArray($url.getSearch()))
         // conditional for angular 1.0.8
-        expect(m.exec($url.path(), $url.search())).toEqual({
+        expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
           param1: "bar,baz",
         }); // coerced to string
       expect(m.format({ param1: ["bar", "baz"] })).toBe(
@@ -610,7 +624,9 @@ describe("UrlMatcher", () => {
       expect(m.exec("/foo/")).toEqual({ param1: undefined });
       expect(m.exec("/foo/bar")).toEqual({ param1: ["bar"] });
       $url.url("/foo/bar-baz");
-      expect(m.exec($location.url())).toEqual({ param1: ["bar", "baz"] });
+      expect(m.exec($location.getUrl())).toEqual({
+        param1: ["bar", "baz"],
+      });
 
       expect(m.format({ param1: [] })).toEqual("/foo/");
       expect(m.format({ param1: ["bar"] })).toEqual("/foo/bar");
@@ -633,15 +649,15 @@ describe("UrlMatcher", () => {
       expect(m.exec("/foo/1-2")).toEqual({ "param1[]": ["1", "2"] });
 
       $url.url("/foo/");
-      expect(m.exec($url.path(), $url.search())).toEqual({
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
         "param1[]": undefined,
       });
       $url.url("/foo/bar");
-      expect(m.exec($url.path(), $url.search())).toEqual({
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
         "param1[]": ["bar"],
       });
       $url.url("/foo/bar-baz");
-      expect(m.exec($url.path(), $url.search())).toEqual({
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
         "param1[]": ["bar", "baz"],
       });
 
@@ -685,19 +701,19 @@ describe("UrlMatcher", () => {
 
       // check that we handle $location.url decodes correctly
       $url.url(m.format({ "param1[]": ["bar-", "-baz"] }));
-      expect(m.exec($url.path(), $url.search())).toEqual({
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
         "param1[]": ["bar-", "-baz"],
       });
 
       // check that we handle $location.url decodes correctly for multiple hyphens
       $url.url(m.format({ "param1[]": ["bar-bar-bar-", "-baz-baz-baz"] }));
-      expect(m.exec($url.path(), $url.search())).toEqual({
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
         "param1[]": ["bar-bar-bar-", "-baz-baz-baz"],
       });
 
       // check that pre-encoded values are passed correctly
       $url.url(m.format({ "param1[]": ["%2C%20%5C%2C", "-baz"] }));
-      expect(m.exec($url.path(), $url.search())).toEqual({
+      expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
         "param1[]": ["%2C%20%5C%2C", "-baz"],
       });
     });
@@ -708,9 +724,9 @@ describe("UrlMatcher", () => {
 //   describe(".type()", ( ) => {
 //     let $url;
 //     beforeEach(
-//       module("ng.router.util", function ($urlServiceProvider) {
-//         $url = $urlServiceProvider;
-//         $urlServiceProvider.type("myType", {}, ( ) => {
+//       module("ng.router.util", function ($urlProvider) {
+//         $url = $urlProvider;
+//         $urlProvider.type("myType", {}, ( ) => {
 //           return {
 //             decode: ( ) => {
 //               return { status: "decoded" };
@@ -744,9 +760,9 @@ describe("UrlMatcher", () => {
 //   let $url;
 //   let $url;
 
-//   beforeEach(function ($urlMatcherFactory, $urlService) {
+//   beforeEach(function ($urlMatcherFactory, $url) {
 //     $url = $urlMatcherFactory;
-//     $url = $urlService;
+//     $url = $url;
 //   });
 
 //   it("compiles patterns", ( ) => {
@@ -903,13 +919,13 @@ describe("UrlMatcher", () => {
 //       const m = $url.compile("/foo/{fooid:int}?{bar:int}");
 
 //       $url.url("/foo/5?bar=1");
-//       expect(m.exec($url.path(), $url.search())).toEqual({ fooid: 5, bar: 1 });
+//       expect(m.exec($url.getPath(), $url.getSearch())).toEqual({ fooid: 5, bar: 1 });
 //       expect(m.format({ fooid: 5, bar: 1 })).toEqual("/foo/5?bar=1");
 
 //       $url.url("/foo/5?bar=1&bar=2&bar=3");
-//       if (Array.isArray($url.search()))
+//       if (Array.isArray($url.getSearch()))
 //         // conditional for angular 1.0.8
-//         expect(m.exec($url.path(), $url.search())).toEqual({
+//         expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
 //           fooid: 5,
 //           bar: [1, 2, 3],
 //         });
@@ -937,11 +953,11 @@ describe("UrlMatcher", () => {
 //       });
 
 //       $url.url("/foo?bar=fox");
-//       expect(m.exec($url.path(), $url.search())).toEqual({ bar: ["fox"] });
+//       expect(m.exec($url.getPath(), $url.getSearch())).toEqual({ bar: ["fox"] });
 //       expect(m.format({ bar: ["fox"] })).toEqual("/foo?bar=fox");
 
 //       $url.url("/foo?bar=quick-brown-fox");
-//       expect(m.exec($url.path(), $url.search())).toEqual({
+//       expect(m.exec($url.getPath(), $url.getSearch())).toEqual({
 //         bar: ["quick", "brown", "fox"],
 //       });
 //       expect(m.format({ bar: ["quick", "brown", "fox"] })).toEqual(

package/src/router/url/url.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/router/url/url.html";
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
+  await page.waitForTimeout(1000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/router/view/view.js

@@ -1,7 +1,8 @@
-import { equals, applyPairs, removeFrom, find } from "../../shared/common.js";
+import { applyPairs, equals, find, removeFrom } from "../../shared/common.js";
 import { curry } from "../../shared/hof.js";
 import { trace } from "../common/trace.js";
 import { getViewConfigFactory } from "../state/views.js";
+
 /**
  * The View service
  *
@@ -26,8 +27,7 @@ export class ViewService {
     this._listeners = [];
     this._pluginapi = {
       _registeredUIView: (id) => {
-        const res = find(this._ngViews, (view) => view.id === id);
-        return res;
+        return find(this._ngViews, (view) => view.id === id);
       },
       _registeredUIViews: () => this._ngViews,
       _activeViewConfigs: () => this._viewConfigs,
@@ -65,8 +65,7 @@ export class ViewService {
       throw new Error(
         "ViewService: No view config factory registered for type " + decl.$type,
       );
-    const cfgs = cfgFactory(path, decl);
-    return cfgs;
+    return cfgFactory(path, decl);
   }
   /**
    * Deactivates a ViewConfig.

package/src/router/view/view.spec.js

@@ -1,5 +1,5 @@
 import { dealoc } from "../../shared/dom.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { curry } from "../../shared/hof.js";
 import { StateMatcher } from "../state/state-matcher.js";
 import { StateBuilder } from "../state/state-builder.js";
@@ -17,7 +17,7 @@ describe("view", () => {
     $injector,
     elem = document.getElementById("app"),
     $controllerProvider,
-    $urlServiceProvider,
+    $urlProvider,
     $view,
     root,
     states;
@@ -27,15 +27,13 @@ describe("view", () => {
     window.angular = new Angular();
     window.angular
       .module("defaultModule", [])
-      .config(
-        function (_$provide_, _$controllerProvider_, _$urlServiceProvider_) {
-          _$provide_.factory("foo", () => {
-            return "Foo";
-          });
-          $controllerProvider = _$controllerProvider_;
-          $urlServiceProvider = _$urlServiceProvider_;
-        },
-      );
+      .config(function (_$provide_, _$controllerProvider_, _$urlProvider_) {
+        _$provide_.factory("foo", () => {
+          return "Foo";
+        });
+        $controllerProvider = _$controllerProvider_;
+        $urlProvider = _$urlProvider_;
+      });
     $injector = window.angular.bootstrap(document.getElementById("app"), [
       "defaultModule",
     ]);
@@ -46,7 +44,7 @@ describe("view", () => {
       $injector = _$injector_;
       states = {};
       const matcher = new StateMatcher(states);
-      const stateBuilder = new StateBuilder(matcher, $urlServiceProvider);
+      const stateBuilder = new StateBuilder(matcher, $urlProvider);
       stateBuilder.builder("views", ng1ViewsBuilder);
       register = registerState(states, stateBuilder);
       root = register({ name: "" });

package/src/router/view/view.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/router/view/view.html";
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
+  await page.waitForTimeout(1000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/router/view-hook.spec.js

@@ -1,5 +1,5 @@
 import { dealoc } from "../shared/dom.js";
-import { Angular } from "../loader.js";
+import { Angular } from "../angular.js";
 import { wait } from "../shared/test-utils.js";
 
 describe("view hooks", () => {

package/src/router/view-scroll.spec.js

@@ -1,5 +1,5 @@
 import { dealoc } from "../shared/dom.js";
-import { Angular } from "../loader.js";
+import { Angular } from "../angular.js";
 import { wait } from "../shared/test-utils.js";
 
 describe("ngView", () => {