npm - @angular-wave/angular.ts - Versions diffs - 0.4.4 → 0.4.6 - Mend

@angular-wave/angular.ts 0.4.4 → 0.4.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (123) hide show

package/Makefile +1 -0
package/dist/angular-ts.esm.js +2 -2
package/dist/angular-ts.umd.js +2 -12
package/index.html +3 -74
package/package.json +1 -1
package/src/angular.spec.js +5 -0
package/src/animations/animate-css.js +13 -5
package/src/animations/animate-queue.js +21 -22
package/src/animations/animate-runner.js +8 -4
package/src/animations/animate.md +1 -1
package/src/animations/animate.spec.js +21 -0
package/src/animations/animation.js +1 -1
package/src/binding.spec.js +1 -0
package/src/core/compile/compile.js +25 -27
package/src/core/compile/compile.spec.js +266 -17
package/src/core/controller/controller.js +0 -2
package/src/core/di/injector.md +1 -1
package/src/core/di/injector.spec.js +2 -0
package/src/core/di/internal-injector.js +1 -2
package/src/core/interpolate/interpolate.js +12 -28
package/src/core/interpolate/interpolate.spec.js +16 -70
package/src/core/interval/interval-factory.js +50 -0
package/src/core/interval/interval.html +18 -0
package/src/core/interval/interval.js +77 -0
package/src/core/interval/interval.md +123 -0
package/src/core/interval/interval.spec.js +280 -0
package/src/core/interval/interval.test.js +1 -1
package/src/core/location/location.js +53 -59
package/src/core/location/location.spec.js +27 -27
package/src/core/on.spec.js +7 -0
package/src/core/parse/interpreter.js +7 -10
package/src/core/parse/parse.js +5 -26
package/src/core/parse/parse.spec.js +91 -95
package/src/core/prop.spec.js +60 -4
package/src/core/q/q.html +18 -0
package/src/core/q/q.js +472 -0
package/src/core/q/q.md +211 -0
package/src/core/q/q.spec.js +2748 -0
package/src/core/q/q.test.js +12 -0
package/src/core/sce/sce.spec.js +8 -0
package/src/core/{model/model.html → scope/scope.html} +1 -1
package/src/core/scope/scope.js +16 -15
package/src/core/scope/scope.spec.js +1959 -24
package/src/core/scope/scope.test.js +12 -0
package/src/core/timeout/timeout.html +18 -0
package/src/core/timeout/timeout.js +109 -0
package/src/core/timeout/timeout.spec.js +354 -0
package/src/core/timeout/timout.test.js +12 -0
package/src/core/url-utils/url-utils.spec.js +1 -1
package/src/directive/aria/aria.js +6 -3
package/src/directive/aria/aria.spec.js +87 -0
package/src/directive/attrs/attrs.spec.js +5 -0
package/src/directive/attrs/boolean.spec.js +15 -0
package/src/directive/attrs/element-style.spec.js +8 -0
package/src/directive/attrs/src.spec.js +7 -0
package/src/directive/bind/bind.spec.js +33 -0
package/src/directive/bind/bing-html.spec.js +3 -0
package/src/directive/class/class.js +3 -3
package/src/directive/class/class.spec.js +75 -9
package/src/directive/controller/controller.spec.js +13 -0
package/src/directive/events/click.spec.js +3 -0
package/src/directive/events/event.spec.js +6 -0
package/src/directive/events/events.html +1 -0
package/src/directive/form/form.js +3 -2
package/src/directive/form/form.spec.js +65 -0
package/src/directive/if/if.spec.js +4 -0
package/src/directive/include/include.spec.js +59 -8
package/src/directive/init/init.js +2 -6
package/src/directive/init/init.spec.js +2 -0
package/src/directive/input/input.spec.js +136 -0
package/src/directive/messages/messages.spec.js +35 -4
package/src/directive/model/model.js +25 -18
package/src/directive/model/model.spec.js +49 -2
package/src/directive/model-options/model-options.spec.js +6 -0
package/src/directive/non-bindable/non-bindable.spec.js +1 -0
package/src/directive/observe/observe.js +5 -1
package/src/directive/observe/observe.spec.js +22 -0
package/src/directive/observe/test.html +3 -11
package/src/directive/options/options.spec.js +34 -0
package/src/directive/ref/href.spec.js +15 -0
package/src/directive/repeat/repeat.spec.js +135 -8
package/src/directive/script/script.spec.js +2 -0
package/src/directive/select/select.js +3 -3
package/src/directive/select/select.spec.js +96 -0
package/src/directive/show-hide/show-hide.js +2 -2
package/src/directive/show-hide/show-hide.spec.js +19 -8
package/src/directive/style/style.spec.js +7 -0
package/src/directive/switch/switch.spec.js +5 -5
package/src/directive/validators/validators.spec.js +1 -0
package/src/loader.js +1 -0
package/src/public.js +10 -2
package/src/router/common/coreservices.js +2 -0
package/src/router/directives/state-directives.js +14 -6
package/src/router/directives/state-directives.spec.js +83 -0
package/src/router/directives/view-directive.js +13 -4
package/src/router/directives/view-directive.spec.js +71 -25
package/src/router/hooks/lazy-load.js +2 -2
package/src/router/hooks/views.js +5 -3
package/src/router/resolve/resolvable.js +6 -3
package/src/router/resolve/resolve-context.js +2 -2
package/src/router/state/state-service.js +4 -4
package/src/router/state/state.spec.js +5 -2
package/src/router/state/state.test.js +1 -1
package/src/router/state/views.js +10 -7
package/src/router/template-factory.js +6 -3
package/src/router/template-factory.spec.js +4 -0
package/src/router/transition/transition-hook.js +1 -1
package/src/router/transition/transition.js +1 -1
package/src/router/view-hook.spec.js +2 -2
package/src/router/view-scroll.js +6 -4
package/src/services/browser.js +5 -8
package/src/services/http/http.js +9 -6
package/src/services/http/http.spec.js +31 -30
package/src/services/http/template-request.spec.js +10 -0
package/src/services/http-backend/http-backend.spec.js +3 -3
package/src/services/template-request.js +4 -2
package/src/shared/common.js +2 -1
package/types/core/location/location.d.ts +37 -34
package/types/core/parse/parse.d.ts +0 -26
package/types/core/scope/scope.d.ts +11 -11
package/src/core/model/model.js +0 -944
package/src/core/model/model.spec.js +0 -3012
package/types/core/model/model.d.ts +0 -204

