@angular-wave/angular.ts 0.0.9 → 0.0.10

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@angular-wave/angular.ts",
   "license": "MIT",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "type": "module",
-  "main": "dist/angular-ts.cjs.js",
-  "module": "dist/angular-ts.esm.js",
+  "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",
   "repository": {
     "type": "git",

package/rollup.config.js

@@ -24,7 +24,7 @@ export default [
   {
     input: 'src/index.js',
     external: ['ms'],
-    output: { file: pkg.module, format: 'es' },
+    output: { file: pkg.main, format: 'es' },
     plugins: [terser()],
   },
 ];

package/src/core/compile.js

@@ -910,7 +910,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
           }
         }
 
-      /**
+        /**
        * @ngdoc method
        * @name $compile.directive.Attributes#$observe
        * @kind function
@@ -1047,9 +1047,11 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
           }
 
           options = options || {};
-          let { parentBoundTranscludeFn } = options;
-          const { transcludeControllers } = options;
-          const { futureParentElement } = options;
+          let {
+            transcludeControllers,
+            parentBoundTranscludeFn,
+            futureParentElement,
+          } = options;
 
           // When `parentBoundTranscludeFn` is passed, it is a
           // `controllersBoundTransclude` function (it was previously passed
@@ -1096,9 +1098,6 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
               );
             }
           }
-
-          compile.$$addScopeInfo($linkNode, scope);
-
           if (cloneConnectFn) cloneConnectFn($linkNode, scope);
           if (compositeLinkFn)
             compositeLinkFn(

package/src/core/root-scope.js

@@ -1044,7 +1044,7 @@ class Scope {
    * Application code can register a `$destroy` event handler that will give it a chance to
    * perform any necessary cleanup.
    *
-   * Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to
+   * Note that, in AngularJS, there is also a `$destroy` event, which can be used to
    * clean up DOM bindings before an element is removed from the DOM.
    */
   $destroy() {

package/src/exts/messages.md

@@ -518,33 +518,33 @@ _ {@link module:ngMessages Click here} to learn more about`ngMessages`and`ngMess
     _ @param {string} ngMessageExp|whenExp an expression value corresponding to the message key.
     _/
 
-                            /**
-                            * @ngdoc directive
-                            * @name ngMessageDefault
-                            * @restrict AE
-                            * @scope
-                            *
-                            * @description
-                            * `ngMessageDefault` is a directive with the purpose to show and hide a default message for
-                            * {@link directive:ngMessages}, when none of provided messages matches.
-                            *
-                            * More information about using `ngMessageDefault` can be found in the
-                            * {@link module:ngMessages `ngMessages` module documentation}.
-                            *
-                            * @usage
-                            * ```html
-                            * <!-- using attribute directives -->
-                            * <ANY ng-messages="expression" role="alert">
-                            *   <ANY ng-message="stringValue">...</ANY>
-                            *   <ANY ng-message="stringValue1, stringValue2, ...">...</ANY>
-                            *   <ANY ng-message-default>...</ANY>
-                            * </ANY>
-                            *
-                            * <!-- or by using element directives -->
-                            * <ng-messages for="expression" role="alert">
-                            *   <ng-message when="stringValue">...</ng-message>
-                            *   <ng-message when="stringValue1, stringValue2, ...">...</ng-message>
-                            *   <ng-message-default>...</ng-message-default>
-                            * </ng-messages>
-                            *
-                            */
+                                                /**
+                                                * @ngdoc directive
+                                                * @name ngMessageDefault
+                                                * @restrict AE
+                                                * @scope
+                                                *
+                                                * @description
+                                                * `ngMessageDefault` is a directive with the purpose to show and hide a default message for
+                                                * {@link directive:ngMessages}, when none of provided messages matches.
+                                                *
+                                                * More information about using `ngMessageDefault` can be found in the
+                                                * {@link module:ngMessages `ngMessages` module documentation}.
+                                                *
+                                                * @usage
+                                                * ```html
+                                                * <!-- using attribute directives -->
+                                                * <ANY ng-messages="expression" role="alert">
+                                                *   <ANY ng-message="stringValue">...</ANY>
+                                                *   <ANY ng-message="stringValue1, stringValue2, ...">...</ANY>
+                                                *   <ANY ng-message-default>...</ANY>
+                                                * </ANY>
+                                                *
+                                                * <!-- or by using element directives -->
+                                                * <ng-messages for="expression" role="alert">
+                                                *   <ng-message when="stringValue">...</ng-message>
+                                                *   <ng-message when="stringValue1, stringValue2, ...">...</ng-message>
+                                                *   <ng-message-default>...</ng-message-default>
+                                                * </ng-messages>
+                                                *
+                                                */

package/src/jqLite.js

@@ -281,6 +281,8 @@ export function JQLite(element) {
 }
 export var jqLite = JQLite;
 
+jqLite.CACHE = CACHE;
+
 /**
  * @param {Element} element
  * @param {boolean} [onlyDescendants]
@@ -827,7 +829,7 @@ function specialMouseHandlerWrapper(target, event, handler) {
 forEach(
   {
     removeData: jqLiteRemoveData,
-    on: function jqLiteOn(element, type, fn, unsupported) {
+    on: (element, type, fn, unsupported) => {
       if (isDefined(unsupported))
         throw jqLiteMinErr(
           "onargs",

package/test/ng/compile.spec.js

@@ -1112,15 +1112,16 @@ describe("$compile", () => {
   });
 
   describe("linking", () => {
-    it("takes a scope and attaches it to elements", () => {
-      registerDirectives("myDirective", () => {
-        return { compile: () => {} };
-      });
-      reloadModules();
-      var el = $("<div my-directive></div>");
-      $compile(el)($rootScope);
-      expect(el.data("$scope")).toBe($rootScope);
-    });
+    // THERE IS NO SCOPE ATTACHED TO ACTUAL ELEMENTS
+    // it("takes a scope and attaches it to elements", () => {
+    //   registerDirectives("myDirective", () => {
+    //     return { compile: () => {} };
+    //   });
+    //   reloadModules();
+    //   var el = $("<div my-directive></div>");
+    //   $compile(el)($rootScope);
+    //   expect(el.data("$scope")).toBe($rootScope);
+    // });
 
     it("calls directive link function with scope", () => {
       var givenScope, givenElement, givenAttrs;
@@ -4969,10 +4970,11 @@ describe("$compile", () => {
   });
 
   describe("compile phase", () => {
-    it("should attach scope to the document node when it is compiled explicitly", () => {
-      $compile($document)($rootScope);
-      expect($document.scope()).toBe($rootScope);
-    });
+    // NO ELEMENT ATTACHMENTS
+    // it("should attach scope to the document node when it is compiled explicitly", () => {
+    //   $compile($document)($rootScope);
+    //   expect($document.scope()).toBe($rootScope);
+    // });
 
     it("should not wrap root text nodes in spans", () => {
       element = JQLite("<div>   <div>A</div>\n  <div>B</div>C\t\n  </div>");
@@ -4994,6 +4996,7 @@ describe("$compile", () => {
       // We compile the contents of element (i.e. not element itself)
       // Then delete these contents and check the cache has been reset to zero
       // Clear cache
+      // Update: THIS TEST IS IRRELEVANT IF WE DONT POLLUTE THE CACHE
       CACHE.clear();
       window.angular.module("test1", ["ng"]);
       createInjector(["test1"]).invoke(($compile) => {
@@ -5001,7 +5004,7 @@ describe("$compile", () => {
         // First with only elements at the top level
         element = JQLite("<div><div></div></div>");
         $compile(element[0].childNodes)($rootScope);
-        expect(CACHE.size).toEqual(2);
+        // expect(CACHE.size).toEqual(2);
         element.empty();
         expect(CACHE.size).toEqual(1);
 
@@ -5021,7 +5024,7 @@ describe("$compile", () => {
         // Finally with empty text nodes at the top level
         element = JQLite("<div>   \n<div></div>   </div>");
         $compile(element[0].childNodes)($rootScope);
-        expect(CACHE.size).toEqual(2);
+        //expect(CACHE.size).toEqual(2);
         element.empty();
         expect(CACHE.size).toEqual(1);
       });
@@ -7075,13 +7078,6 @@ describe("$compile", () => {
       });
 
       describe("scope()/isolate() scope getters", () => {
-        describe("with no directives", () => {
-          it("should return the scope of the parent node", () => {
-            element = $compile("<div></div>")($rootScope);
-            expect(element.scope()).toBe($rootScope);
-          });
-        });
-
         describe("with new scope directives", () => {
           it("should return the new scope at the directive element", () => {
             element = $compile("<div scope></div>")($rootScope);
@@ -7107,22 +7103,17 @@ describe("$compile", () => {
         });
 
         describe("with isolate scope directives", () => {
-          it("should return the root scope for directives at the root element", () => {
-            element = $compile("<div iscope></div>")($rootScope);
-            expect(element.scope()).toBe($rootScope);
-          });
-
           it("should return the non-isolate scope at the directive element", () => {
+            expect($rootScope.$$childHead).toBeNull();
             let directiveElement;
             element = $compile("<div><div iscope></div></div>")($rootScope);
             directiveElement = element.children();
-            expect(directiveElement.scope()).toBe($rootScope);
-            expect(directiveElement.isolateScope().$parent).toBe($rootScope);
+            expect($rootScope.$$childHead.$parent).toBe($rootScope);
           });
 
           it("should return the isolate scope for children in the original template", () => {
             element = $compile("<div iscope><a></a></div>")($rootScope);
-            expect(element.find("a").scope()).toBe($rootScope); // xx
+            expect($rootScope.$$childHead.$parent).toBe($rootScope); // xx
           });
 
           it("should return the isolate scope for children in directive template", () => {
@@ -13541,19 +13532,19 @@ describe("$compile", () => {
           element = $compile(
             '<div><div ng-repeat="x in xs" ng-if="x==1">{{x}}</div></div>',
           )($rootScope);
-          expect(CACHE.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize);
 
           $rootScope.$apply("xs = [0,1]");
-          expect(CACHE.size).toEqual(cacheSize + 2);
+          expect(CACHE.size).toEqual(cacheSize);
 
           $rootScope.$apply("xs = [0]");
-          expect(CACHE.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize);
 
           $rootScope.$apply("xs = []");
-          expect(CACHE.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize);
 
           element.remove();
-          expect(CACHE.size).toEqual(cacheSize + 0);
+          expect(CACHE.size).toEqual(cacheSize);
         });
 
         it('should not leak if two "element" transclusions are on the same element', () => {
@@ -13565,20 +13556,20 @@ describe("$compile", () => {
           $rootScope.$apply("xs = [0,1]");
           // At this point we have a bunch of comment placeholders but no real transcluded elements
           // So the cache only contains the root element's data
-          expect(CACHE.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize);
 
           $rootScope.$apply("val = true");
           // Now we have two concrete transcluded elements plus some comments so two more cache items
-          expect(CACHE.size).toEqual(cacheSize + 3);
+          expect(CACHE.size).toEqual(cacheSize);
 
           $rootScope.$apply("val = false");
           // Once again we only have comments so no transcluded elements and the cache is back to just
           // the root element
-          expect(CACHE.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize);
 
           element.remove();
           // Now we've even removed the root element along with its cache
-          expect(CACHE.size).toEqual(cacheSize + 0);
+          expect(CACHE.size).toEqual(cacheSize);
         });
 
         // it("should not leak when continuing the compilation of elements on a scope that was destroyed", () => {
@@ -13647,7 +13638,6 @@ describe("$compile", () => {
             $rootScope.$apply(`xs = [${xs}]`);
             firstRepeatedElem = element.children(".ng-scope").eq(0);
 
-            expect(firstRepeatedElem.data("$scope")).toBeDefined();
             privateData = CACHE.get(firstRepeatedElem[0][EXPANDO]);
             expect(privateData.events).toBeDefined();
 
@@ -17026,40 +17016,39 @@ describe("$compile", () => {
           "</div>",
       )($rootScope);
       $rootScope.$apply("val0 = true; val1 = true; val2 = true");
-
+      expect($rootScope.$$childHead).toBeTruthy();
+      expect($rootScope.$$childHead.$$childHead).toBeTruthy();
       // At this point we should have something like:
       //
       // <div>
       //
-      //   <!-- ngIf: val0 -->
-      //
+      //   <!---->
       //   <div ng-if-start="val0">
-      //     <!-- ngIf: val1 -->
+      //     <!---->
       //     <span ng-if="val1"></span>
-      //     <!-- end ngIf: val1 -->
+      //     <!---->
       //   </div>
       //
       //   <div ng-if-end="">
-      //     <!-- ngIf: val2 -->
+      //     <!---->
       //     <span ng-if="val2"></span>
-      //     <!-- end ngIf: val2 -->
+      //     <!---->
       //   </div>
       //
-      //   <!-- end ngIf: val0 -->
+      //   <!---->
       // </div>
-      const ngIfStartScope = element.find("div").eq(0).scope();
-      const ngIfEndScope = element.find("div").eq(1).scope();
+      // const ngIfStartScope = element.find("div").eq(0).scope();
+      // const ngIfEndScope = element.find("div").eq(1).scope();
 
-      expect(ngIfStartScope.$id).toEqual(ngIfEndScope.$id);
+      // expect(ngIfStartScope.$id).toEqual(ngIfEndScope.$id);
 
-      const ngIf1Scope = element.find("span").eq(0).scope();
-      const ngIf2Scope = element.find("span").eq(1).scope();
+      // const ngIf1Scope = element.find("span").eq(0).scope();
+      // const ngIf2Scope = element.find("span").eq(1).scope();
 
-      expect(ngIf1Scope.$id).not.toEqual(ngIf2Scope.$id);
-      expect(ngIf1Scope.$parent.$id).toEqual(ngIf2Scope.$parent.$id);
+      // expect(ngIf1Scope.$id).not.toEqual(ngIf2Scope.$id);
+      // expect(ngIf1Scope.$parent.$id).toEqual(ngIf2Scope.$parent.$id);
 
       $rootScope.$apply("val1 = false");
-
       // Now we should have something like:
       //
       // <div>
@@ -17075,9 +17064,9 @@ describe("$compile", () => {
       //   <!-- end ngIf: val0 -->
       // </div>
 
-      expect(ngIfStartScope.$$destroyed).not.toEqual(true);
-      expect(ngIf1Scope.$$destroyed).toEqual(true);
-      expect(ngIf2Scope.$$destroyed).not.toEqual(true);
+      // expect(ngIfStartScope.$$destroyed).not.toEqual(true);
+      // expect(ngIf1Scope.$$destroyed).toEqual(true);
+      // expect(ngIf2Scope.$$destroyed).not.toEqual(true);
 
       $rootScope.$apply("val0 = false");
 
@@ -17086,10 +17075,11 @@ describe("$compile", () => {
       // <div>
       //   <!-- ngIf: val0 -->
       // </div>
-
-      expect(ngIfStartScope.$$destroyed).toEqual(true);
-      expect(ngIf1Scope.$$destroyed).toEqual(true);
-      expect(ngIf2Scope.$$destroyed).toEqual(true);
+      // TODO: Until we figure out a better way of testing this
+      expect($rootScope.$$childHead).toBeNull();
+      // expect(ngIfStartScope.$$destroyed).toEqual(true);
+      // expect(ngIf1Scope.$$destroyed).toEqual(true);
+      // expect(ngIf2Scope.$$destroyed).toEqual(true);
     });
 
     it("should set up and destroy the transclusion scopes correctly", () => {
@@ -17105,7 +17095,7 @@ describe("$compile", () => {
       //   <!-- ngRepeat: val in val0 -->
       // </div>
 
-      expect(element.scope().$id).toEqual($rootScope.$id);
+      //expect(element.scope().$id).toEqual($rootScope.$id);
 
       // Now we create all the elements
       $rootScope.$apply("val0 = [1]; val1 = true; val2 = true");
@@ -17126,17 +17116,17 @@ describe("$compile", () => {
       //   <!-- end ngIf: val2 -->
       //   <!-- end ngRepeat: val in val0 -->
       // </div>
-      const ngIf1Scope = element.find("div").eq(0).scope();
-      const ngIf2Scope = element.find("div").eq(1).scope();
-      const ngRepeatScope = ngIf1Scope.$parent;
+      // const ngIf1Scope = element.find("div").eq(0).scope();
+      // const ngIf2Scope = element.find("div").eq(1).scope();
+      // const ngRepeatScope = ngIf1Scope.$parent;
 
-      expect(ngIf1Scope.$id).not.toEqual(ngIf2Scope.$id);
-      expect(ngIf1Scope.$parent.$id).toEqual(ngRepeatScope.$id);
-      expect(ngIf2Scope.$parent.$id).toEqual(ngRepeatScope.$id);
+      // expect(ngIf1Scope.$id).not.toEqual(ngIf2Scope.$id);
+      // expect(ngIf1Scope.$parent.$id).toEqual(ngRepeatScope.$id);
+      // expect(ngIf2Scope.$parent.$id).toEqual(ngRepeatScope.$id);
 
-      // What is happening here??
-      // We seem to have a repeater scope which doesn't actually match to any element
-      expect(ngRepeatScope.$parent.$id).toEqual($rootScope.$id);
+      // // What is happening here??
+      // // We seem to have a repeater scope which doesn't actually match to any element
+      // expect(ngRepeatScope.$parent.$id).toEqual($rootScope.$id);
 
       // Now remove the first ngIf element from the first item in the repeater
       $rootScope.$apply("val1 = false");
@@ -17155,9 +17145,9 @@ describe("$compile", () => {
       //   <!-- end ngRepeat: val in val0 -->
       // </div>
       //
-      expect(ngRepeatScope.$$destroyed).toEqual(false);
-      expect(ngIf1Scope.$$destroyed).toEqual(true);
-      expect(ngIf2Scope.$$destroyed).toEqual(false);
+      // expect(ngRepeatScope.$$destroyed).toEqual(false);
+      // expect(ngIf1Scope.$$destroyed).toEqual(true);
+      // expect(ngIf2Scope.$$destroyed).toEqual(false);
 
       // Now remove the second ngIf element from the first item in the repeater
       $rootScope.$apply("val2 = false");
@@ -17171,17 +17161,18 @@ describe("$compile", () => {
       //   <!-- end ngRepeat: val in val0 -->
       // </div>
 
-      expect(ngRepeatScope.$$destroyed).toEqual(false);
-      expect(ngIf1Scope.$$destroyed).toEqual(true);
-      expect(ngIf2Scope.$$destroyed).toEqual(true);
+      // expect(ngRepeatScope.$$destroyed).toEqual(false);
+      // expect(ngIf1Scope.$$destroyed).toEqual(true);
+      // expect(ngIf2Scope.$$destroyed).toEqual(true);
 
       // Finally remove the repeat items
       $rootScope.$apply("val0 = []");
 
       // Somehow this ngRepeat scope knows how to destroy itself...
-      expect(ngRepeatScope.$$destroyed).toEqual(true);
-      expect(ngIf1Scope.$$destroyed).toEqual(true);
-      expect(ngIf2Scope.$$destroyed).toEqual(true);
+      expect($rootScope.$$childHead).toBeNull();
+      // expect(ngRepeatScope.$$destroyed).toEqual(true);
+      // expect(ngIf1Scope.$$destroyed).toEqual(true);
+      // expect(ngIf2Scope.$$destroyed).toEqual(true);
     });
 
     it("should throw error if unterminated", () => {

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

@@ -987,7 +987,7 @@ describe("form", () => {
       });
 
       const { parent } = scope;
-      const { child } = doc.find("input").scope();
+      const child = parent.child;
       const input = child.text;
 
       expect(parent).toBeDefined();

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

@@ -103,10 +103,11 @@ describe("ngIf", () => {
 
     it("should destroy the child scope every time the expression evaluates to false", () => {
       $scope.value = true;
+      debugger;
       element.append($compile('<div ng-if="value"></div>')($scope));
       $scope.$apply();
 
-      const childScope = element.children().scope();
+      const childScope = $scope.$$childHead;
       let destroyed = false;
 
       childScope.$on("$destroy", () => {

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

@@ -236,13 +236,13 @@ describe("ngInclude", () => {
       const injector = angular.bootstrap(element, ["myModule"]);
       $rootScope = injector.get("$rootScope");
       $rootScope.$digest();
-      expect(element.children().scope()).toBeFalsy();
+      expect($rootScope.$$childHead).toBeFalsy();
 
       $rootScope.url = "/mock/hello";
       $rootScope.$digest();
 
       setTimeout(() => {
-        expect(element.children().scope().$parent).toBe($rootScope);
+        expect($rootScope.$$childHead.$parent).toBe($rootScope);
         expect(element.text()).toBe("Hello");
 
         $rootScope.url = "/mock/401";
@@ -258,7 +258,7 @@ describe("ngInclude", () => {
       }, 200);
 
       setTimeout(() => {
-        expect(element.children().scope().$parent).toBe($rootScope);
+        expect($rootScope.$$childHead.$parent).toBe($rootScope);
 
         $rootScope.url = null;
         $rootScope.$digest();

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

@@ -223,32 +223,29 @@ describe("ngSwitch", () => {
 
   it("should properly create and destroy child scopes", () => {
     element = $compile(
-      '<ng:switch on="url">' +
-        '<div ng-switch-when="a">{{name}}</div>' +
-        "</ng:switch>",
+      '<ng-switch on="url"><div ng-switch-when="a">{{name}}</div></ng-switch>',
     )($scope);
     $scope.$apply();
 
-    const getChildScope = function () {
-      return element.find("div").scope();
-    };
-
-    expect(getChildScope()).toBeUndefined();
+    expect($scope.$$childHead).toBeNull();
 
     $scope.url = "a";
     $scope.$apply();
-    const child1 = getChildScope();
+    const child1 = $scope.$$childHead;
     expect(child1).toBeDefined();
     spyOn(child1, "$destroy");
 
     $scope.url = "x";
     $scope.$apply();
-    expect(getChildScope()).toBeUndefined();
+
+    // NOTE THAT THE CHILD SCOPE IS NOT ACTUALLY DESTROYED.
+    expect(child1).toBeDefined();
     expect(child1.$destroy).toHaveBeenCalled();
 
     $scope.url = "a";
     $scope.$apply();
-    const child2 = getChildScope();
+    // ... BUT A NEW CHILD SCOPE WILL BE CREATED IN A TAIL.
+    const child2 = $scope.$$childTail;
     expect(child2).toBeDefined();
     expect(child2).not.toBe(child1);
   });