@angular-wave/angular.ts 0.0.1 → 0.0.4

package/test/jqlite.spec.js

@@ -4,6 +4,7 @@ import { createInjector } from "../src/injector";
 import { publishExternalAPI } from "../src/public";
 import { equals, forEach } from "../src/core/utils";
 import { browserTrigger } from "./test-utils";
+import { CACHE, EXPANDO } from "../src/core/cache";
 
 describe("jqLite", () => {
   let scope;
@@ -572,13 +573,13 @@ describe("jqLite", () => {
       const node = document.createElement("div");
       document.body.appendChild(node);
 
-      expect(jqLite.hasData(node)).toBe(false);
+      expect(CACHE.has(node[EXPANDO])).toBe(false);
       expect(jqLite.data(node, "foo")).toBeUndefined();
-      expect(jqLite.hasData(node)).toBe(false);
+      expect(CACHE.has(node[EXPANDO])).toBe(false);
 
       jqLite.data(node, "foo", "bar");
 
-      expect(jqLite.hasData(node)).toBe(true);
+      expect(CACHE.has(node[EXPANDO])).toBe(true);
       expect(jqLite.data(node, "foo")).toBe("bar");
       expect(jqLite(node).data("foo")).toBe("bar");
 
@@ -593,7 +594,7 @@ describe("jqLite", () => {
       expect(jqLite.data(node, "bar")).toBeUndefined();
 
       jqLite(node).remove();
-      expect(jqLite.hasData(node)).toBe(false);
+      expect(CACHE.has(node[EXPANDO])).toBe(false);
     });
 
     it("should emit $destroy event if element removed via remove()", function () {
@@ -919,37 +920,6 @@ describe("jqLite", () => {
     });
   });
 
-  describe("prop", () => {
-    it("should read element property", () => {
-      const elm = jqLite('<div class="foo">a</div>');
-      expect(elm.prop("className")).toBe("foo");
-    });
-
-    it("should set element property to a value", () => {
-      const elm = jqLite('<div class="foo">a</div>');
-      elm.prop("className", "bar");
-      expect(elm[0].className).toBe("bar");
-      expect(elm.prop("className")).toBe("bar");
-    });
-
-    it("should set boolean element property", () => {
-      const elm = jqLite('<input type="checkbox">');
-      expect(elm.prop("checked")).toBe(false);
-
-      elm.prop("checked", true);
-      expect(elm.prop("checked")).toBe(true);
-
-      elm.prop("checked", "");
-      expect(elm.prop("checked")).toBe(false);
-
-      elm.prop("checked", "lala");
-      expect(elm.prop("checked")).toBe(true);
-
-      elm.prop("checked", null);
-      expect(elm.prop("checked")).toBe(false);
-    });
-  });
-
   describe("text", () => {
     it('should return `""` on empty', () => {
       expect(jqLite().length).toEqual(0);

package/test/messages/messages.spec.js

@@ -1,5 +1,5 @@
 import { createInjector } from "../../src/injector";
-import { countWatchers } from "../../src/core/rootScope";
+import { countWatchers } from "../../src/core/root-scope";
 import { publishExternalAPI } from "../../src/public";
 import { isString } from "../../src/core/utils";
 import { jqLite } from "../../src/jqLite";

package/test/ng/compile.spec.js

@@ -1,6 +1,6 @@
 import { publishExternalAPI } from "../../src/public";
 import { createInjector } from "../../src/injector";
-import { dealoc, jqLite, JQLite } from "../../src/jqLite";
+import { dealoc, JQLite } from "../../src/jqLite";
 import {
   forEach,
   isFunction,
@@ -10,7 +10,8 @@ import {
   extend,
   isArray,
 } from "../../src/core/utils";
-import { countChildScopes, countWatchers } from "../../src/core/rootScope";
+import { countChildScopes, countWatchers } from "../../src/core/root-scope";
+import { CACHE, EXPANDO } from "../../src/core/cache";
 
 function isUnknownElement(el) {
   return !!el.toString().match(/Unknown/);
@@ -930,7 +931,7 @@ describe("$compile", () => {
         "<input my-directive>",
         function (element, attrs) {
           attrs.$set("disabled", true);
-          expect(element.prop("disabled")).toBe(true);
+          expect(element[0]["disabled"]).toBe(true);
         },
       );
     });
@@ -941,7 +942,7 @@ describe("$compile", () => {
         "<input my-directive>",
         function (element, attrs) {
           attrs.$set("disabled", true, false);
-          expect(element.prop("disabled")).toBe(true);
+          expect(element[0]["disabled"]).toBe(true);
         },
       );
     });
@@ -16421,7 +16422,7 @@ describe("$compile", () => {
         '<svg><a xlink:href="" ng-href="{{ testUrl }}"></a></svg>',
       )($rootScope);
       $rootScope.$apply();
-      expect(element.find("a").prop("href").baseVal).toBe(
+      expect(element.find("a")[0].href.baseVal).toBe(
         "https://clean.example.org",
       );
       expect($$sanitizeUri).toHaveBeenCalledWith($rootScope.testUrl, false);
@@ -17083,15 +17084,15 @@ describe("$compile", () => {
 
       $rootScope.bar = "untrusted:test1";
       $rootScope.$apply();
-      expect(element.prop("foo")).toBe("unsafe:untrusted:test1");
+      expect(element[0].foo).toBe("unsafe:untrusted:test1");
 
       $rootScope.bar = $sce.trustAsCss("untrusted:test2");
       $rootScope.$apply();
-      expect(element.prop("foo")).toBe("unsafe:untrusted:test2");
+      expect(element[0].foo).toBe("unsafe:untrusted:test2");
 
       $rootScope.bar = $sce.trustAsMediaUrl("untrusted:test3");
       $rootScope.$apply();
-      expect(element.prop("foo")).toBe("untrusted:test3");
+      expect(element[0].foo).toBe("untrusted:test3");
     });
 
     it("should enforce the specified sce type for properties added for all elements (*)", () => {
@@ -17108,15 +17109,15 @@ describe("$compile", () => {
 
       $rootScope.bar = "untrusted:test1";
       $rootScope.$apply();
-      expect(element.prop("foo")).toBe("unsafe:untrusted:test1");
+      expect(element[0].foo).toBe("unsafe:untrusted:test1");
 
       $rootScope.bar = $sce.trustAsCss("untrusted:test2");
       $rootScope.$apply();
-      expect(element.prop("foo")).toBe("unsafe:untrusted:test2");
+      expect(element[0].foo).toBe("unsafe:untrusted:test2");
 
       $rootScope.bar = $sce.trustAsMediaUrl("untrusted:test3");
       $rootScope.$apply();
-      expect(element.prop("foo")).toBe("untrusted:test3");
+      expect(element[0].foo).toBe("untrusted:test3");
     });
 
     it("should enforce the specific sce type when both an element specific and generic exist", () => {
@@ -17134,15 +17135,15 @@ describe("$compile", () => {
 
       $rootScope.bar = "untrusted:test1";
       $rootScope.$apply();
-      expect(element.prop("foo")).toBe("unsafe:untrusted:test1");
+      expect(element[0].foo).toBe("unsafe:untrusted:test1");
 
       $rootScope.bar = $sce.trustAsCss("untrusted:test2");
       $rootScope.$apply();
-      expect(element.prop("foo")).toBe("unsafe:untrusted:test2");
+      expect(element[0].foo).toBe("unsafe:untrusted:test2");
 
       $rootScope.bar = $sce.trustAsMediaUrl("untrusted:test3");
       $rootScope.$apply();
-      expect(element.prop("foo")).toBe("untrusted:test3");
+      expect(element[0].foo).toBe("untrusted:test3");
     });
   });
 
@@ -17624,10 +17625,10 @@ describe("$compile", () => {
       linkedElements.remove();
 
       forEach(preCompiledChildren, (element, i) => {
-        expect(JQLite.hasData(element)).toBe(false, `template#${i}`);
+        expect(CACHE.has(element[EXPANDO])).toBe(false, `template#${i}`);
       });
       forEach(getAll(linkedElements), (element, i) => {
-        expect(JQLite.hasData(element)).toBe(false, `linked#${i}`);
+        expect(CACHE.has(element[EXPANDO])).toBe(false, `linked#${i}`);
       });
     }
 

package/test/ng/directive/model-options.spec.js

@@ -1,4 +1,4 @@
-import { defaultModelOptions } from "../../../src/directive/ngModelOptions";
+import { defaultModelOptions } from "../../../src/directive/model-options";
 import { dealoc, jqLite } from "../../../src/jqLite";
 import { publishExternalAPI } from "../../../src/public";
 import { createInjector } from "../../../src/injector";

package/test/ng/directive/model.spec.js

@@ -1,7 +1,7 @@
 import { jqLite, dealoc } from "../../../src/jqLite";
 import { publishExternalAPI } from "../../../src/public";
 import { createInjector } from "../../../src/injector";
-import { NgModelController } from "../../../src/directive/ngModel";
+import { NgModelController } from "../../../src/directive/model";
 import { isDefined, valueFn, isObject } from "../../../src/core/utils";
 import { browserTrigger } from "../../test-utils";
 

package/test/ng/directive/options.spec.js

@@ -395,7 +395,7 @@ describe("ngOptions", () => {
     expect(options.eq(0)[0].getAttribute("selected")).toBe("selected");
     expect(options.eq(0).attr("selected")).toBe("selected");
     expect(options.eq(0)[0].selected).toBe(true);
-    expect(options.eq(0).prop("selected")).toBe(true);
+    expect(options.eq(0)[0].selected).toBe(true);
 
     scope.selected = "0000FF";
     scope.$digest();
@@ -403,7 +403,7 @@ describe("ngOptions", () => {
     expect(options.eq(1)[0].getAttribute("selected")).toBe("selected");
     expect(options.eq(1).attr("selected")).toBe("selected");
     expect(options.eq(1)[0].selected).toBe(true);
-    expect(options.eq(1).prop("selected")).toBe(true);
+    expect(options.eq(1)[0].selected).toBe(true);
   });
 
   it("should render zero as a valid display value", () => {
@@ -678,17 +678,17 @@ describe("ngOptions", () => {
     const options = element.find("option");
 
     expect(scope.selected).toEqual(jasmine.objectContaining({ name: "A" }));
-    expect(options.eq(0).prop("selected")).toBe(true);
-    expect(options.eq(1).prop("selected")).toBe(false);
+    expect(options.eq(0)[0].selected).toBe(true);
+    expect(options.eq(1)[0].selected).toBe(false);
 
     const optionToSelect = options.eq(1);
 
     expect(optionToSelect.text()).toBe("B");
 
-    optionToSelect.prop("selected", true);
+    optionToSelect[0].selected = true;
     scope.$digest();
 
-    expect(optionToSelect.prop("selected")).toBe(true);
+    expect(optionToSelect[0].selected).toBe(true);
     expect(scope.selected).toBe(scope.values[0]);
   });
 
@@ -704,9 +704,9 @@ describe("ngOptions", () => {
     });
 
     const options = element.find("option");
-    expect(options.eq(0).prop("label")).toEqual("A");
-    expect(options.eq(1).prop("label")).toEqual("B");
-    expect(options.eq(2).prop("label")).toEqual("C");
+    expect(options.eq(0)[0].label).toEqual("A");
+    expect(options.eq(1)[0].label).toEqual("B");
+    expect(options.eq(2)[0].label).toEqual("C");
   });
 
   it("should update the label if only the property has changed", () => {
@@ -720,14 +720,14 @@ describe("ngOptions", () => {
     });
 
     let options = element.find("option");
-    expect(options.eq(0).prop("label")).toEqual("A");
-    expect(options.eq(1).prop("label")).toEqual("B");
-    expect(options.eq(2).prop("label")).toEqual("C");
+    expect(options.eq(0)[0].label).toEqual("A");
+    expect(options.eq(1)[0].label).toEqual("B");
+    expect(options.eq(2)[0].label).toEqual("C");
 
     scope.$apply('values[0].name = "X"');
 
     options = element.find("option");
-    expect(options.eq(0).prop("label")).toEqual("X");
+    expect(options.eq(0)[0].label).toEqual("X");
   });
 
   // bug fix #9714
@@ -741,7 +741,7 @@ describe("ngOptions", () => {
     let options = element.find("option");
     // we expect the selected option to be the "unknown" option
     expect(options.eq(0)).toEqualUnknownOption("");
-    expect(options.eq(0).prop("selected")).toEqual(true);
+    expect(options.eq(0)[0].selected).toEqual(true);
 
     // now add some real options - one of which matches the selected value
     scope.$apply(
@@ -890,10 +890,10 @@ describe("ngOptions", () => {
         const options = element.find("option");
 
         expect(options.length).toEqual(5);
-        expect(options.eq(1).prop("disabled")).toEqual(false);
-        expect(options.eq(2).prop("disabled")).toEqual(true);
-        expect(options.eq(3).prop("disabled")).toEqual(false);
-        expect(options.eq(4).prop("disabled")).toEqual(false);
+        expect(options.eq(1)[0].disabled).toEqual(false);
+        expect(options.eq(2)[0].disabled).toEqual(true);
+        expect(options.eq(3)[0].disabled).toEqual(false);
+        expect(options.eq(4)[0].disabled).toEqual(false);
       });
 
       it("should select disabled options when model changes", () => {
@@ -912,7 +912,7 @@ describe("ngOptions", () => {
         // Initially the model is set to an enabled option
         scope.$apply("selected = 30");
         let options = element.find("option");
-        expect(options.eq(3).prop("selected")).toEqual(true);
+        expect(options.eq(3)[0].selected).toEqual(true);
 
         // Now set the model to a disabled option
         scope.$apply("selected = 1");
@@ -922,10 +922,10 @@ describe("ngOptions", () => {
         // https://bugs.jquery.com/ticket/13097
         expect(element[0].value).toBe("number:1");
         expect(options.length).toEqual(4);
-        expect(options.eq(0).prop("selected")).toEqual(false);
-        expect(options.eq(1).prop("selected")).toEqual(true);
-        expect(options.eq(2).prop("selected")).toEqual(false);
-        expect(options.eq(3).prop("selected")).toEqual(false);
+        expect(options.eq(0)[0].selected).toEqual(false);
+        expect(options.eq(1)[0].selected).toEqual(true);
+        expect(options.eq(2)[0].selected).toEqual(false);
+        expect(options.eq(3)[0].selected).toEqual(false);
       });
 
       it("should select options in model when they become enabled", () => {
@@ -949,10 +949,10 @@ describe("ngOptions", () => {
         // https://bugs.jquery.com/ticket/13097
         expect(element[0].value).toBe("number:1");
         expect(options.length).toEqual(4);
-        expect(options.eq(0).prop("selected")).toEqual(false);
-        expect(options.eq(1).prop("selected")).toEqual(true);
-        expect(options.eq(2).prop("selected")).toEqual(false);
-        expect(options.eq(3).prop("selected")).toEqual(false);
+        expect(options.eq(0)[0].selected).toEqual(false);
+        expect(options.eq(1)[0].selected).toEqual(true);
+        expect(options.eq(2)[0].selected).toEqual(false);
+        expect(options.eq(3)[0].selected).toEqual(false);
 
         // Now enable that option
         scope.$apply(() => {
@@ -962,8 +962,8 @@ describe("ngOptions", () => {
         expect(element).toEqualSelectValue(1);
         options = element.find("option");
         expect(options.length).toEqual(4);
-        expect(options.eq(1).prop("selected")).toEqual(true);
-        expect(options.eq(3).prop("selected")).toEqual(false);
+        expect(options.eq(1)[0].selected).toEqual(true);
+        expect(options.eq(3)[0].selected).toEqual(false);
       });
     });
 
@@ -984,10 +984,10 @@ describe("ngOptions", () => {
         });
         const options = element.find("option");
 
-        expect(options.eq(0).prop("disabled")).toEqual(false);
-        expect(options.eq(1).prop("disabled")).toEqual(true);
-        expect(options.eq(2).prop("disabled")).toEqual(false);
-        expect(options.eq(3).prop("disabled")).toEqual(false);
+        expect(options.eq(0)[0].disabled).toEqual(false);
+        expect(options.eq(1)[0].disabled).toEqual(true);
+        expect(options.eq(2)[0].disabled).toEqual(false);
+        expect(options.eq(3)[0].disabled).toEqual(false);
       });
 
       it("should select disabled options when model changes", () => {
@@ -1007,25 +1007,25 @@ describe("ngOptions", () => {
         // Initially the model is set to an enabled option
         scope.$apply("selected = [3]");
         let options = element.find("option");
-        expect(options.eq(0).prop("selected")).toEqual(false);
-        expect(options.eq(1).prop("selected")).toEqual(false);
-        expect(options.eq(2).prop("selected")).toEqual(false);
-        expect(options.eq(3).prop("selected")).toEqual(true);
+        expect(options.eq(0)[0].selected).toEqual(false);
+        expect(options.eq(1)[0].selected).toEqual(false);
+        expect(options.eq(2)[0].selected).toEqual(false);
+        expect(options.eq(3)[0].selected).toEqual(true);
 
         // Now add a disabled option
         scope.$apply("selected = [1,3]");
         options = element.find("option");
-        expect(options.eq(0).prop("selected")).toEqual(false);
-        expect(options.eq(1).prop("selected")).toEqual(true);
-        expect(options.eq(2).prop("selected")).toEqual(false);
-        expect(options.eq(3).prop("selected")).toEqual(true);
+        expect(options.eq(0)[0].selected).toEqual(false);
+        expect(options.eq(1)[0].selected).toEqual(true);
+        expect(options.eq(2)[0].selected).toEqual(false);
+        expect(options.eq(3)[0].selected).toEqual(true);
 
         // Now only select the disabled option
         scope.$apply("selected = [1]");
-        expect(options.eq(0).prop("selected")).toEqual(false);
-        expect(options.eq(1).prop("selected")).toEqual(true);
-        expect(options.eq(2).prop("selected")).toEqual(false);
-        expect(options.eq(3).prop("selected")).toEqual(false);
+        expect(options.eq(0)[0].selected).toEqual(false);
+        expect(options.eq(1)[0].selected).toEqual(true);
+        expect(options.eq(2)[0].selected).toEqual(false);
+        expect(options.eq(3)[0].selected).toEqual(false);
       });
 
       it("should select options in model when they become enabled", () => {
@@ -1046,10 +1046,10 @@ describe("ngOptions", () => {
         scope.$apply("selected = [1]");
         let options = element.find("option");
 
-        expect(options.eq(0).prop("selected")).toEqual(false);
-        expect(options.eq(1).prop("selected")).toEqual(true);
-        expect(options.eq(2).prop("selected")).toEqual(false);
-        expect(options.eq(3).prop("selected")).toEqual(false);
+        expect(options.eq(0)[0].selected).toEqual(false);
+        expect(options.eq(1)[0].selected).toEqual(true);
+        expect(options.eq(2)[0].selected).toEqual(false);
+        expect(options.eq(3)[0].selected).toEqual(false);
 
         // Now enable that option
         scope.$apply(() => {
@@ -1058,10 +1058,10 @@ describe("ngOptions", () => {
 
         expect(element).toEqualSelectValue([1], true);
         options = element.find("option");
-        expect(options.eq(0).prop("selected")).toEqual(false);
-        expect(options.eq(1).prop("selected")).toEqual(true);
-        expect(options.eq(2).prop("selected")).toEqual(false);
-        expect(options.eq(3).prop("selected")).toEqual(false);
+        expect(options.eq(0)[0].selected).toEqual(false);
+        expect(options.eq(1)[0].selected).toEqual(true);
+        expect(options.eq(2)[0].selected).toEqual(false);
+        expect(options.eq(3)[0].selected).toEqual(false);
       });
     });
   });
@@ -1261,7 +1261,7 @@ describe("ngOptions", () => {
 
       // But the label of the selected option does not change
       const option = element.find("option").eq(1);
-      expect(option.prop("selected")).toEqual(true);
+      expect(option[0].selected).toEqual(true);
       expect(option.text()).toEqual("twenty"); // not 'new twenty'
     });
 
@@ -1291,7 +1291,7 @@ describe("ngOptions", () => {
 
         // But the label of the selected option does not change
         const option = element.find("option").eq(1);
-        expect(option.prop("selected")).toEqual(true);
+        expect(option[0].selected).toEqual(true);
         expect(option.text()).toEqual("twenty"); // not 'new twenty'
       },
     );
@@ -2194,7 +2194,7 @@ describe("ngOptions", () => {
       let options = element.find("option");
 
       expect(scope.options[1].unavailable).toEqual(true);
-      expect(options.eq(1).prop("disabled")).toEqual(true);
+      expect(options.eq(1)[0].disabled).toEqual(true);
 
       scope.$apply(() => {
         scope.options[1].unavailable = false;
@@ -2203,7 +2203,7 @@ describe("ngOptions", () => {
       options = element.find("option");
 
       expect(scope.options[1].unavailable).toEqual(false);
-      expect(options.eq(1).prop("disabled")).toEqual(false);
+      expect(options.eq(1)[0].disabled).toEqual(false);
     });
 
     it("should insert the unknown option if bound to null", () => {
@@ -2341,7 +2341,7 @@ describe("ngOptions", () => {
 
       expect(element.find("option").length).toEqual(2);
       expect(element).toEqualSelectValue(scope.selected);
-      expect(element.find("option").eq(0).prop("selected")).toBeTruthy();
+      expect(element.find("option").eq(0)[0].selected).toBeTruthy();
     });
 
     it("should remove unknown option when empty option exists and model is undefined", () => {
@@ -2858,7 +2858,7 @@ describe("ngOptions", () => {
       const options = element.find("option");
       const optionToSelect = options.eq(0);
       expect(optionToSelect.text()).toBe("Choose One");
-      expect(optionToSelect.prop("selected")).toBe(true);
+      expect(optionToSelect[0].selected).toBe(true);
       expect(element[0].value).toBe("");
 
       dealoc(element);
@@ -2878,7 +2878,7 @@ describe("ngOptions", () => {
       const options = element.find("option");
       const optionToSelect = options.eq(0);
       expect(optionToSelect.text()).toBe("Choose One");
-      expect(optionToSelect.prop("selected")).toBe(true);
+      expect(optionToSelect[0].selected).toBe(true);
       expect(element[0].value).toBe("");
 
       dealoc(element);
@@ -3355,7 +3355,7 @@ describe("ngOptions", () => {
 
       expect(element.val()).toBe("");
       const emptyOption = element.find("option").eq(0);
-      expect(emptyOption.prop("selected")).toBe(true);
+      expect(emptyOption[0].selected).toBe(true);
       expect(emptyOption.val()).toBe("");
     });
   });

package/test/ng/directive/select.spec.js

@@ -511,7 +511,7 @@ describe("select", () => {
 
         scope.robot = undefined;
         scope.$digest();
-        expect(element.find("option").eq(0).prop("selected")).toBe(true);
+        expect(element.find("option").eq(0)[0].selected).toBe(true);
         expect(element.find("option").eq(0).text()).toBe("--static-select--");
 
         scope.dynamicOptions = [
@@ -1440,7 +1440,7 @@ describe("select", () => {
 
       scope.selected = "option2";
       scope.$digest();
-      expect(element.find("option").eq(1).prop("selected")).toBe(true);
+      expect(element.find("option").eq(1)[0].selected).toBe(true);
       expect(element.find("option").eq(1).text()).toBe("Option 2");
     });
 
@@ -1468,7 +1468,7 @@ describe("select", () => {
       scope.$digest();
 
       expect(selectCtrl.removeOption).toHaveBeenCalledWith("");
-      expect(element.find("option").eq(1).prop("selected")).toBe(true);
+      expect(element.find("option").eq(1)[0].selected).toBe(true);
       expect(element.find("option").eq(1).text()).toBe("Option 2");
     });
 
@@ -1491,7 +1491,7 @@ describe("select", () => {
 
       scope.selected = "Option 2";
       scope.$digest();
-      expect(element.find("option").eq(1).prop("selected")).toBe(true);
+      expect(element.find("option").eq(1)[0].selected).toBe(true);
       expect(element.find("option").eq(1).text()).toBe("Option 2");
     });
 
@@ -1519,7 +1519,7 @@ describe("select", () => {
       scope.$digest();
 
       expect(selectCtrl.removeOption).toHaveBeenCalledWith("");
-      expect(element.find("option").eq(1).prop("selected")).toBe(true);
+      expect(element.find("option").eq(1)[0].selected).toBe(true);
       expect(element.find("option").eq(1).text()).toBe("Option 2 Changed");
     });
 
@@ -1646,9 +1646,9 @@ describe("select", () => {
           expect(scope.selected).toBe(null);
           expect(element[0].selectedIndex).toBe(0);
           expect(element.find("option").length).toBe(3);
-          expect(element.find("option").eq(0).prop("selected")).toBe(true);
+          expect(element.find("option").eq(0)[0].selected).toBe(true);
           expect(element.find("option").eq(0).val()).toBe(unknownValue(prop));
-          expect(element.find("option").eq(1).prop("selected")).toBe(false);
+          expect(element.find("option").eq(1)[0].selected).toBe(false);
           expect(element.find("option").eq(1).val()).toBe(
             "string:UPDATEDVALUE",
           );
@@ -1769,8 +1769,8 @@ describe("select", () => {
           scope.selected = ["string", 1];
           scope.$digest();
 
-          expect(element.find("option").eq(0).prop("selected")).toBe(true);
-          expect(element.find("option").eq(2).prop("selected")).toBe(true);
+          expect(element.find("option").eq(0)[0].selected).toBe(true);
+          expect(element.find("option").eq(2)[0].selected).toBe(true);
 
           setSelectValue(element, 1);
           expect(scope.selected).toEqual([undefined]);
@@ -1781,7 +1781,7 @@ describe("select", () => {
 
           forEach(element.find("option"), (option) => {
             // browserTrigger can't produce click + ctrl, so set selection manually
-            jqLite(option).prop("selected", true);
+            jqLite(option)[0].selected = true;
           });
 
           browserTrigger(element, "change");
@@ -1982,7 +1982,7 @@ describe("select", () => {
           // jQuery returns null for val() when the option is disabled, see
           // https://bugs.jquery.com/ticket/13097
           expect(element[0].value).toBe(prop === "ngValue" ? "string:B" : "B");
-          expect(optionElements.eq(1).prop("selected")).toBe(true);
+          expect(optionElements.eq(1)[0].selected).toBe(true);
         });
 
         it("should ignore an option with $prop that becomes enabled and does not match the model", () => {
@@ -2169,8 +2169,8 @@ describe("select", () => {
             let optionElements = element.find("option");
             expect(optionElements.length).toEqual(3);
 
-            optionElements.eq(0).prop("selected", true);
-            optionElements.eq(2).prop("selected", true);
+            optionElements.eq(0)[0].selected = true;
+            optionElements.eq(2)[0].selected = true;
             browserTrigger(element);
 
             optionElements = element.find("option");
@@ -2233,8 +2233,8 @@ describe("select", () => {
             let optionElements = element.find("option");
             expect(optionElements.length).toEqual(3);
 
-            optionElements.eq(0).prop("selected", true);
-            optionElements.eq(2).prop("selected", true);
+            optionElements.eq(0)[0].selected = true;
+            optionElements.eq(2)[0].selected = true;
             browserTrigger(element, "change");
 
             optionElements = element.find("option");
@@ -2299,9 +2299,9 @@ describe("select", () => {
             let optionElements = element.find("option");
             expect(optionElements.length).toEqual(4);
 
-            optionElements.eq(0).prop("selected", true);
-            optionElements.eq(2).prop("selected", true);
-            optionElements.eq(3).prop("selected", true);
+            optionElements.eq(0)[0].selected = true;
+            optionElements.eq(2)[0].selected = true;
+            optionElements.eq(3)[0].selected = true;
             browserTrigger(element, "change");
 
             optionElements = element.find("option");
@@ -2369,9 +2369,9 @@ describe("select", () => {
 
             optionElements = element.find("option");
             expect(optionElements.length).toEqual(4);
-            expect(optionElements.eq(0).prop("selected")).toBe(true);
-            expect(optionElements.eq(2).prop("selected")).toBe(true);
-            expect(optionElements.eq(3).prop("selected")).toBe(true);
+            expect(optionElements.eq(0)[0].selected).toBe(true);
+            expect(optionElements.eq(2)[0].selected).toBe(true);
+            expect(optionElements.eq(3)[0].selected).toBe(true);
           });
 
           it("should select a newly added option with $prop when it matches the current model", () => {
@@ -2407,7 +2407,7 @@ describe("select", () => {
 
             let optionElements = element.find("option");
             expect(optionElements.length).toEqual(2);
-            expect(optionElements.eq(1).prop("selected")).toBe(true);
+            expect(optionElements.eq(1)[0].selected).toBe(true);
 
             scope.options.push(C);
             scope.$digest();

package/test/ng/http-backend.spec.js

@@ -1,6 +1,6 @@
 import { createInjector } from "../../src/injector";
 import { publishExternalAPI } from "../../src/public";
-import { createHttpBackend } from "../../src/services/httpBackend";
+import { createHttpBackend } from "../../src/services/http-backend";
 import sinon from "sinon";
 
 describe("$httpBackend", () => {