@angular-wave/angular.ts 0.7.8 → 0.8.1

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", () => {
@@ -10,13 +10,18 @@ describe("UrlMatcher", () => {
   beforeEach(() => {
     dealoc(document.getElementById("app"));
     window.angular = new Angular();
-    window.angular.module("defaultModule", []);
+    window.angular
+      .module("defaultModule", [])
+      .config(
+        ($locationProvider) =>
+          ($locationProvider.html5ModeConf.enabled = false),
+      );
     $injector = window.angular.bootstrap(document.getElementById("app"), [
       "defaultModule",
     ]);
 
-    $injector.invoke(($urlService, _$location_) => {
-      $url = $urlService;
+    $injector.invoke((_$url_, _$location_) => {
+      $url = _$url_;
       $location = _$location_;
     });
   });
@@ -80,44 +85,6 @@ describe("UrlMatcher", () => {
     expect(matcher.format(array)).toBe("/?foo=bar&foo=baz");
   });
 
-  it("should encode and decode slashes in parameter values as ~2F", () => {
-    const matcher1 = $url.compile("/:foo");
-
-    expect(matcher1.format({ foo: "/" })).toBe("/~2F");
-    expect(matcher1.format({ foo: "//" })).toBe("/~2F~2F");
-
-    expect(matcher1.exec("/")).toBeTruthy();
-    expect(matcher1.exec("//")).not.toBeTruthy();
-
-    expect(matcher1.exec("/").foo).toBe("");
-    expect(matcher1.exec("/123").foo).toBe("123");
-    expect(matcher1.exec("/~2F").foo).toBe("/");
-    expect(matcher1.exec("/123~2F").foo).toBe("123/");
-
-    // param :foo should match between two slashes
-    const matcher2 = $url.compile("/:foo/");
-
-    expect(matcher2.exec("/")).not.toBeTruthy();
-    expect(matcher2.exec("//")).toBeTruthy();
-
-    expect(matcher2.exec("//").foo).toBe("");
-    expect(matcher2.exec("/123/").foo).toBe("123");
-    expect(matcher2.exec("/~2F/").foo).toBe("/");
-    expect(matcher2.exec("/123~2F/").foo).toBe("123/");
-  });
-
-  it("should encode and decode tildes in parameter values as ~~", () => {
-    const matcher1 = $url.compile("/:foo");
-
-    expect(matcher1.format({ foo: "abc" })).toBe("/abc");
-    expect(matcher1.format({ foo: "~abc" })).toBe("/~~abc");
-    expect(matcher1.format({ foo: "~2F" })).toBe("/~~2F");
-
-    expect(matcher1.exec("/abc").foo).toBe("abc");
-    expect(matcher1.exec("/~~abc").foo).toBe("~abc");
-    expect(matcher1.exec("/~~2F").foo).toBe("~2F");
-  });
-
   describe("snake-case parameters", () => {
     it("should match if properly formatted", () => {
       const matcher = $url.compile(
@@ -359,7 +326,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 +334,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 +342,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 +408,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 +458,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 +491,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 +554,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 +591,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 +616,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 +668,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 +691,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 +727,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 +886,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 +920,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.js

@@ -1,3 +1,5 @@
+import { $injectTokens as $t } from "../injection-tokens.js";
+
 export class ViewScrollProvider {
   constructor() {
     this.enabled = false;
@@ -8,7 +10,7 @@ export class ViewScrollProvider {
   }
 
   $get = [
-    "$anchorScroll",
+    $t.$anchorScroll,
     /**
      * @param {import('../services/anchor-scroll.js').AnchorScrollObject} $anchorScroll
      * @returns {import('../services/anchor-scroll.js').AnchorScrollObject|Function}

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

@@ -1,10 +1,10 @@
 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", () => {
   describe("scrollIntoView", () => {
-    let elem, $anchorScroll, $ngViewScroll;
+    let elem, $anchorScroll, $viewScroll;
 
     beforeEach(() => {
       dealoc(document.getElementById("app"));
@@ -14,15 +14,15 @@ describe("ngView", () => {
         "defaultModule",
       ]);
 
-      $injector.invoke((_$ngViewScroll_, _$anchorScroll_) => {
+      $injector.invoke((_$viewScroll_, _$anchorScroll_) => {
         $anchorScroll = _$anchorScroll_;
-        $ngViewScroll = _$ngViewScroll_;
+        $viewScroll = _$viewScroll_;
       });
       elem = [{ scrollIntoView: jasmine.createSpy("scrollIntoView") }];
     });
 
     it("should scroll element into view after timeout", async () => {
-      $ngViewScroll(elem[0]);
+      $viewScroll(elem[0]);
       expect(elem[0].scrollIntoView).not.toHaveBeenCalled();
 
       await wait(100);
@@ -31,7 +31,7 @@ describe("ngView", () => {
 
     it("should return the promise from the timeout", async () => {
       dealoc(document.getElementById("app"));
-      const promise = $ngViewScroll(elem[0]);
+      const promise = $viewScroll(elem[0]);
 
       await wait(10);
       expect(elem[0].scrollIntoView).toHaveBeenCalled();
@@ -40,32 +40,32 @@ describe("ngView", () => {
   });
 
   describe("useAnchorScroll", () => {
-    let elem, $anchorScroll, $ngViewScroll;
+    let elem, $anchorScroll, $viewScroll;
 
     beforeEach(() => {
       dealoc(document.getElementById("app"));
       window.angular = new Angular();
       let module = window.angular.module("defaultModule", []);
-      module.config(($provide, $ngViewScrollProvider) => {
+      module.config(($provide, $viewScrollProvider) => {
         $provide.decorator("$anchorScroll", function ($delegate) {
           return jasmine.createSpy("$anchorScroll");
         });
-        $ngViewScrollProvider.useAnchorScroll();
+        $viewScrollProvider.useAnchorScroll();
       });
 
       let $injector = window.angular.bootstrap(document.getElementById("app"), [
         "defaultModule",
       ]);
 
-      $injector.invoke((_$ngViewScroll_, _$anchorScroll_) => {
+      $injector.invoke((_$viewScroll_, _$anchorScroll_) => {
         $anchorScroll = _$anchorScroll_;
-        $ngViewScroll = _$ngViewScroll_;
+        $viewScroll = _$viewScroll_;
       });
       elem = [{ scrollIntoView: jasmine.createSpy("scrollIntoView") }];
     });
 
     it("should call $anchorScroll", () => {
-      $ngViewScroll();
+      $viewScroll();
       expect($anchorScroll).toHaveBeenCalled();
     });
   });

package/src/services/anchor-scroll.html

@@ -23,10 +23,10 @@
               $scope.gotoAnchor = function (x) {
                 window.$locationTest = $location;
                 const newHash = "anchor" + x;
-                if ($location.hash() !== newHash) {
+                if ($location.getHash() !== newHash) {
                   // set the $location.hash to `newHash` and
                   // $anchorScroll will automatically scroll to it
-                  $location.hash("anchor" + x);
+                  $location.setHash("anchor" + x);
                 } else {
                   // call $anchorScroll() explicitly,
                   // since $location.hash hasn't changed

package/src/services/anchor-scroll.js

@@ -5,6 +5,7 @@ import {
   isString,
   getNodeName,
 } from "../shared/utils.js";
+import { $injectTokens as $t } from "../injection-tokens.js";
 
 /**
  * @typedef {Object} AnchorScrollObject
@@ -25,8 +26,8 @@ export class AnchorScrollProvider {
   }
 
   $get = [
-    "$location",
-    "$rootScope",
+    $t.$location,
+    $t.$rootScope,
     /**
      *
      * @param {import('../services/location/location.js').Location} $location
@@ -104,7 +105,7 @@ export class AnchorScrollProvider {
           ? hash
           : isNumber(hash)
             ? hash.toString()
-            : $location.hash();
+            : $location.getHash();
         let elm;
 
         // empty hash, scroll to the top of the page
@@ -121,7 +122,7 @@ export class AnchorScrollProvider {
       };
 
       // does not scroll when user clicks on anchor link that is currently on
-      // (no url change, no $location.hash() change), browser native does scroll
+      // (no url change, no $location.getHash() change), browser native does scroll
       if (this.autoScrollingEnabled) {
         $rootScope["$location"] = $location;
         $rootScope.$watch("$location.$$hash", (newVal, oldVal) => {

package/src/services/http/http.js

@@ -291,6 +291,7 @@ export function HttpProvider() {
   });
 
   let useApplyAsync = false;
+
   /**
    * Configure $http service to combine processing of multiple http responses received at around
    * the same time via {@link ng.$rootScope.Scope#$applyAsync $rootScope.$applyAsync}. This can result in
@@ -323,7 +324,7 @@ export function HttpProvider() {
    *
    * {@link ng.$http#interceptors Interceptors detailed info}
    */
-  const interceptorFactories = (this.interceptors = []);
+  this.interceptors = [];
 
   /**
    * Array containing URLs whose origins are trusted to receive the XSRF token. See the
@@ -360,8 +361,10 @@ export function HttpProvider() {
    *     $http.get('https://stats.example.com/activity').then(...);
    *   }]);
    * ```
+   *
+   * @type {string[]}
    */
-  const xsrfTrustedOrigins = (this.xsrfTrustedOrigins = []);
+  this.xsrfTrustedOrigins = [];
 
   /**
    * This property is deprecated. Use {@link $httpProvider#xsrfTrustedOrigins xsrfTrustedOrigins}
@@ -407,7 +410,7 @@ export function HttpProvider() {
        */
       const reversedInterceptors = [];
 
-      interceptorFactories.forEach((interceptorFactory) => {
+      this.interceptors.forEach((interceptorFactory) => {
         reversedInterceptors.unshift(
           isString(interceptorFactory)
             ? $injector.get(interceptorFactory)
@@ -418,7 +421,9 @@ export function HttpProvider() {
       /**
        * A function to check request URLs against a list of allowed origins.
        */
-      const urlIsAllowedOrigin = urlIsAllowedOriginFactory(xsrfTrustedOrigins);
+      const urlIsAllowedOrigin = urlIsAllowedOriginFactory(
+        this.xsrfTrustedOrigins,
+      );
 
       /**
        * @property {Array.<Object>} requestConfig Array of config objects for currently pending

package/src/services/http/http.spec.js

@@ -1,6 +1,6 @@
 import { createInjector } from "../../core/di/injector.js";
 import { isObject } from "../../shared/utils.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { wait } from "../../shared/test-utils.js";
 
 export function getLastAjaxRequest() {
@@ -238,12 +238,7 @@ describe("$http", function () {
     });
     expect(response.headers).toBeDefined();
     expect(response.headers instanceof Function).toBe(true);
-    expect(response.headers("Content-Type")).toBe(
-      "application/json; charset=utf-8",
-    );
-    expect(response.headers("content-type")).toBe(
-      "application/json; charset=utf-8",
-    );
+    expect(response.headers("Content-Type")).toBe("text/html; charset=utf-8");
   });
 
   it("may returns all response headers", async function () {

package/src/services/http/template-request.spec.js

@@ -1,5 +1,5 @@
 import { createInjector } from "../../core/di/injector.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { wait } from "../../shared/test-utils.js";
 
 describe("$templateRequest", () => {