package/src/core/scope/scope.test.js ADDED Viewed

@@ -0,0 +1,12 @@
+import { test, expect } from "@playwright/test";
+const TEST_URL = "src/core/scope/scope.html";
+test("unit tests contain no errors", async ({ page }) => {
+  await page.goto(TEST_URL);
+  await page.content();
+  await page.waitForTimeout(100);
+  await expect(page.locator(".jasmine-overall-result")).toHaveText(
+    /0 failures/,
+  );
+});

package/src/core/timeout/timeout.html ADDED Viewed

@@ -0,0 +1,18 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>AngularTS Test Runner</title>
+    <link rel="shortcut icon" type="image/png" href="/images/favicon.ico" />
+    <link rel="stylesheet" href="/jasmine/jasmine-5.1.2/jasmine.css" />
+    <script src="/jasmine/jasmine-5.1.2/jasmine.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/jasmine-html.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/boot0.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/boot1.js"></script>
+    <script type="module" src="/src/core/timeout/timeout.spec.js"></script>
+  </head>
+  <body>
+    <div id="dummy"></div>
+  </body>
+</html>

package/src/core/timeout/timeout.js ADDED Viewed

@@ -0,0 +1,109 @@
+import { markQExceptionHandled } from "../q/q";
+import { isDefined, minErr, sliceArgs } from "../../shared/utils";
+const $timeoutMinErr = minErr("$timeout");
+export class TimeoutProvider {
+  $get = [
+    "$rootScope",
+    "$browser",
+    "$q",
+    "$exceptionHandler",
+    /**
+     *
+     * @param {import('../scope/scope').Scope} $rootScope
+     * @param {import('../../services/browser').Browser} $browser
+     * @param {*} $q
+     * @param {import('../exception-handler').ErrorHandler} $exceptionHandler
+     * @returns
+     */
+    ($rootScope, $browser, $q, $exceptionHandler) => {
+      const deferreds = {};
+      /**
+       * AngularJS's wrapper for `window.setTimeout`. The `fn` function is wrapped into a try/catch
+       * block and delegates any exceptions to
+       * {@link $exceptionHandler} service.
+       *
+       * The return value of calling `$timeout` is a promise, which will be resolved when
+       * the delay has passed and the timeout function, if provided, is executed.
+       *
+       * To cancel a timeout request, call `$timeout.cancel(promise)`.
+       *
+       * If you only want a promise that will be resolved after some specified delay
+       * then you can call `$timeout` without the `fn` function.
+       *
+       * @param {function()=} fn A function, whose execution should be delayed.
+       * @param {number=} [delay=0] Delay in milliseconds.
+       * @returns {import("../q/q").QPromise<any>} Promise that will be resolved when the timeout is reached. The promise
+       *   will be resolved with the return value of the `fn` function.
+       *
+       */
+      function timeout(fn, delay, invokeApply = true) {
+        const args = sliceArgs(arguments, 3);
+        const skipApply = isDefined(invokeApply) && !invokeApply;
+        const deferred = $q.defer();
+        const { promise } = deferred;
+        let timeoutId;
+        timeoutId = $browser.defer(
+          () => {
+            try {
+              deferred.resolve(fn.apply(null, args));
+            } catch (e) {
+              deferred.reject(e);
+              $exceptionHandler(e);
+            } finally {
+              delete deferreds[promise.$$timeoutId];
+            }
+            if (!skipApply) $rootScope.$apply();
+          },
+          delay,
+          "$timeout",
+        );
+        promise.$$timeoutId = timeoutId;
+        deferreds[timeoutId] = deferred;
+        return promise;
+      }
+      /**
+       * Cancels a task associated with the `promise`. As a result of this, the promise will be
+       * resolved with a rejection.
+       *
+       * @param {import("../q/q").QPromise<any>} promise Promise returned by the `$timeout` function.
+       * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
+       *   canceled.
+       */
+      timeout.cancel = function (promise) {
+        if (!promise) return false;
+        if (!Object.prototype.hasOwnProperty.call(promise, "$$timeoutId")) {
+          throw $timeoutMinErr(
+            "badprom",
+            "`$timeout.cancel()` called with a promise that was not generated by `$timeout()`.",
+          );
+        }
+        if (
+          !Object.prototype.hasOwnProperty.call(deferreds, promise.$$timeoutId)
+        )
+          return false;
+        const id = promise.$$timeoutId;
+        const deferred = deferreds[id];
+        // Timeout cancels should not report an unhandled promise.
+        markQExceptionHandled(deferred.promise);
+        deferred.reject("canceled");
+        delete deferreds[id];
+        return $browser.cancel(id);
+      };
+      return timeout;
+    },
+  ];
+}

