@angular-wave/angular.ts 0.0.6 → 0.0.7

package/src/loader.js

@@ -28,20 +28,6 @@ import { jqLite, startingTag } from "./jqLite";
 import { createInjector } from "./injector";
 import { CACHE } from "./core/cache";
 
-/**
- * @ngdoc module
- * @name ng
-
- * @installation
- * @description
- *
- * The ng module is loaded by default when an AngularJS application is started. The module itself
- * contains the essential components for an AngularJS application to function. The table below
- * lists a high level breakdown of each of the services/factories, filters, directives and testing
- * components available within this core module.
- *
- */
-
 const ngMinErr = minErr("ng");
 
 /** @type {Object.<string, angular.IModule>} */
@@ -131,7 +117,7 @@ export class Angular {
  * </html>
  * ```
  *
- * @param {string | Element | JQuery | Document} element DOM element which is the root of AngularJS application.
+ * @param {string | Element | Document} element DOM element which is the root of AngularJS application.
  * @param {Array<string | Function | any[]>=} modules an array of modules to load into the application.
  *     Each item in the array should be the name of a predefined module or a (DI annotated)
  *     function that will be invoked by the injector as a `config` block.

package/src/loader.md

@@ -0,0 +1,13 @@
+/\*\*
+
+- @ngdoc module
+- @name ng
+
+- @installation
+- @description
+-
+- The ng module is loaded by default when an AngularJS application is started. The module itself
+- contains the essential components for an AngularJS application to function. The table below
+- lists a high level breakdown of each of the services/factories, filters, directives and testing
+- components available within this core module.
+- \*/

package/test/jqlite.spec.js

@@ -548,13 +548,13 @@ describe("jqLite", () => {
     });
 
     it("should not add to the cache if the node is a comment or text node", () => {
-      const initial = Object.keys(jqLite.cache).length;
+      const initial = CACHE.size;
       const nodes = jqLite("<!-- some comment --> and some text");
-      expect(Object.keys(jqLite.cache).length).toEqual(initial);
+      expect(CACHE.size).toEqual(initial);
       nodes.data("someKey");
-      expect(Object.keys(jqLite.cache).length).toEqual(initial);
+      expect(CACHE.size).toEqual(initial);
       nodes.data("someKey", "someValue");
-      expect(Object.keys(jqLite.cache).length).toEqual(initial);
+      expect(CACHE.size).toEqual(initial);
     });
 
     it("should provide the non-wrapped data calls", () => {

package/test/ng/compile.spec.js

@@ -5081,36 +5081,36 @@ 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
-      JQLite.cache.clear();
+      CACHE.clear();
       window.angular.module("test1", ["ng"]);
       createInjector(["test1"]).invoke(($compile) => {
-        expect(JQLite.cache.size).toEqual(1);
+        expect(CACHE.size).toEqual(1);
         // First with only elements at the top level
         element = JQLite("<div><div></div></div>");
         $compile(element[0].childNodes)($rootScope);
-        expect(JQLite.cache.size).toEqual(2);
+        expect(CACHE.size).toEqual(2);
         element.empty();
-        expect(JQLite.cache.size).toEqual(1);
+        expect(CACHE.size).toEqual(1);
 
         // Next with non-empty text nodes at the top level
         // (in this case the compiler will wrap them in a <span>)
         element = JQLite("<div>xxx</div>");
         $compile(element[0].childNodes)($rootScope);
         element.empty();
-        expect(JQLite.cache.size).toEqual(1);
+        expect(CACHE.size).toEqual(1);
 
         // Next with comment nodes at the top level
         element = JQLite("<div><!-- comment --></div>");
         $compile(element[0].childNodes)($rootScope);
         element.empty();
-        expect(JQLite.cache.size).toEqual(1);
+        expect(CACHE.size).toEqual(1);
 
         // Finally with empty text nodes at the top level
         element = JQLite("<div>   \n<div></div>   </div>");
         $compile(element[0].childNodes)($rootScope);
-        expect(JQLite.cache.size).toEqual(2);
+        expect(CACHE.size).toEqual(2);
         element.empty();
-        expect(JQLite.cache.size).toEqual(1);
+        expect(CACHE.size).toEqual(1);
       });
     });
 
@@ -13790,28 +13790,28 @@ describe("$compile", () => {
         });
 
         it('should not leak if two "element" transclusions are on the same element', () => {
-          const cacheSize = JQLite.cache.size;
+          const cacheSize = CACHE.size;
 
           element = $compile(
             '<div><div ng-repeat="x in xs" ng-if="x==1">{{x}}</div></div>',
           )($rootScope);
-          expect(JQLite.cache.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize + 1);
 
           $rootScope.$apply("xs = [0,1]");
-          expect(JQLite.cache.size).toEqual(cacheSize + 2);
+          expect(CACHE.size).toEqual(cacheSize + 2);
 
           $rootScope.$apply("xs = [0]");
-          expect(JQLite.cache.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize + 1);
 
           $rootScope.$apply("xs = []");
-          expect(JQLite.cache.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize + 1);
 
           element.remove();
-          expect(JQLite.cache.size).toEqual(cacheSize + 0);
+          expect(CACHE.size).toEqual(cacheSize + 0);
         });
 
         it('should not leak if two "element" transclusions are on the same element', () => {
-          const cacheSize = JQLite.cache.size;
+          const cacheSize = CACHE.size;
           element = $compile(
             '<div><div ng-repeat="x in xs" ng-if="val">{{x}}</div></div>',
           )($rootScope);
@@ -13819,20 +13819,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(JQLite.cache.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize + 1);
 
           $rootScope.$apply("val = true");
           // Now we have two concrete transcluded elements plus some comments so two more cache items
-          expect(JQLite.cache.size).toEqual(cacheSize + 3);
+          expect(CACHE.size).toEqual(cacheSize + 3);
 
           $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(JQLite.cache.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize + 1);
 
           element.remove();
           // Now we've even removed the root element along with its cache
-          expect(JQLite.cache.size).toEqual(cacheSize + 0);
+          expect(CACHE.size).toEqual(cacheSize + 0);
         });
 
         // it("should not leak when continuing the compilation of elements on a scope that was destroyed", () => {
@@ -13857,7 +13857,7 @@ describe("$compile", () => {
         //       link: linkFn,
         //     }));
         //   initInjector("test1");
-        //   const cacheSize = JQLite.cache.size;
+        //   const cacheSize = CACHE.size;
         //   $templateCache.put("red.html", "<p>red</p>");
         //   const template = $compile(
         //     '<div ng-controller="Leak">' +
@@ -13872,7 +13872,7 @@ describe("$compile", () => {
         //   $rootScope.$digest();
 
         //   expect(linkFn).toHaveBeenCalled();
-        //   expect(JQLite.cache.size).toEqual(cacheSize + 2);
+        //   expect(CACHE.size).toEqual(cacheSize + 2);
 
         //   $templateCache.removeAll();
         //   const destroyedScope = $rootScope.$new();
@@ -13903,7 +13903,7 @@ describe("$compile", () => {
             firstRepeatedElem = element.children(".ng-scope").eq(0);
 
             expect(firstRepeatedElem.data("$scope")).toBeDefined();
-            privateData = CACHE.get(firstRepeatedElem[0]);
+            privateData = CACHE.get(firstRepeatedElem[0][EXPANDO]);
             expect(privateData.events).toBeDefined();
 
             expect(privateData.events.click).toBeDefined();
@@ -13919,7 +13919,7 @@ describe("$compile", () => {
 
             expect(destroyCount).toBe(2);
             expect(firstRepeatedElem.data("$scope")).not.toBeDefined();
-            privateData = CACHE.get(firstRepeatedElem[0]);
+            privateData = CACHE.get(firstRepeatedElem[0][EXPANDO]);
             expect(privateData && privateData.events).not.toBeDefined();
           }
 
@@ -14808,7 +14808,7 @@ describe("$compile", () => {
 
           it("should not leak memory with nested transclusion", () => {
             let size;
-            const initialSize = JQLite.cache.size;
+            const initialSize = CACHE.size;
 
             element = JQLite(
               '<div><ul><li ng-repeat="n in nums">{{n}} => <i ng-if="0 === n%2">Even</i><i ng-if="1 === n%2">Odd</i></li></ul></div>',
@@ -14817,14 +14817,14 @@ describe("$compile", () => {
 
             $rootScope.nums = [0, 1, 2];
             $rootScope.$apply();
-            size = JQLite.cache.size;
+            size = CACHE.size;
 
             $rootScope.nums = [3, 4, 5];
             $rootScope.$apply();
-            expect(JQLite.cache.size).toEqual(size);
+            expect(CACHE.size).toEqual(size);
 
             element.remove();
-            expect(JQLite.cache.size).toEqual(initialSize);
+            expect(CACHE.size).toEqual(initialSize);
           });
         });
 

package/src/route-to-reg-exp.js

@@ -1,41 +0,0 @@
-/**
- * @param {string} path - The path to parse. (It is assumed to have query and hash stripped off.)
- * @param {Object} opts - Options.
- * @return {Object} - An object containing an array of path parameter names (`keys`) and a regular
- *     expression (`regexp`) that can be used to identify a matching URL and extract the path
- *     parameter values.
- *
- * @description
- * Parses the given path, extracting path parameter names and a regular expression to match URLs.
- *
- * Originally inspired by `pathRexp` in `visionmedia/express/lib/utils.js`.
- */
-export function routeToRegExp(path, opts) {
-  const keys = [];
-
-  let pattern = path
-    .replace(/([().])/g, "\\$1")
-    .replace(/(\/)?:(\w+)(\*\?|[?*])?/g, (_, slash, key, option) => {
-      const optional = option === "?" || option === "*?";
-      const star = option === "*" || option === "*?";
-      keys.push({ name: key, optional });
-      return (
-        (optional ? `(?:${slash || ""}` : `${slash || ""}(?:`) +
-        (star ? "(.+?)" : "([^/]+)") +
-        (optional ? "?)?" : ")")
-      );
-    })
-    .replace(/([/$*])/g, "\\$1");
-
-  if (opts.ignoreTrailingSlashes) {
-    pattern = `${pattern.replace(/\/+$/, "")}/*`;
-  }
-
-  return {
-    keys,
-    regexp: new RegExp(
-      `^${pattern}(?:[?#]|$)`,
-      opts.caseInsensitiveMatch ? "i" : "",
-    ),
-  };
-}