@angular-wave/angular.ts 0.0.44 → 0.0.46

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@angular-wave/angular.ts",
   "license": "MIT",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

package/src/angular.spec.js

@@ -21,7 +21,7 @@ import {
   toJson,
   fromJson,
   nextUid,
-  nodeName_,
+  getNodeName,
   snakeCase,
 } from "./shared/utils";
 import { dealoc, JQLite, startingTag } from "./shared/jqlite/jqlite";
@@ -1827,14 +1827,14 @@ describe("angular", () => {
     });
   });
 
-  describe("nodeName_", () => {
+  describe("getNodeName", () => {
     it('should correctly detect node name with "namespace" when xmlns is defined', () => {
       const div = JQLite(
         '<div xmlns:ngtest="http://angularjs.org/">' +
           '<ngtest:foo ngtest:attr="bar"></ngtest:foo>' +
           "</div>",
       )[0];
-      expect(nodeName_(div.childNodes[0])).toBe("ngtest:foo");
+      expect(getNodeName(div.childNodes[0])).toBe("ngtest:foo");
       expect(div.childNodes[0].getAttribute("ngtest:attr")).toBe("bar");
     });
 
@@ -1844,13 +1844,13 @@ describe("angular", () => {
           '<ngtest:foo ngtest:attr="bar"></ng-test>' +
           "</div>",
       )[0];
-      expect(nodeName_(div.childNodes[0])).toBe("ngtest:foo");
+      expect(getNodeName(div.childNodes[0])).toBe("ngtest:foo");
       expect(div.childNodes[0].getAttribute("ngtest:attr")).toBe("bar");
     });
 
     it("should return undefined for elements without the .nodeName property", () => {
       // some elements, like SVGElementInstance don't have .nodeName property
-      expect(nodeName_({})).toBeUndefined();
+      expect(getNodeName({})).toBeUndefined();
     });
   });
 

package/src/core/compile/compile.js

@@ -26,7 +26,7 @@ import {
   inherit,
   isUndefined,
   arrayRemove,
-  nodeName_,
+  getNodeName,
   bind,
   trim,
   isBoolean,
@@ -1120,7 +1120,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
         if (!node) {
           return "html";
         }
-        return nodeName_(node) !== "foreignobject" &&
+        return getNodeName(node) !== "foreignobject" &&
           toString.call(node).match(/SVG/)
           ? "svg"
           : "html";
@@ -1822,7 +1822,8 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
                 // Add the matching elements into their slot
 
                 forEach(JQLite($compileNode[0].childNodes), (node) => {
-                  const slotName = slotMap[directiveNormalize(nodeName_(node))];
+                  const slotName =
+                    slotMap[directiveNormalize(getNodeName(node))];
                   if (slotName) {
                     filledSlots[slotName] = true;
                     slots[slotName] =
@@ -2911,7 +2912,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
           );
         }
 
-        const nodeName = nodeName_(node);
+        const nodeName = getNodeName(node);
         const trustedContext = getTrustedPropContext(nodeName, propName);
 
         let sanitizer = (x) => x;
@@ -2969,7 +2970,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
         name,
         isNgAttr,
       ) {
-        const nodeName = nodeName_(node);
+        const nodeName = getNodeName(node);
         const trustedContext = getTrustedAttrContext(nodeName, name);
         const mustHaveExpression = !isNgAttr;
         const allOrNothing = ALL_OR_NOTHING_ATTRS[name] || isNgAttr;

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

@@ -6,7 +6,7 @@ import {
   isFunction,
   valueFn,
   isElement,
-  nodeName_,
+  getNodeName,
   extend,
 } from "../../shared/utils";
 import { countChildScopes, countWatchers } from "../../core/scope/scope";
@@ -5603,7 +5603,7 @@ describe("$compile", () => {
         expect(() => {
           element = $compile("<div replace-with-tr></div>")($rootScope);
         }).not.toThrow();
-        expect(nodeName_(element)).toMatch(/tr/i);
+        expect(getNodeName(element)).toMatch(/tr/i);
       });
 
       it("should support templates with root <td> tags", () => {
@@ -5611,7 +5611,7 @@ describe("$compile", () => {
         expect(() => {
           element = $compile("<div replace-with-td></div>")($rootScope);
         }).not.toThrow();
-        expect(nodeName_(element)).toMatch(/td/i);
+        expect(getNodeName(element)).toMatch(/td/i);
       });
 
       it("should support templates with root <th> tags", () => {
@@ -5619,7 +5619,7 @@ describe("$compile", () => {
         expect(() => {
           element = $compile("<div replace-with-th></div>")($rootScope);
         }).not.toThrow();
-        expect(nodeName_(element)).toMatch(/th/i);
+        expect(getNodeName(element)).toMatch(/th/i);
       });
 
       it("should support templates with root <thead> tags", () => {
@@ -5627,7 +5627,7 @@ describe("$compile", () => {
         expect(() => {
           element = $compile("<div replace-with-thead></div>")($rootScope);
         }).not.toThrow();
-        expect(nodeName_(element)).toMatch(/thead/i);
+        expect(getNodeName(element)).toMatch(/thead/i);
       });
 
       it("should support templates with root <tbody> tags", () => {
@@ -5635,7 +5635,7 @@ describe("$compile", () => {
         expect(() => {
           element = $compile("<div replace-with-tbody></div>")($rootScope);
         }).not.toThrow();
-        expect(nodeName_(element)).toMatch(/tbody/i);
+        expect(getNodeName(element)).toMatch(/tbody/i);
       });
 
       it("should support templates with root <tfoot> tags", () => {
@@ -5643,7 +5643,7 @@ describe("$compile", () => {
         expect(() => {
           element = $compile("<div replace-with-tfoot></div>")($rootScope);
         }).not.toThrow();
-        expect(nodeName_(element)).toMatch(/tfoot/i);
+        expect(getNodeName(element)).toMatch(/tfoot/i);
       });
 
       it("should support templates with root <option> tags", () => {
@@ -5651,7 +5651,7 @@ describe("$compile", () => {
         expect(() => {
           element = $compile("<div replace-with-option></div>")($rootScope);
         }).not.toThrow();
-        expect(nodeName_(element)).toMatch(/option/i);
+        expect(getNodeName(element)).toMatch(/option/i);
       });
 
       it("should support templates with root <optgroup> tags", () => {
@@ -5659,7 +5659,7 @@ describe("$compile", () => {
         expect(() => {
           element = $compile("<div replace-with-optgroup></div>")($rootScope);
         }).not.toThrow();
-        expect(nodeName_(element)).toMatch(/optgroup/i);
+        expect(getNodeName(element)).toMatch(/optgroup/i);
       });
 
       it("should support SVG templates using directive.templateNamespace=svg", () => {
@@ -5681,7 +5681,7 @@ describe("$compile", () => {
         )($rootScope);
         const child = element.children().eq(0);
         $rootScope.$digest();
-        expect(nodeName_(child)).toMatch(/a/i);
+        expect(getNodeName(child)).toMatch(/a/i);
         expect(isSVGElement(child[0])).toBe(true);
         expect(child[0].href.baseVal).toBe("/foo/bar");
       });
@@ -5710,7 +5710,7 @@ describe("$compile", () => {
         );
         $rootScope.$digest();
         const child = element.children().eq(0);
-        expect(nodeName_(child)).toMatch(/msup/i);
+        expect(getNodeName(child)).toMatch(/msup/i);
         expect(isUnknownElement(child[0])).toBe(false);
         expect(isHTMLElement(child[0])).toBe(false);
       });
@@ -6566,7 +6566,7 @@ describe("$compile", () => {
           element = $compile("<div replace-with-tr></div>")($rootScope);
         }).not.toThrow();
         $rootScope.$digest();
-        expect(nodeName_(element)).toMatch(/tr/i);
+        expect(getNodeName(element)).toMatch(/tr/i);
       });
 
       it("should support templates with root <td> tags", () => {
@@ -6575,7 +6575,7 @@ describe("$compile", () => {
           element = $compile("<div replace-with-td></div>")($rootScope);
         }).not.toThrow();
         $rootScope.$digest();
-        expect(nodeName_(element)).toMatch(/td/i);
+        expect(getNodeName(element)).toMatch(/td/i);
       });
 
       it("should support templates with root <th> tags", () => {
@@ -6584,7 +6584,7 @@ describe("$compile", () => {
           element = $compile("<div replace-with-th></div>")($rootScope);
         }).not.toThrow();
         $rootScope.$digest();
-        expect(nodeName_(element)).toMatch(/th/i);
+        expect(getNodeName(element)).toMatch(/th/i);
       });
 
       it("should support templates with root <thead> tags", () => {
@@ -6593,7 +6593,7 @@ describe("$compile", () => {
           element = $compile("<div replace-with-thead></div>")($rootScope);
         }).not.toThrow();
         $rootScope.$digest();
-        expect(nodeName_(element)).toMatch(/thead/i);
+        expect(getNodeName(element)).toMatch(/thead/i);
       });
 
       it("should support templates with root <tbody> tags", () => {
@@ -6602,7 +6602,7 @@ describe("$compile", () => {
           element = $compile("<div replace-with-tbody></div>")($rootScope);
         }).not.toThrow();
         $rootScope.$digest();
-        expect(nodeName_(element)).toMatch(/tbody/i);
+        expect(getNodeName(element)).toMatch(/tbody/i);
       });
 
       it("should support templates with root <tfoot> tags", () => {
@@ -6611,7 +6611,7 @@ describe("$compile", () => {
           element = $compile("<div replace-with-tfoot></div>")($rootScope);
         }).not.toThrow();
         $rootScope.$digest();
-        expect(nodeName_(element)).toMatch(/tfoot/i);
+        expect(getNodeName(element)).toMatch(/tfoot/i);
       });
 
       it("should support templates with root <option> tags", () => {
@@ -6620,7 +6620,7 @@ describe("$compile", () => {
           element = $compile("<div replace-with-option></div>")($rootScope);
         }).not.toThrow();
         $rootScope.$digest();
-        expect(nodeName_(element)).toMatch(/option/i);
+        expect(getNodeName(element)).toMatch(/option/i);
       });
 
       it("should support templates with root <optgroup> tags", () => {
@@ -6629,7 +6629,7 @@ describe("$compile", () => {
           element = $compile("<div replace-with-optgroup></div>")($rootScope);
         }).not.toThrow();
         $rootScope.$digest();
-        expect(nodeName_(element)).toMatch(/optgroup/i);
+        expect(getNodeName(element)).toMatch(/optgroup/i);
       });
 
       it("should support SVG templates using directive.templateNamespace=svg", () => {
@@ -6656,7 +6656,7 @@ describe("$compile", () => {
             )($rootScope);
             $rootScope.$digest();
             const child = element.children().eq(0);
-            expect(nodeName_(child)).toMatch(/a/i);
+            expect(getNodeName(child)).toMatch(/a/i);
             expect(isSVGElement(child[0])).toBe(true);
             expect(child[0].href.baseVal).toBe("/foo/bar");
           },
@@ -6692,7 +6692,7 @@ describe("$compile", () => {
             );
             $rootScope.$digest();
             const child = element.children().eq(0);
-            expect(nodeName_(child)).toMatch(/msup/i);
+            expect(getNodeName(child)).toMatch(/msup/i);
             expect(isUnknownElement(child[0])).toBe(false);
             expect(isHTMLElement(child[0])).toBe(false);
           },
@@ -14789,10 +14789,10 @@ describe("$compile", () => {
           JQLite("<div>before<div transclude></div>after</div>")[0].childNodes,
         );
         expect(element.length).toEqual(3);
-        expect(nodeName_(element[1])).toBe("div");
+        expect(getNodeName(element[1])).toBe("div");
         $compile(element)($rootScope);
-        expect(nodeName_(element[1])).toBe("#comment");
-        expect(nodeName_(comment)).toBe("#comment");
+        expect(getNodeName(element[1])).toBe("#comment");
+        expect(getNodeName(comment)).toBe("#comment");
       });
 
       it("should terminate compilation only for element transclusion", () => {
@@ -14973,7 +14973,7 @@ describe("$compile", () => {
           .directive("innerAgain", () => ({
             transclude: true,
             link(scope, element, attr, controllers, transclude) {
-              log.push(`innerAgain:${nodeName_(element)}`);
+              log.push(`innerAgain:${getNodeName(element)}`);
               transclude(scope, (clone) => {
                 element.parent().append(clone);
               });
@@ -14983,13 +14983,13 @@ describe("$compile", () => {
             replace: true,
             templateUrl: "inner.html",
             link(scope, element) {
-              log.push(`inner:${nodeName_(element)}`);
+              log.push(`inner:${getNodeName(element)}`);
             },
           }))
           .directive("outer", () => ({
             transclude: true,
             link(scope, element, attrs, controllers, transclude) {
-              log.push(`outer:${nodeName_(element)}`);
+              log.push(`outer:${getNodeName(element)}`);
               transclude(scope, (clone) => {
                 element.parent().append(clone);
               });

package/src/directive/ref/ref.js

@@ -1,4 +1,4 @@
-import { nodeName_, minErr, directiveNormalize } from "../../shared/utils";
+import { getNodeName, minErr, directiveNormalize } from "../../shared/utils";
 
 /**
  * @ngdoc directive
@@ -36,7 +36,7 @@ export const ngRefDirective = [
     restrict: "A",
     compile(tElement, tAttrs) {
       // Get the expected controller name, converts <data-some-thing> into "someThing"
-      const controllerName = directiveNormalize(nodeName_(tElement));
+      const controllerName = directiveNormalize(getNodeName(tElement));
 
       // Get the expression for value binding
       const getter = $parse(tAttrs.ngRef);

package/src/router/directives/directives.test.js

@@ -1,6 +1,6 @@
 import { test, expect } from "@playwright/test";
 
-test("unitstate-directives tests contain no errors", async ({ page }) => {
+test("unit state-directives tests contain no errors", async ({ page }) => {
   await page.goto("src/router/directives/state-directives.html");
   await page.content();
   await page.waitForTimeout(6000);

package/src/router/state/state-service.js

@@ -22,40 +22,6 @@ import { not, val } from "../../shared/hof";
 import { EventBus } from "../../core/pubsub/pubsub";
 
 const err = minErr("$stateProvider");
-// Right now this is a collection of all the properties we encounter in tests
-const validKeys = [
-  "$$state",
-  "__stateObjectCache",
-  "abstract",
-  "bindings",
-  "controller",
-  "controllerAs",
-  "controllerProvider",
-  "component",
-  "componentProvider",
-  "data",
-  "includes",
-  "lazyLoad",
-  "name",
-  "navigable",
-  "onEnter",
-  "onExit",
-  "onRetain",
-  "params",
-  "parent",
-  "path",
-  "redirectTo",
-  "reloadOnSearch",
-  "resolve",
-  "resolveAs",
-  "resolvables",
-  "self",
-  "template",
-  "templateProvider",
-  "templateUrl",
-  "url",
-  "views",
-];
 
 /**
  * Provides services related to ui-router states.
@@ -230,13 +196,6 @@ export class StateService {
     if (!definition.name) {
       throw err("stateinvalid", `'name' required`);
     }
-
-    const hasInvalidKeys = Object.keys(definition).filter(
-      (key) => !validKeys.includes(key),
-    );
-    if (hasInvalidKeys.length) {
-      throw err("stateinvalid", `Invalid key(s): ${hasInvalidKeys.join(", ")}`);
-    }
     try {
       this.stateRegistry.register(definition);
     } catch (e) {

package/src/router/state/state.spec.js

@@ -128,12 +128,6 @@ describe("$state", () => {
       }).toThrowError(/stateinvalid/);
     });
 
-    it("should should not allow states that have invalid keys", () => {
-      expect(() => {
-        $stateProvider.state({ name: "faulty", faulturl: "/to-string" });
-      }).toThrowError(/stateinvalid/);
-    });
-
     it("should requred `name` if state definition object is passed", () => {
       expect(() => {
         $stateProvider.state({ url: "/to-string" });

package/src/services/anchor-scroll.js

@@ -3,7 +3,7 @@ import {
   isFunction,
   isNumber,
   isString,
-  nodeName_,
+  getNodeName,
 } from "../shared/utils";
 
 export function AnchorScrollProvider() {
@@ -31,7 +31,7 @@ export function AnchorScrollProvider() {
       function getFirstAnchor(list) {
         let result = null;
         Array.prototype.some.call(list, (element) => {
-          if (nodeName_(element) === "a") {
+          if (getNodeName(element) === "a") {
             result = element;
             return true;
           }