package/src/core/timeout/timeout.spec.js ADDED Viewed

@@ -0,0 +1,354 @@
+import { Angular } from "../../loader";
+import { createInjector } from "../di/injector";
+import { wait } from "../../shared/test-utils";
+describe("$timeout", () => {
+  let injector;
+  let $interval;
+  let $rootScope;
+  let errors;
+  let $timeout;
+  let $browser;
+  let log;
+  beforeEach(() => {
+    errors = [];
+    log = [];
+    window.angular = new Angular();
+    window.angular
+      .module("myModule", ["ng"])
+      .decorator("$exceptionHandler", function () {
+        return (exception) => {
+          errors.push(exception);
+        };
+      });
+    injector = createInjector(["myModule"]);
+    $interval = injector.get("$interval");
+    $rootScope = injector.get("$rootScope");
+    $timeout = injector.get("$timeout");
+    $browser = injector.get("$browser");
+  });
+  it("should delegate functions to $browser.defer", (done) => {
+    let counter = 0;
+    $timeout(() => {
+      counter++;
+    });
+    expect(counter).toBe(0);
+    setTimeout(() => {
+      expect(counter).toBe(1);
+      done();
+    });
+  });
+  it("should call $apply after each callback is executed", (done) => {
+    const applySpy = spyOn($rootScope, "$apply").and.callThrough();
+    $timeout(() => {});
+    expect(applySpy).not.toHaveBeenCalled();
+    setTimeout(() => {
+      expect(applySpy).toHaveBeenCalled();
+      applySpy.calls.reset();
+    });
+    $timeout(() => {});
+    $timeout(() => {});
+    setTimeout(() => {
+      expect(applySpy).toHaveBeenCalledTimes(2);
+      done();
+    });
+  });
+  it("should NOT call $apply if skipApply is set to true", (done) => {
+    const applySpy = spyOn($rootScope, "$apply").and.callThrough();
+    $timeout(() => {}, 12, false);
+    expect(applySpy).not.toHaveBeenCalled();
+    setTimeout(() => {
+      expect(applySpy).not.toHaveBeenCalled();
+      done();
+    });
+  });
+  it("should NOT call $evalAsync or $digest if invokeApply is set to false", (done) => {
+    const evalAsyncSpy = spyOn($rootScope, "$evalAsync").and.callThrough();
+    const digestSpy = spyOn($rootScope, "$digest").and.callThrough();
+    const fulfilledSpy = jasmine.createSpy("fulfilled");
+    $timeout(fulfilledSpy, 1, false);
+    setTimeout(() => {
+      expect(fulfilledSpy).toHaveBeenCalled();
+      expect(evalAsyncSpy).not.toHaveBeenCalled();
+      expect(digestSpy).not.toHaveBeenCalled();
+      done();
+    }, 1);
+  });
+  it("should allow you to specify the delay time", () => {
+    const defer = spyOn($browser, "defer");
+    $timeout(() => {}, 123);
+    expect(defer).toHaveBeenCalledTimes(1);
+    expect(defer.calls.mostRecent().args[1]).toEqual(123);
+  });
+  it("should return a promise which will be resolved with return value of the timeout callback", (done) => {
+    const promise = $timeout(() => {
+      log.push("timeout");
+      return "buba";
+    });
+    promise.then(
+      (value) => {
+        log.push(`promise success: ${value}`);
+      },
+      () => log.push("promise error"),
+    );
+    expect(log).toEqual([]);
+    setTimeout(() => {
+      expect(log).toEqual(["timeout", "promise success: buba"]);
+      done();
+    });
+  });
+  it("should allow the `fn` parameter to be optional", (done) => {
+    $timeout().then(
+      (value) => {
+        log.push(`promise success: ${value}`);
+      },
+      () => log.push("promise error"),
+    );
+    expect(log).toEqual([]);
+    setTimeout(() => {
+      expect(log).toEqual(["promise success: undefined"]);
+      log = [];
+    });
+    $timeout(1).then(
+      (value) => {
+        log.push(`promise success: ${value}`);
+      },
+      () => log.push("promise error"),
+    );
+    expect(log).toEqual([]);
+    setTimeout(() => {
+      expect(log).toEqual(["promise success: undefined"]);
+      done();
+    }, 1);
+  });
+  describe("exception handling", () => {
+    it("should delegate exception to the $exceptionHandler service", async () => {
+      errors = [];
+      $timeout(() => {
+        errors = [];
+        throw "Test Error";
+      }, 1);
+      expect(errors).toEqual([]);
+      await wait(1);
+      expect(errors).toEqual([
+        "Test Error",
+        "Possibly unhandled rejection: Test Error",
+      ]);
+    });
+    it("should call $apply even if an exception is thrown in callback", async () => {
+      const applySpy = spyOn($rootScope, "$apply").and.callThrough();
+      $timeout(() => {
+        throw "Test $apply";
+      });
+      expect(applySpy).not.toHaveBeenCalled();
+      await wait(2);
+      expect(applySpy).toHaveBeenCalled();
+    });
+    it("should reject the timeout promise when an exception is thrown in the timeout callback", (done) => {
+      const promise = $timeout(() => {
+        throw "Some Error";
+      });
+      promise.then(
+        () => log.push("success"),
+        (reason) => {
+          log.push(`error: ${reason}`);
+        },
+      );
+      setTimeout(() => {
+        expect(log).toEqual(["error: Some Error"]);
+        done();
+      });
+    });
+    it("should pass the timeout arguments in the timeout callback even if an exception is thrown", (done) => {
+      const promise1 = $timeout(
+        (arg) => {
+          throw arg;
+        },
+        1,
+        true,
+        "Some Arguments",
+      );
+      const promise2 = $timeout(
+        (arg1, args2) => {
+          throw `${arg1} ${args2}`;
+        },
+        2,
+        false,
+        "Are Meant",
+        "To Be Thrown",
+      );
+      promise1.then(
+        () => log.push("success"),
+        (reason) => {
+          log.push(`error: ${reason}`);
+        },
+      );
+      promise2.then(
+        () => log.push("success"),
+        (reason) => {
+          log.push(`error: ${reason}`);
+        },
+      );
+      setTimeout(() => {
+        expect(log).toEqual([]);
+      });
+      setTimeout(() => {
+        expect(log).toEqual(["error: Some Arguments"]);
+      }, 1);
+      setTimeout(() => {
+        expect(log).toEqual([
+          "error: Some Arguments",
+          "error: Are Meant To Be Thrown",
+        ]);
+        done();
+      }, 15);
+    });
+    it("should forget references to relevant deferred even when exception is thrown", () => {
+      var promise = $timeout(
+        function () {
+          throw "Test Error";
+        },
+        0,
+        false,
+      );
+      const res = $timeout.cancel(promise);
+      expect(res).toBe(true);
+    });
+  });
+  describe("cancel", () => {
+    it("should cancel tasks", (done) => {
+      const task1 = jasmine.createSpy("task1");
+      const task2 = jasmine.createSpy("task2");
+      const task3 = jasmine.createSpy("task3");
+      const task4 = jasmine.createSpy("task4");
+      let promise1;
+      let promise3;
+      let promise4;
+      promise1 = $timeout(task1);
+      $timeout(task2);
+      promise3 = $timeout(task3, 333);
+      promise4 = $timeout(333);
+      promise3.then(task4, () => {});
+      $timeout.cancel(promise1);
+      $timeout.cancel(promise3);
+      $timeout.cancel(promise4);
+      setTimeout(() => {
+        expect(task1).not.toHaveBeenCalled();
+        expect(task2).toHaveBeenCalled();
+        expect(task3).not.toHaveBeenCalled();
+        expect(task4).not.toHaveBeenCalled();
+        done();
+      });
+    });
+    it("should cancel the promise", (done) => {
+      const promise = $timeout(() => {});
+      promise.then(
+        (value) => {
+          log.push(`promise success: ${value}`);
+        },
+        (err) => {
+          log.push(`promise error: ${err}`);
+        },
+        (note) => {
+          log.push(`promise update: ${note}`);
+        },
+      );
+      expect(log).toEqual([]);
+      $timeout.cancel(promise);
+      setTimeout(() => {
+        expect(log).toEqual(["promise error: canceled"]);
+        done();
+      });
+    });
+    it("should return true if a task was successfully canceled", (done) => {
+      const task1 = jasmine.createSpy("task1");
+      const task2 = jasmine.createSpy("task2");
+      let promise1;
+      let promise2;
+      promise1 = $timeout(task1);
+      setTimeout(() => {
+        promise2 = $timeout(task2);
+        expect($timeout.cancel(promise1)).toBe(false);
+        expect($timeout.cancel(promise2)).toBe(true);
+        done();
+      });
+    });
+    it("should not throw an error when given an undefined promise", () => {
+      expect($timeout.cancel()).toBe(false);
+    });
+    it("should throw an error when given a non-$timeout promise", () => {
+      const promise = $timeout(() => {}).then(() => {});
+      expect(() => {
+        $timeout.cancel(promise);
+      }).toThrowError(/badprom/);
+    });
+    it("should forget references to relevant deferred", () => {
+      // $browser.cancel is only called on cancel if the deferred object is still referenced
+      const cancelSpy = spyOn($browser, "cancel").and.callThrough();
+      const promise = $timeout(() => {}, 0, false);
+      expect(cancelSpy).not.toHaveBeenCalled();
+      $timeout.cancel(promise);
+      expect(cancelSpy).toHaveBeenCalled();
+      // Promise deferred object should already be removed from the list and not cancellable again
+      $timeout.cancel(promise);
+      expect(cancelSpy).toHaveBeenCalled();
+    });
+    it("should not trigger digest when cancelled", () => {
+      const watchSpy = jasmine.createSpy("watchSpy");
+      $rootScope.$watch(watchSpy);
+      const t = $timeout();
+      $timeout.cancel(t);
+      expect(watchSpy).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/core/timeout/timout.test.js ADDED Viewed

@@ -0,0 +1,12 @@
+import { test, expect } from "@playwright/test";
+const TEST_URL = "src/core/interval/interval.html";
+test("unit tests contain no errors", async ({ page }) => {
+  await page.goto(TEST_URL);
+  await page.content();
+  await page.waitForTimeout(100);
+  await expect(page.locator(".jasmine-overall-result")).toHaveText(
+    /0 failures/,
+  );
+});

package/src/core/url-utils/url-utils.spec.js CHANGED Viewed

@@ -65,7 +65,7 @@ describe("urlUtils", () => {
       expectIsSameOrigin("path", true);
-      const origin = urlResolve(document.location.href);
+      const origin = urlResolve(window.location.href);
       expectIsSameOrigin(`//${origin.host}/path`, true);
       // Different domain.

package/src/directive/aria/aria.js CHANGED Viewed

@@ -348,9 +348,12 @@ export function ngModelAriaDirective($aria) {
           }
           if (shouldAttachAttr("aria-invalid", "ariaInvalid", elem, true)) {
-            scope.$watch("ngModel.$invalid", (newVal) => {
-              elem.attr("aria-invalid", (!!newVal).toString());
-            });
+            scope.$watch(
+              () => ngModel.$invalid,
+              (newVal) => {
+                elem.attr("aria-invalid", (!!newVal).toString());
+              },
+            );
           }
         },
       };