@angular-wave/angular.ts 0.7.8 → 0.8.1

package/src/directive/http/post.spec.js

@@ -1,26 +1,521 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
+import { browserTrigger, wait } from "../../shared/test-utils.js";
 import { dealoc } from "../../shared/dom.js";
-// import { browserTrigger, wait } from "../../shared/test-utils.js";
 
-describe("ngPost", () => {
-  let $compile, $rootScope, $httpBackend, el;
+describe("ng-post", () => {
+  let $compile, $rootScope, $log, el;
 
   beforeEach(() => {
     el = document.getElementById("app");
     dealoc(el);
     el.innerHTML = "";
     let angular = new Angular();
-    angular.module("default", []);
+    angular.module("default", []).config([
+      "$stateProvider",
+      "$locationProvider",
+      ($stateProvider) => {
+        $stateProvider
+          .state({
+            name: "success",
+            url: "/success",
+            template: `success`,
+          })
+          .state({
+            name: "error",
+            url: "/error",
+            template: `error`,
+          });
+      },
+    ]);
     angular
       .bootstrap(el, ["default"])
-      .invoke((_$compile_, _$rootScope_, _$httpBackend_) => {
+      .invoke((_$compile_, _$rootScope_, _$log_) => {
         $compile = _$compile_;
         $rootScope = _$rootScope_;
-        $httpBackend = _$httpBackend_;
+        $log = _$log_;
       });
   });
 
-  it("should pass", () => {
-    expect(true).toBeTrue();
+  it("should replace innerHTML (default) on click", async () => {
+    const scope = $rootScope.$new();
+    el.innerHTML = '<button ng-post="/mock/hello">Load</button>';
+    $compile(el)(scope);
+    browserTrigger(el.querySelector("button"), "click");
+    await wait(100);
+    expect(el.innerText).toBe("Hello");
   });
+
+  it("should replace innerHTML (default) on click when used with expression", async () => {
+    const scope = $rootScope.$new();
+    el.innerHTML = '<button ng-post="/mock/{{a}}">Load</button>';
+    scope.a = "hello";
+    $compile(el)(scope);
+    browserTrigger(el.querySelector("button"), "click");
+    await wait(100);
+    expect(el.firstChild.innerHTML).toBe("<div>Hello</div>");
+  });
+
+  it("should attach parameters of a form and replace innerHTML (default) on click", async () => {
+    const scope = $rootScope.$new();
+    el.innerHTML =
+      '<form ng-post="/mock/posthtml"><input name="name" value="Bob" /><button type="submit">Load</button></form>';
+    $compile(el)(scope);
+    browserTrigger(el.querySelector("form"), "submit");
+    await wait(100);
+    expect(el.innerText).toBe("Bob");
+  });
+
+  it("should use json encoding by default", async () => {
+    const scope = $rootScope.$new();
+    el.innerHTML =
+      '<form ng-post="/mock/json"> {{ name }} <input name="name" value="Bob" /><button type="submit">Load</button></form>';
+    $compile(el)(scope);
+    browserTrigger(el.querySelector("form"), "submit");
+    await wait(100);
+    expect(el.innerText).toBe("Bob Load");
+  });
+
+  it("should use encoding in enctype", async () => {
+    const scope = $rootScope.$new();
+    el.innerHTML = `
+      <form ng-post="/mock/urlencoded" enctype="application/x-www-form-urlencoded">
+        <input type="text" name="name" value="Bob"/>
+        <button type="submit">Load</button>
+      </form>`;
+    $compile(el)(scope);
+    browserTrigger(el.querySelector("form"), "submit");
+    await wait(100);
+    expect(el.innerText).toBe("Form data: Bob");
+  });
+
+  // it("should attach parameters of a form and replace innerHTML (default) on click in case of error", async () => {
+  //   const scope = $rootScope.$new();
+  //   el.innerHTML =
+  //     '<form ng-post="/mock/posterror"><input name="name" value="Bob"></input><button type="submit">Load</button></form>';
+  //   $compile(el)(scope);
+  //   browserTrigger(el.querySelector("form"), "submit");
+  //   await wait(100);
+  //   expect(el.innerText).toBe("Error");
+  // });
+
+  // it("should replace innerHTML on error", async () => {
+  //   const scope = $rootScope.$new();
+  //   el.innerHTML = '<button ng-post="/mock/422">Load</button>';
+  //   $compile(el)(scope);
+  //   browserTrigger(el.querySelector("button"), "click");
+  //   await wait(100);
+  //   expect(el.innerText).toBe("Invalid data");
+  // });
+
+  // it("should not trigger request if element is disabled", async () => {
+  //   el.innerHTML = '<button ng-post="/mock/hello" disabled>Load</button>';
+  //   const scope = $rootScope.$new();
+  //   $compile(el)(scope);
+  //   browserTrigger(el.querySelector("button"), "click");
+  //   await wait(100);
+  //   expect(el.innerText).toBe("Load");
+  // });
+
+  // it("should replace innerHTML on status error without a body", async () => {
+  //   const scope = $rootScope.$new();
+  //   el.innerHTML = '<button ng-post="/mock/401">Load</button>';
+  //   $compile(el)(scope);
+  //   browserTrigger(el.querySelector("button"), "click");
+  //   await wait(100);
+  //   expect(el.innerText).toBe("Unauthorized");
+  // });
+
+  // describe("data-trigger", () => {
+  //   it("should not trigger request on click if element has trigger attribute", async () => {
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/hello" data-trigger="mouseover">Load</button>';
+  //     const scope = $rootScope.$new();
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     expect(el.innerText).toBe("Load");
+  //   });
+
+  //   it("should trigger request on new event name if element has trigger attribute", async () => {
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/hello" data-trigger="mouseover">Load</button>';
+  //     const scope = $rootScope.$new();
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "mouseover");
+  //     await wait(100);
+  //     expect(el.innerText).toBe("Hello");
+  //   });
+  // });
+
+  // describe("data-latch", () => {
+  //   it("should trigger request on latch change", async () => {
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/now" data-latch="{{ latch }}">Load</button>';
+  //     const scope = $rootScope.$new();
+  //     $compile(el)(scope);
+  //     await wait(100);
+  //     expect(el.innerText).toBe("Load");
+  //     scope.latch = true;
+  //     await wait(100);
+  //     expect(el.innerText).not.toBe("Load");
+  //     const firstRes = parseInt(el.innerText);
+  //     expect(firstRes).toBeLessThan(Date.now());
+
+  //     scope.latch = !scope.latch;
+  //     await wait(100);
+  //     const secondRes = parseInt(el.innerText);
+  //     expect(secondRes).toBeGreaterThan(firstRes);
+
+  //     scope.latch = !scope.latch;
+  //     await wait(100);
+  //     const thirdRes = parseInt(el.innerText);
+  //     expect(thirdRes).toBeGreaterThan(secondRes);
+  //   });
+
+  //   it("should still work with events with latch change", async () => {
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/now" data-latch="{{ latch }}">Load</button>';
+  //     const scope = $rootScope.$new();
+  //     $compile(el)(scope);
+  //     await wait(100);
+  //     expect(el.innerText).toBe("Load");
+  //     scope.latch = true;
+  //     await wait(100);
+  //     expect(el.innerText).not.toBe("Load");
+  //     const firstRes = parseInt(el.innerText);
+  //     expect(firstRes).toBeLessThan(Date.now());
+
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     const secondRes = parseInt(el.innerText);
+  //     expect(secondRes).toBeGreaterThan(firstRes);
+  //   });
+
+  //   it("should still work with custom events with latch change", async () => {
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/now" data-latch="{{ latch }}" data-trigger="mouseover">Load</button>';
+  //     const scope = $rootScope.$new();
+  //     $compile(el)(scope);
+  //     await wait(100);
+  //     expect(el.innerText).toBe("Load");
+  //     scope.latch = true;
+  //     await wait(100);
+  //     expect(el.innerText).not.toBe("Load");
+  //     const firstRes = parseInt(el.innerText);
+  //     expect(firstRes).toBeLessThan(Date.now());
+
+  //     browserTrigger(el.querySelector("button"), "mouseover");
+  //     await wait(100);
+  //     const secondRes = parseInt(el.innerText);
+  //     expect(secondRes).toBeGreaterThan(firstRes);
+  //   });
+
+  //   it("should still work with ng-event directives with latch change", async () => {
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/now" data-latch="{{ latch }}" ng-mouseover="latch = !latch">Load</button>';
+  //     const scope = $rootScope.$new();
+  //     $compile(el)(scope);
+  //     await wait(100);
+  //     expect(el.innerText).toBe("Load");
+  //     browserTrigger(el.querySelector("button"), "mouseover");
+  //     await wait(100);
+  //     expect(el.innerText).not.toBe("Load");
+  //     const firstRes = parseInt(el.innerText);
+  //     expect(firstRes).toBeLessThan(Date.now());
+
+  //     browserTrigger(el.querySelector("button"), "mouseover");
+  //     await wait(100);
+  //     const secondRes = parseInt(el.innerText);
+  //     expect(secondRes).toBeGreaterThan(firstRes);
+  //   });
+  // });
+
+  // describe("data-swap", () => {
+  //   it("should not change anything if swap is 'none'", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/div" data-swap="none" data-target="#found">Load</button><div id="found">Original</div>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     const found = el.querySelector("#found");
+  //     expect(found.textContent).toBe("Original");
+  //   });
+
+  //   it("should replace outerHTML on click", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/hello" data-swap="outerHTML">Load</button>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     expect(el.innerText).toBe("Hello");
+  //   });
+
+  //   it("should replace textcontent on click", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/hello" data-swap="textContent">Load</button>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     expect(el.innerText).toBe("Hello");
+  //   });
+
+  //   it("should replace beforebegin on click", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/div" data-swap="beforebegin">Load</button>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     expect(el.firstChild.innerText).toBe("Hello");
+  //   });
+
+  //   it("should replace beforeend on click", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/div" data-swap="beforeend">Load</button>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     expect(el.firstChild.lastChild.innerText).toBe("Hello");
+  //   });
+
+  //   it("should delete the target on click", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/hello" data-swap="delete" data-target="#found">Load</button><div id="found"></div>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     expect(el.querySelector("#found")).toBeNull();
+  //   });
+  // });
+
+  // describe("data-target", () => {
+  //   it("should remain unchanged if target is not found and log a warning", async () => {
+  //     const scope = $rootScope.$new();
+  //     spyOn($log, "warn");
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/hello" data-target="#missing">Load</button>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     expect(el.firstChild.innerText).toBe("Load");
+  //     expect($log.warn).toHaveBeenCalled();
+  //   });
+
+  //   it("should replace target innerHTML (default) on click", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/hello" data-target="#found">Load</button><div id="found"></div>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     expect(el.lastChild.innerHTML).toBe("Hello");
+  //   });
+
+  //   it("should replace textcontent on click", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/hello" data-swap="textContent" data-target="#found">Load</button><div id="found"></div>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     expect(el.lastChild.innerText).toBe("Hello");
+  //   });
+
+  //   it("should replace beforebegin on click", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/div" data-swap="beforebegin" data-target="#found">Load</button><div id="found"></div>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     const found = el.querySelector("#found");
+  //     // The sibling before #found should contain "Hello"
+  //     const prevSibling = found.previousSibling;
+  //     expect(prevSibling.textContent).toBe("Hello");
+  //     expect(found.textContent).toBe(""); // found itself unchanged
+  //   });
+
+  //   it("should replace beforeend on click", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/div" data-swap="beforeend" data-target="#found">Load</button><div id="found"></div>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     const found = el.querySelector("#found");
+  //     expect(found.textContent).toBe("Hello");
+  //   });
+
+  //   it("should insert afterbegin on click", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/div" data-swap="afterbegin" data-target="#found">Load</button><div id="found"><div>World</div></div>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     const found = el.querySelector("#found");
+  //     expect(found.textContent).toBe("HelloWorld");
+  //   });
+
+  //   it("should insert afterend on click", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/div" data-swap="afterend" data-target="#found">Load</button><div id="found"><div>World</div></div>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     const found = el.querySelector("#found");
+  //     const next = found.nextSibling;
+  //     expect(el.lastChild.textContent).toBe("Hello");
+  //   });
+  // });
+
+  // describe("data-delay", () => {
+  //   it("should accept delay as a data attribute", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/hello" data-delay="1000">Load</button>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     expect(el.innerText).toBe("Load");
+
+  //     await wait(1000);
+  //     expect(el.innerText).toBe("Hello");
+  //   });
+  // });
+
+  // describe("data-throttle", () => {
+  //   it("should accept throttle as a data attribute", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/now" data-throttle="1000">Load</button>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     const firstRes = parseInt(el.innerText);
+  //     expect(firstRes).toBeLessThan(Date.now());
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     const secondRes = parseInt(el.innerText);
+  //     expect(secondRes).toBe(firstRes);
+
+  //     await wait(900);
+  //     // should release the throttle
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(100);
+  //     const thirdRes = parseInt(el.innerText);
+  //     expect(thirdRes).toBeGreaterThan(firstRes);
+  //   });
+  // });
+
+  // describe("data-interval", () => {
+  //   it("should accept delay as a data attribute and should stop on $destroy", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/now" data-interval="100">Load</button>';
+  //     $compile(el)(scope);
+
+  //     await wait(200);
+  //     await wait(200);
+  //     const firstRes = parseInt(el.innerText);
+  //     expect(firstRes).toBeLessThan(Date.now());
+  //     await wait(200);
+  //     await wait(200);
+  //     const secondRes = parseInt(el.innerText);
+  //     expect(secondRes).toBeGreaterThan(firstRes);
+  //     await wait(200);
+  //     await wait(200);
+  //     const thirdRes = parseInt(el.innerText);
+  //     expect(thirdRes).toBeGreaterThan(secondRes);
+
+  //     scope.$broadcast("$destroy");
+
+  //     await wait(200);
+  //     await wait(200);
+  //     const finalRes = parseInt(el.innerText);
+
+  //     await wait(1000);
+  //     await wait(200);
+  //     expect(parseInt(el.innerText)).toEqual(finalRes);
+  //   });
+  // });
+
+  // describe("data-loading", () => {
+  //   it("should update loading data attribute", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML = '<button ng-post="/mock/now" data-loading>Load</button>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     expect(el.querySelector("button").dataset.loading).toEqual("true");
+  //     await wait(200);
+  //     expect(el.querySelector("button").dataset.loading).toEqual("false");
+  //   });
+  // });
+
+  // describe("data-loading-class", () => {
+  //   it("should update class from data-loading-class attribute", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/now" data-loading-class="red">Load</button>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     expect(el.querySelector("button").classList.contains("red")).toBeTrue();
+  //     await wait(200);
+  //     expect(el.querySelector("button").classList.contains("red")).toBeFalse();
+  //   });
+  // });
+
+  // describe("data-success", () => {
+  //   it("should evaluate expression passing result", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/hello" data-success="res = $res">Load</button>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(200);
+  //     expect(scope.res).toEqual("Hello");
+  //   });
+  // });
+
+  // describe("data-state-success", () => {
+  //   it("should call stateService with success state", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/hello" data-state-success="success">Load</button><ng-view id="view"></ng-view>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(200);
+  //     expect(document.getElementById("view").innerHTML).toEqual("success");
+  //   });
+  // });
+
+  // describe("data-state-error", () => {
+  //   it("should call stateService with success state", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/422" data-state-success="success" data-state-error="error">Load</button><ng-view id="view"></ng-view>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(200);
+  //     expect(document.getElementById("view").innerHTML).toEqual("error");
+  //   });
+  // });
+
+  // describe("data-error", () => {
+  //   it("should evaluate expression passing result", async () => {
+  //     const scope = $rootScope.$new();
+  //     el.innerHTML =
+  //       '<button ng-post="/mock/422" data-error="res = $res">Load</button>';
+  //     $compile(el)(scope);
+  //     browserTrigger(el.querySelector("button"), "click");
+  //     await wait(200);
+  //     expect(scope.res).toEqual("Invalid data");
+  //   });
+  // });
 });

package/src/directive/http/put.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { dealoc } from "../../shared/dom.js";
 // import { browserTrigger, wait } from "../../shared/test-utils.js";
 

package/src/directive/if/if.spec.js

@@ -4,7 +4,7 @@ import {
   getCacheData,
   setCacheData,
 } from "../../shared/dom.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { wait } from "../../shared/test-utils.js";
 
 describe("ngIf", () => {

package/src/directive/include/include.spec.js

@@ -1,5 +1,5 @@
 import { createElementFromHTML, dealoc, getScope } from "../../shared/dom.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createInjector } from "../../core/di/injector.js";
 import { wait } from "../../shared/test-utils.js";
 

package/src/directive/init/init.spec.js

@@ -1,5 +1,5 @@
 import { createElementFromHTML, dealoc } from "../../shared/dom.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createInjector } from "../../core/di/injector.js";
 import { wait } from "../../shared/test-utils.js";
 

package/src/directive/init/init.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/directive/init/init.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/directive/input/input.js

@@ -1,19 +1,19 @@
 import {
+  addDateMinutes,
+  convertTimezoneToLocal,
+  equals,
+  isDate,
   isDefined,
-  isUndefined,
-  isString,
-  lowercase,
-  trim,
-  isObject,
   isNumber,
   isNumberNaN,
-  isDate,
-  convertTimezoneToLocal,
-  addDateMinutes,
-  timezoneToOffset,
-  nextUid,
-  equals,
+  isObject,
   isProxy,
+  isString,
+  isUndefined,
+  lowercase,
+  nextUid,
+  timezoneToOffset,
+  trim,
 } from "../../shared/utils.js";
 import { ngModelMinErr } from "./../model/model";
 
@@ -502,9 +502,8 @@ export function createDateInputType(type, regexp, parseDate) {
 }
 
 export function badInputChecker(scope, element, attr, ctrl, parserName) {
-  const node = element;
   const nativeValidation = (ctrl.$$hasNativeValidators = isObject(
-    node.validity,
+    element.validity,
   ));
 
   if (nativeValidation) {
@@ -1051,12 +1050,11 @@ export function ngValueDirective() {
     // TODO REMOVE IS SUPPORT
     // Support: IE9 only
     // In IE9 values are converted to string (e.g. `input.value = null` results in `input.value === 'null'`).
-    const propValue = isDefined(value)
+    element["value"] = isDefined(value)
       ? isProxy(value)
         ? value.$target
         : value
       : null;
-    element["value"] = propValue;
     attr.$set("value", value);
   }
 

package/src/directive/input/input.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import {
   createElementFromHTML as $,
   dealoc,
@@ -391,7 +391,6 @@ describe("input", () => {
             '<form name="form"><input type="month" ng-model="value" name="alias" min="{{ minVal }}" /></form>',
           )(scope);
           await wait();
-          return;
         });
 
         it("should invalidate", () => {

package/src/directive/input/input.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/directive/input/input.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/,
   );