@angular-wave/angular.ts 0.0.68 → 0.0.69

package/package.json

@@ -2,7 +2,7 @@
   "name": "@angular-wave/angular.ts",
   "description": "A modern, optimized and typesafe version of AngularJS",
   "license": "MIT",
-  "version": "0.0.68",
+  "version": "0.0.69",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

package/src/animations/animate-swap.js

@@ -20,7 +20,7 @@ export function ngAnimateSwapDirective($animate) {
           previousScope.$destroy();
           previousScope = null;
         }
-        if (value || value === 0) {
+        if (value) {
           $transclude((clone, childScope) => {
             previousElement = clone;
             previousScope = childScope;

package/src/core/animate/animate.js

@@ -136,13 +136,13 @@ export function CoreAnimateQueueProvider() {
 
       function handleCSSClassChanges() {
         forEach(postDigestElements, function (element) {
-          var data = postDigestQueue.get(element);
+          const data = postDigestQueue.get(element);
           if (data) {
-            var existing = splitClasses(element.attr("class"));
-            var toAdd = "";
-            var toRemove = "";
+            const existing = splitClasses(element.attr("class"));
+            let toAdd = "";
+            let toRemove = "";
             forEach(data, function (status, className) {
-              var hasClass = !!existing[className];
+              const hasClass = !!existing[className];
               if (status !== hasClass) {
                 if (status) {
                   toAdd += (toAdd.length ? " " : "") + className;

package/src/core/compile/compile.spec.js

@@ -9,8 +9,8 @@ import {
   getNodeName,
   extend,
 } from "../../shared/utils";
-import { countChildScopes, countWatchers } from "../../core/scope/scope";
-import { CACHE, EXPANDO } from "../../core/cache/cache";
+import { countChildScopes, countWatchers } from "../scope/scope";
+import { CACHE, EXPANDO } from "../cache/cache";
 import { wait } from "../../shared/test-utils";
 
 function isUnknownElement(el) {

package/src/core/controller/controller.js

@@ -198,7 +198,11 @@ export function $ControllerProvider() {
           );
         }
 
-        instance = $injector.instantiate(expression, locals, constructor);
+        instance = $injector.instantiate(
+          /** @type {Function} */ (expression),
+          locals,
+          constructor,
+        );
 
         if (identifier) {
           addIdentifier(

package/src/core/cookie-reader.spec.js

@@ -28,7 +28,7 @@ describe("$$cookieReader", () => {
       expect(document.cookie).toEqual("");
 
       window.angular = new Angular();
-      var injector = createInjector(["ng"]);
+      const injector = createInjector(["ng"]);
       $$cookieReader = injector.get("$$cookieReader");
     });
 

package/src/core/di/injector.js

@@ -247,7 +247,7 @@ function extractArgs(fn) {
  * @returns {Array<string>}
  */
 export function annotate(fn, strictDi, name) {
-  var $inject, argDecl, last;
+  let $inject, argDecl, last;
 
   if (typeof fn === "function") {
     if (!($inject = fn.$inject)) {

package/src/core/di/injector.spec.js

@@ -1164,42 +1164,42 @@ describe("factories", () => {
   beforeEach(() => (window.angular = new Angular()));
 
   it("allows registering a factory", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.factory("a", function () {
       return 42;
     });
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(injector.get("a")).toBe(42);
   });
 
   it("injects a factory function with instances", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.factory("a", function () {
       return 1;
     });
     module.factory("b", function (a) {
       return a + 2;
     });
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(injector.get("b")).toBe(3);
   });
 
   it("only calls a factory function once", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.factory("a", function () {
       return {};
     });
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(injector.get("a")).toBe(injector.get("a"));
   });
 
   it("forces a factory to return a value", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.factory("a", function () {});
     module.factory("b", function () {
       return null;
     });
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(function () {
       injector.get("a");
     }).toThrow();
@@ -1224,14 +1224,14 @@ describe("values", () => {
   beforeEach(() => (window.angular = new Angular()));
 
   it("allows registering a value", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.value("a", 42);
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(injector.get("a")).toBe(42);
   });
 
   it("does not make values available to config blocks", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.value("a", 42);
     module.config(function (a) {});
     expect(function () {
@@ -1240,9 +1240,9 @@ describe("values", () => {
   });
 
   it("allows an undefined value", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.value("a", undefined);
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(injector.get("a")).toBeUndefined();
   });
 });
@@ -1251,30 +1251,30 @@ describe("services", () => {
   beforeEach(() => (window.angular = new Angular()));
 
   it("allows registering a service", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.service("aService", function MyService() {
       this.getValue = function () {
         return 42;
       };
     });
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(injector.get("aService").getValue()).toBe(42);
   });
 
   it("injects service constructors with instances", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.value("theValue", 42);
     module.service("aService", function MyService(theValue) {
       this.getValue = function () {
         return theValue;
       };
     });
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(injector.get("aService").getValue()).toBe(42);
   });
 
   it("injects service ES6 constructors with instances", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.value("theValue", 42);
     module.service(
       "aService",
@@ -1287,14 +1287,14 @@ describe("services", () => {
         }
       },
     );
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(injector.get("aService").getValue()).toBe(42);
   });
 
   it("only instantiates services once", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.service("aService", function MyService() {});
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(injector.get("aService")).toBe(injector.get("aService"));
   });
 });
@@ -1303,7 +1303,7 @@ describe("decorators", () => {
   beforeEach(() => (window.angular = new Angular()));
 
   it("allows changing an instance using a decorator", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.factory("aValue", function () {
       return { aKey: 42 };
     });
@@ -1311,14 +1311,14 @@ describe("decorators", () => {
       $delegate.decoratedKey = 43;
       return $delegate;
     });
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
 
     expect(injector.get("aValue").aKey).toBe(42);
     expect(injector.get("aValue").decoratedKey).toBe(43);
   });
 
   it("allows multiple decorators per service", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.factory("aValue", function () {
       return {};
     });
@@ -1330,13 +1330,13 @@ describe("decorators", () => {
       $delegate.otherDecoratedKey = 43;
       return $delegate;
     });
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(injector.get("aValue").decoratedKey).toBe(42);
     expect(injector.get("aValue").otherDecoratedKey).toBe(43);
   });
 
   it("uses dependency injection with decorators", function () {
-    var module = angular.module("myModule", []);
+    const module = angular.module("myModule", []);
     module.factory("aValue", function () {
       return {};
     });
@@ -1345,7 +1345,7 @@ describe("decorators", () => {
       $delegate.decoratedKey = a;
       return $delegate;
     });
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     expect(injector.get("aValue").decoratedKey).toBe(42);
   });
 });
@@ -2180,7 +2180,7 @@ describe("service instantiation", () => {
     "should instantiate object and preserve constructor property and be instanceof " +
       "with the array annotated type",
     () => {
-      var t = $injector.instantiate(["book", "author", Type]);
+      const t = $injector.instantiate(["book", "author", Type]);
       expect(t.book).toEqual("moby");
       expect(t.author).toEqual("melville");
       expect(t.title()).toEqual("melville: moby");
@@ -2189,8 +2189,8 @@ describe("service instantiation", () => {
   );
 
   it("should allow constructor to return different object", () => {
-    var obj = {};
-    var Class = function () {
+    const obj = {};
+    const Class = function () {
       return obj;
     };
 
@@ -2198,8 +2198,8 @@ describe("service instantiation", () => {
   });
 
   it("should allow constructor to return a function", () => {
-    var fn = function () {};
-    var Class = function () {
+    const fn = function () {};
+    const Class = function () {
       return fn;
     };
 
@@ -2215,15 +2215,15 @@ describe("service instantiation", () => {
   });
 
   it("should return instance if constructor returns non-object value", () => {
-    var A = function () {
+    const A = function () {
       return 10;
     };
 
-    var B = function () {
+    const B = function () {
       return "some-string";
     };
 
-    var C = function () {
+    const C = function () {
       return undefined;
     };
 

package/src/core/di/internal-injector.js

@@ -253,7 +253,7 @@ function isClass(func) {
  * @returns {Array<string>}
  */
 function annotate(fn, strictDi, name) {
-  var $inject, argDecl, last;
+  let $inject, argDecl, last;
 
   if (typeof fn === "function") {
     if (!($inject = fn.$inject)) {

package/src/core/filter/filter.spec.js

@@ -1,29 +1,29 @@
 import { Angular } from "../../loader";
-import { createInjector } from "../../core/di/injector";
+import { createInjector } from "../di/injector";
 
 describe("filter", function () {
   beforeEach(() => {
     window.angular = new Angular();
   });
   it("can be registered and obtained", () => {
-    var myFilter = () => {};
-    var myFilterFactory = () => {
+    const myFilter = () => {};
+    const myFilterFactory = () => {
       return myFilter;
     };
-    var injector = createInjector([
+    const injector = createInjector([
       "ng",
       function ($filterProvider) {
         $filterProvider.register("my", myFilterFactory);
       },
     ]);
-    var $filter = injector.get("$filter");
+    const $filter = injector.get("$filter");
     expect($filter("my")).toBe(myFilter);
   });
 
   it("allows registering multiple filters with an object", () => {
-    var myFilter = () => {};
-    var myOtherFilter = () => {};
-    var injector = createInjector([
+    const myFilter = () => {};
+    const myOtherFilter = () => {};
+    const injector = createInjector([
       "ng",
       function ($filterProvider) {
         $filterProvider.register({
@@ -36,14 +36,14 @@ describe("filter", function () {
         });
       },
     ]);
-    var $filter = injector.get("$filter");
+    const $filter = injector.get("$filter");
     expect($filter("my")).toBe(myFilter);
     expect($filter("myOther")).toBe(myOtherFilter);
   });
 
   it("is available through injector", () => {
-    var myFilter = () => {};
-    var injector = createInjector([
+    const myFilter = () => {};
+    const injector = createInjector([
       "ng",
       function ($filterProvider) {
         $filterProvider.register("my", () => {
@@ -56,7 +56,7 @@ describe("filter", function () {
   });
 
   it("may have dependencies in factory", () => {
-    var injector = createInjector([
+    const injector = createInjector([
       "ng",
       function ($provide, $filterProvider) {
         $provide.constant("suffix", "!");
@@ -71,11 +71,11 @@ describe("filter", function () {
   });
 
   it("can be registered through module API", () => {
-    var myFilter = () => {};
+    const myFilter = () => {};
     angular.module("myModule", []).filter("my", () => {
       return myFilter;
     });
-    var injector = createInjector(["ng", "myModule"]);
+    const injector = createInjector(["ng", "myModule"]);
     expect(injector.has("myFilter")).toBe(true);
     expect(injector.get("myFilter")).toBe(myFilter);
   });
@@ -86,7 +86,7 @@ describe("filter filter", function () {
     window.angular = new Angular();
   });
   it("is available", function () {
-    var injector = createInjector(["ng"]);
+    const injector = createInjector(["ng"]);
     expect(injector.has("filterFilter")).toBe(true);
   });
   // TODO

package/src/core/interpolate/interpolate.spec.js

@@ -1,4 +1,4 @@
-import { createInjector } from "../../core/di/injector";
+import { createInjector } from "../di/injector";
 import { Angular } from "../../loader";
 
 describe("$interpolate", () => {
@@ -13,70 +13,70 @@ describe("$interpolate", () => {
   });
 
   it("produces an identity function for static content", function () {
-    var interp = $interpolate("hello");
+    const interp = $interpolate("hello");
     expect(interp instanceof Function).toBe(true);
     expect(interp()).toEqual("hello");
   });
 
   it("evaluates a single expression", function () {
-    var interp = $interpolate("{{anAttr}}");
+    const interp = $interpolate("{{anAttr}}");
     expect(interp({ anAttr: "42" })).toEqual("42");
   });
 
   it("passes through ill-defined interpolations", function () {
-    var interp = $interpolate("why u no }}work{{");
+    const interp = $interpolate("why u no }}work{{");
     expect(interp({})).toEqual("why u no }}work{{");
   });
 
   it("evaluates many expressions", function () {
-    var interp = $interpolate("First {{anAttr}}, then {{anotherAttr}}!");
+    const interp = $interpolate("First {{anAttr}}, then {{anotherAttr}}!");
     expect(interp({ anAttr: "42", anotherAttr: "43" })).toEqual(
       "First 42, then 43!",
     );
   });
 
   it("turns nulls into empty strings", function () {
-    var interp = $interpolate("{{aNull}}");
+    const interp = $interpolate("{{aNull}}");
     expect(interp({ aNull: null })).toEqual("");
   });
 
   it("turns undefineds into empty strings", function () {
-    var interp = $interpolate("{{anUndefined}}");
+    const interp = $interpolate("{{anUndefined}}");
     expect(interp({})).toEqual("");
   });
 
   it("turns numbers into strings", function () {
-    var interp = $interpolate("{{aNumber}}");
+    const interp = $interpolate("{{aNumber}}");
     expect(interp({ aNumber: 42 })).toEqual("42");
   });
 
   it("turns booleans into strings", function () {
-    var interp = $interpolate("{{aBoolean}}");
+    const interp = $interpolate("{{aBoolean}}");
     expect(interp({ aBoolean: true })).toEqual("true");
   });
 
   it("turns arrays into JSON strings", function () {
-    var interp = $interpolate("{{anArray}}");
+    const interp = $interpolate("{{anArray}}");
     expect(interp({ anArray: [1, 2, [3]] })).toEqual("[1,2,[3]]");
   });
 
   it("turns objects into JSON strings", function () {
-    var interp = $interpolate("{{anObject}}");
+    const interp = $interpolate("{{anObject}}");
     expect(interp({ anObject: { a: 1, b: "2" } })).toEqual('{"a":1,"b":"2"}');
   });
 
   it("unescapes escaped sequences", function () {
-    var interp = $interpolate("\\{\\{expr\\}\\} {{expr}} \\{\\{expr\\}\\}");
+    const interp = $interpolate("\\{\\{expr\\}\\} {{expr}} \\{\\{expr\\}\\}");
     expect(interp({ expr: "value" })).toEqual("{{expr}} value {{expr}}");
   });
 
   it("does not return function when flagged and no expressions", function () {
-    var interp = $interpolate("static content only", true);
+    const interp = $interpolate("static content only", true);
     expect(interp).toBeFalsy();
   });
 
   it("returns function when flagged and has expressions", function () {
-    var interp = $interpolate("has an {{expr}}", true);
+    const interp = $interpolate("has an {{expr}}", true);
     expect(interp).not.toBeFalsy();
   });
 
@@ -253,20 +253,20 @@ describe("$interpolate", () => {
 
   describe("interpolation escaping", () => {
     let obj;
-    var $compile;
+    let $compile;
     beforeEach(() => {
       obj = { foo: "Hello", bar: "World" };
       $compile = $injector.get("$compile");
     });
 
     it("uses a watch delegate", function () {
-      var interp = $interpolate("has an {{expr}}");
+      const interp = $interpolate("has an {{expr}}");
       expect(interp.$$watchDelegate).toBeDefined();
     });
 
     it("correctly returns new and old value when watched", function () {
-      var interp = $interpolate("{{expr}}");
-      var listenerSpy = jasmine.createSpy();
+      const interp = $interpolate("{{expr}}");
+      const listenerSpy = jasmine.createSpy();
       $rootScope.$watch(interp, listenerSpy);
       $rootScope.expr = 42;
       $rootScope.$apply();
@@ -341,50 +341,50 @@ describe("$interpolate", () => {
     });
 
     it("allows configuring start and end symbols", function () {
-      var injector = createInjector([
+      const injector = createInjector([
         "ng",
         function ($interpolateProvider) {
           $interpolateProvider.startSymbol("FOO").endSymbol("OOF");
         },
       ]);
-      var $interpolate = injector.get("$interpolate");
+      const $interpolate = injector.get("$interpolate");
       expect($interpolate.startSymbol()).toEqual("FOO");
       expect($interpolate.endSymbol()).toEqual("OOF");
     });
 
     it("works with start and end symbols that differ from default", function () {
-      var injector = createInjector([
+      const injector = createInjector([
         "ng",
         function ($interpolateProvider) {
           $interpolateProvider.startSymbol("FOO").endSymbol("OOF");
         },
       ]);
-      var $interpolate = injector.get("$interpolate");
-      var interpFn = $interpolate("FOOmyExprOOF");
+      const $interpolate = injector.get("$interpolate");
+      const interpFn = $interpolate("FOOmyExprOOF");
       expect(interpFn({ myExpr: 42 })).toEqual("42");
     });
 
     it("does not work with default symbols when reconfigured", function () {
-      var injector = createInjector([
+      const injector = createInjector([
         "ng",
         function ($interpolateProvider) {
           $interpolateProvider.startSymbol("FOO").endSymbol("OOF");
         },
       ]);
-      var $interpolate = injector.get("$interpolate");
-      var interpFn = $interpolate("{{myExpr}}");
+      const $interpolate = injector.get("$interpolate");
+      const interpFn = $interpolate("{{myExpr}}");
       expect(interpFn({ myExpr: 42 })).toEqual("{{myExpr}}");
     });
 
     it("supports unescaping for reconfigured symbols", function () {
-      var injector = createInjector([
+      const injector = createInjector([
         "ng",
         function ($interpolateProvider) {
           $interpolateProvider.startSymbol("FOO").endSymbol("OOF");
         },
       ]);
-      var $interpolate = injector.get("$interpolate");
-      var interpFn = $interpolate("\\F\\O\\OmyExpr\\O\\O\\F");
+      const $interpolate = injector.get("$interpolate");
+      const interpFn = $interpolate("\\F\\O\\OmyExpr\\O\\O\\F");
       expect(interpFn({})).toEqual("FOOmyExprOOF");
     });
 

package/src/core/interval/interval.spec.js

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

package/src/core/location/location.spec.js

@@ -4,7 +4,7 @@ import {
   $LocationProvider,
 } from "./location";
 import { Angular } from "../../loader";
-import { createInjector } from "../../core/di/injector";
+import { createInjector } from "../di/injector";
 
 describe("$location", () => {
   let module;

package/src/core/parser/lexer.spec.js

@@ -1,6 +1,6 @@
 import { Lexer } from "./lexer";
 import { Angular } from "../../loader";
-import { createInjector } from "../../core/di/injector";
+import { createInjector } from "../di/injector";
 
 describe("lexer", () => {
   let $rootScope;

package/src/core/parser/parse.spec.js

@@ -7,7 +7,7 @@ import {
   valueFn,
   extend,
 } from "../../shared/utils";
-import { createInjector } from "../../core/di/injector";
+import { createInjector } from "../di/injector";
 import { ASTType } from "./ast-type";
 import { Angular } from "../../loader";
 

package/src/core/q/q.js

@@ -27,6 +27,7 @@ import {
  * @property {function(((reason: any) => (QPromise<never>|QPromise<T>|T))|null): QPromise<T>|T} catch - Shorthand for promise.then(null, errorCallback).
  * @property {function(function(): void): QPromise<T>} finally - Allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value.
  * @property {number} [$$intervalId] - Internal id set by the $interval service for callback notifications
+ * @property {number} [$$timeoutId] - Timeout id set by the $timeout service for cancelations
  */
 
 /**

package/src/core/q/q.spec.js

@@ -1,4 +1,4 @@
-import { createInjector } from "../../core/di/injector";
+import { createInjector } from "../di/injector";
 import { Angular } from "../../loader";
 
 /**

package/src/core/scope/scope.js

@@ -415,7 +415,7 @@ export class Scope {
 
     lastDirtyWatch = null;
 
-    if (this.$$watchers.length == 0) {
+    if (this.$$watchers.length === 0) {
       this.$$digestWatchIndex = -1;
     }
     // we use unshift since we use a while loop in $digest for speed.