@angular-wave/angular.ts 0.0.6 → 0.0.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@angular-wave/angular.ts",
   "license": "MIT",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "type": "module",
   "main": "dist/angular-ts.cjs.js",
   "module": "dist/angular-ts.esm.js",

package/src/core/compile.js

@@ -940,7 +940,6 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
           const booleanKey = getBooleanAttrName(node, key);
           const aliasedKey = ALIASED_ATTR[key];
           let observer = key;
-          let nodeName;
 
           if (booleanKey) {
             this.$$element[0][key] = value;
@@ -962,7 +961,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
             }
           }
 
-          nodeName = nodeName_(this.$$element);
+          let nodeName = this.$$element[0].nodeName.toLowerCase();
 
           // Sanitize img[srcset] values.
           if (nodeName === "img" && key === "srcset") {
@@ -1461,7 +1460,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
 
         switch (nodeType) {
           case Node.ELEMENT_NODE /* Element */:
-            nodeName = nodeName_(node);
+            nodeName = node.nodeName.toLowerCase();
 
             // use the node name: <directive>
             addDirective(

package/src/core/filter.js

@@ -4,120 +4,10 @@ import { jsonFilter } from "../filters/filters";
 import { limitToFilter } from "../filters/limit-to";
 import { orderByFilter } from "../filters/order-by";
 
-/**
- * @ngdoc provider
- * @name $filterProvider
- * @description
- *
- * Filters are just functions which transform input to an output. However filters need to be
- * Dependency Injected. To achieve this a filter definition consists of a factory function which is
- * annotated with dependencies and is responsible for creating a filter function.
- *
- * <div class="alert alert-warning">
- * **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
- * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
- * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
- * (`myapp_subsection_filterx`).
- * </div>
- *
- * ```js
- *   // Filter registration
- *   function MyModule($provide, $filterProvider) {
- *     // create a service to demonstrate injection (not always needed)
- *     $provide.value('greet', function(name){
- *       return 'Hello ' + name + '!';
- *     });
- *
- *     // register a filter factory which uses the
- *     // greet service to demonstrate DI.
- *     $filterProvider.register('greet', function(greet){
- *       // return the filter function which uses the greet service
- *       // to generate salutation
- *       return function(text) {
- *         // filters need to be forgiving so check input validity
- *         return text && greet(text) || text;
- *       };
- *     });
- *   }
- * ```
- *
- * The filter function is registered with the `$injector` under the filter name suffix with
- * `Filter`.
- *
- * ```js
- *   it('should be the same instance', inject(
- *     function($filterProvider) {
- *       $filterProvider.register('reverse', function(){
- *         return ...;
- *       });
- *     },
- *     function($filter, reverseFilter) {
- *       expect($filter('reverse')).toBe(reverseFilter);
- *     });
- * ```
- *
- *
- * For more information about how AngularJS filters work, and how to create your own filters, see
- * {@link guide/filter Filters} in the AngularJS Developer Guide.
- */
-
-/**
- * @ngdoc service
- * @name $filter
- * @kind function
- * @description
- * Filters are used for formatting data displayed to the user.
- *
- * They can be used in view templates, controllers or services. AngularJS comes
- * with a collection of [built-in filters](api/ng/filter), but it is easy to
- * define your own as well.
- *
- * The general syntax in templates is as follows:
- *
- * ```html
- * {{ expression [| filter_name[:parameter_value] ... ] }}
- * ```
- *
- * @param {String} name Name of the filter function to retrieve
- * @return {Function} the filter function
- * @example
-   <example name="$filter" module="filterExample">
-     <file name="index.html">
-       <div ng-controller="MainCtrl">
-        <h3>{{ originalText }}</h3>
-        <h3>{{ filteredText }}</h3>
-       </div>
-     </file>
-
-     <file name="script.js">
-      angular.module('filterExample', [])
-      .controller('MainCtrl', function($scope, $filter) {
-        $scope.originalText = 'hello';
-        $scope.filteredText = $filter('uppercase')($scope.originalText);
-      });
-     </file>
-   </example>
-  */
 $FilterProvider.$inject = ["$provide"];
 export function $FilterProvider($provide) {
   const suffix = "Filter";
 
-  /**
-   * @ngdoc method
-   * @name $filterProvider#register
-   * @param {string|Object} name Name of the filter function, or an object map of filters where
-   *    the keys are the filter names and the values are the filter factories.
-   *
-   *    <div class="alert alert-warning">
-   *    **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
-   *    Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
-   *    your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
-   *    (`myapp_subsection_filterx`).
-   *    </div>
-   * @param {Function} factory If the first argument was a string, a factory function for the filter to be registered.
-   * @returns {Object} Registered filter instance, or if a map of filters was provided then a map
-   *    of the registered filter instances.
-   */
   function register(name, factory) {
     if (isObject(name)) {
       const filters = {};

package/src/core/filter.md

@@ -0,0 +1,126 @@
+/\*\*
+
+- @ngdoc provider
+- @name $filterProvider
+- @description
+-
+- Filters are just functions which transform input to an output. However filters need to be
+- Dependency Injected. To achieve this a filter definition consists of a factory function which is
+- annotated with dependencies and is responsible for creating a filter function.
+-
+- <div class="alert alert-warning">
+- **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
+- Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
+- your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
+- (`myapp_subsection_filterx`).
+- </div>
+-
+- ```js
+
+  ```
+- // Filter registration
+- function MyModule($provide, $filterProvider) {
+-     // create a service to demonstrate injection (not always needed)
+-     $provide.value('greet', function(name){
+-       return 'Hello ' + name + '!';
+-     });
+-
+-     // register a filter factory which uses the
+-     // greet service to demonstrate DI.
+-     $filterProvider.register('greet', function(greet){
+-       // return the filter function which uses the greet service
+-       // to generate salutation
+-       return function(text) {
+-         // filters need to be forgiving so check input validity
+-         return text && greet(text) || text;
+-       };
+-     });
+- }
+- ```
+
+  ```
+-
+- The filter function is registered with the `$injector` under the filter name suffix with
+- `Filter`.
+-
+- ```js
+
+  ```
+- it('should be the same instance', inject(
+-     function($filterProvider) {
+-       $filterProvider.register('reverse', function(){
+-         return ...;
+-       });
+-     },
+-     function($filter, reverseFilter) {
+-       expect($filter('reverse')).toBe(reverseFilter);
+-     });
+- ```
+
+  ```
+-
+-
+- For more information about how AngularJS filters work, and how to create your own filters, see
+- {@link guide/filter Filters} in the AngularJS Developer Guide.
+  \*/
+
+/\*\*
+
+- @ngdoc service
+- @name $filter
+- @kind function
+- @description
+- Filters are used for formatting data displayed to the user.
+-
+- They can be used in view templates, controllers or services. AngularJS comes
+- with a collection of [built-in filters](api/ng/filter), but it is easy to
+- define your own as well.
+-
+- The general syntax in templates is as follows:
+-
+- ```html
+
+  ```
+- {{ expression [| filter_name[:parameter_value] ... ] }}
+- ```
+
+  ```
+-
+- @param {String} name Name of the filter function to retrieve
+- @return {Function} the filter function
+- @example
+<example name="$filter" module="filterExample">
+<file name="index.html">
+<div ng-controller="MainCtrl">
+<h3>{{ originalText }}</h3>
+<h3>{{ filteredText }}</h3>
+</div>
+</file>
+
+   <file name="script.js">
+    angular.module('filterExample', [])
+    .controller('MainCtrl', function($scope, $filter) {
+      $scope.originalText = 'hello';
+      $scope.filteredText = $filter('uppercase')($scope.originalText);
+    });
+   </file>
+ </example>
+*/
+
+/\*\*
+
+- @ngdoc method
+- @name $filterProvider#register
+- @param {string|Object} name Name of the filter function, or an object map of filters where
+- the keys are the filter names and the values are the filter factories.
+-
+- <div class="alert alert-warning">
+- **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
+- Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
+- your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
+- (`myapp_subsection_filterx`).
+- </div>
+- @param {Function} factory If the first argument was a string, a factory function for the filter to be registered.
+- @returns {Object} Registered filter instance, or if a map of filters was provided then a map
+- of the registered filter instances.
+  \*/

package/src/core/interval.js

@@ -18,132 +18,6 @@ export function $IntervalProvider() {
         delete intervals[id];
       };
 
-      /**
-       * @ngdoc service
-       * @name $interval
-       *
-       * @description
-       * AngularJS's wrapper for `window.setInterval`. The `fn` function is executed every `delay`
-       * milliseconds.
-       *
-       * The return value of registering an interval function is a promise. This promise will be
-       * notified upon each tick of the interval, and will be resolved after `count` iterations, or
-       * run indefinitely if `count` is not defined. The value of the notification will be the
-       * number of iterations that have run.
-       * To cancel an interval, call `$interval.cancel(promise)`.
-       *
-       * In tests you can use {@link ngMock.$interval#flush `$interval.flush(millis)`} to
-       * move forward by `millis` milliseconds and trigger any functions scheduled to run in that
-       * time.
-       *
-       * <div class="alert alert-warning">
-       * **Note**: Intervals created by this service must be explicitly destroyed when you are finished
-       * with them.  In particular they are not automatically destroyed when a controller's scope or a
-       * directive's element are destroyed.
-       * You should take this into consideration and make sure to always cancel the interval at the
-       * appropriate moment.  See the example below for more details on how and when to do this.
-       * </div>
-       *
-       * @param {function()} fn A function that should be called repeatedly. If no additional arguments
-       *   are passed (see below), the function is called with the current iteration count.
-       * @param {number} delay Number of milliseconds between each function call.
-       * @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat
-       *   indefinitely.
-       * @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
-       *   will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
-       * @param {...*=} Pass additional parameters to the executed function.
-       * @returns {promise} A promise which will be notified on each iteration. It will resolve once all iterations of the interval complete.
-       *
-       * @example
-       * <example module="intervalExample" name="interval-service">
-       * <file name="index.html">
-       *   <script>
-       *     angular.module('intervalExample', [])
-       *       .controller('ExampleController', ['$scope', '$interval',
-       *         function($scope, $interval) {
-       *           $scope.format = 'M/d/yy h:mm:ss a';
-       *           $scope.blood_1 = 100;
-       *           $scope.blood_2 = 120;
-       *
-       *           let stop;
-       *           $scope.fight = function() {
-       *             // Don't start a new fight if we are already fighting
-       *             if ( angular.isDefined(stop) ) return;
-       *
-       *             stop = $interval(function() {
-       *               if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
-       *                 $scope.blood_1 = $scope.blood_1 - 3;
-       *                 $scope.blood_2 = $scope.blood_2 - 4;
-       *               } else {
-       *                 $scope.stopFight();
-       *               }
-       *             }, 100);
-       *           };
-       *
-       *           $scope.stopFight = function() {
-       *             if (angular.isDefined(stop)) {
-       *               $interval.cancel(stop);
-       *               stop = undefined;
-       *             }
-       *           };
-       *
-       *           $scope.resetFight = function() {
-       *             $scope.blood_1 = 100;
-       *             $scope.blood_2 = 120;
-       *           };
-       *
-       *           $scope.$on('$destroy', function() {
-       *             // Make sure that the interval is destroyed too
-       *             $scope.stopFight();
-       *           });
-       *         }])
-       *       // Register the 'myCurrentTime' directive factory method.
-       *       // We inject $interval and dateFilter service since the factory method is DI.
-       *       .directive('myCurrentTime', ['$interval', 'dateFilter',
-       *         function($interval, dateFilter) {
-       *           // return the directive link function. (compile function not needed)
-       *           return function(scope, element, attrs) {
-       *             let format,  // date format
-       *                 stopTime; // so that we can cancel the time updates
-       *
-       *             // used to update the UI
-       *             function updateTime() {
-       *               element.text(dateFilter(new Date(), format));
-       *             }
-       *
-       *             // watch the expression, and update the UI on change.
-       *             scope.$watch(attrs.myCurrentTime, function(value) {
-       *               format = value;
-       *               updateTime();
-       *             });
-       *
-       *             stopTime = $interval(updateTime, 1000);
-       *
-       *             // listen on DOM destroy (removal) event, and cancel the next UI update
-       *             // to prevent updating time after the DOM element was removed.
-       *             element.on('$destroy', function() {
-       *               $interval.cancel(stopTime);
-       *             });
-       *           }
-       *         }]);
-       *   </script>
-       *
-       *   <div>
-       *     <div ng-controller="ExampleController">
-       *       <label>Date format: <input ng-model="format"></label> <hr/>
-       *       Current time is: <span my-current-time="format"></span>
-       *       <hr/>
-       *       Blood 1 : <font color='red'>{{blood_1}}</font>
-       *       Blood 2 : <font color='red'>{{blood_2}}</font>
-       *       <button type="button" data-ng-click="fight()">Fight</button>
-       *       <button type="button" data-ng-click="stopFight()">StopFight</button>
-       *       <button type="button" data-ng-click="resetFight()">resetFight</button>
-       *     </div>
-       *   </div>
-       *
-       * </file>
-       * </example>
-       */
       const interval = $$intervalFactory(setIntervalFn, clearIntervalFn);
 
       /**

package/src/core/interval.md

@@ -0,0 +1,122 @@
+/**
+_ @ngdoc service
+_ @name $interval
+       *
+       * @description
+       * AngularJS's wrapper for `window.setInterval`. The `fn` function is executed every `delay`
+       * milliseconds.
+       *
+       * The return value of registering an interval function is a promise. This promise will be
+       * notified upon each tick of the interval, and will be resolved after `count` iterations, or
+       * run indefinitely if `count` is not defined. The value of the notification will be the
+       * number of iterations that have run.
+       * To cancel an interval, call `$interval.cancel(promise)`.
+       *
+       * In tests you can use {@link ngMock.$interval#flush `$interval.flush(millis)`} to
+       * move forward by `millis` milliseconds and trigger any functions scheduled to run in that
+_ time.
+_
+_ <div class="alert alert-warning">
+_ **Note\*_: Intervals created by this service must be explicitly destroyed when you are finished
+_ with them. In particular they are not automatically destroyed when a controller's scope or a
+_ directive's element are destroyed.
+_ You should take this into consideration and make sure to always cancel the interval at the
+_ appropriate moment. See the example below for more details on how and when to do this.
+_ </div> \*
+_ @param {function()} fn A function that should be called repeatedly. If no additional arguments
+_ are passed (see below), the function is called with the current iteration count.
+_ @param {number} delay Number of milliseconds between each function call.
+_ @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat
+_ indefinitely.
+_ @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
+_ will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
+_ @param {..._=} Pass additional parameters to the executed function.
+_ @returns {promise} A promise which will be notified on each iteration. It will resolve once all iterations of the interval complete. \*
+_ @example
+_ <example module="intervalExample" name="interval-service">
+_ <file name="index.html">
+_ <script>
+_ angular.module('intervalExample', [])
+_ .controller('ExampleController', ['$scope', '$interval',
+* function($scope, $interval) {
+* $scope.format = 'M/d/yy h:mm:ss a';
+* $scope.blood_1 = 100;
+* $scope.blood_2 = 120;
+*
+* let stop;
+* $scope.fight = function() {
+* // Don't start a new fight if we are already fighting
+* if ( angular.isDefined(stop) ) return;
+*
+* stop = $interval(function() {
+* if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
+* $scope.blood_1 = $scope.blood_1 - 3;
+* $scope.blood_2 = $scope.blood_2 - 4;
+* } else {
+* $scope.stopFight();
+* }
+* }, 100);
+* };
+*
+* $scope.stopFight = function() {
+* if (angular.isDefined(stop)) {
+* $interval.cancel(stop);
+* stop = undefined;
+* }
+* };
+*
+* $scope.resetFight = function() {
+* $scope.blood_1 = 100;
+* $scope.blood_2 = 120;
+* };
+*
+* $scope.$on('$destroy', function() {
+* // Make sure that the interval is destroyed too
+* $scope.stopFight();
+* });
+* }])
+_ // Register the 'myCurrentTime' directive factory method.
+_ // We inject $interval and dateFilter service since the factory method is DI.
+       *       .directive('myCurrentTime', ['$interval', 'dateFilter',
+_ function($interval, dateFilter) {
+_ // return the directive link function. (compile function not needed)
+_ return function(scope, element, attrs) {
+_ let format, // date format
+_ stopTime; // so that we can cancel the time updates
+_
+_ // used to update the UI
+_ function updateTime() {
+_ element.text(dateFilter(new Date(), format));
+_ } \*
+_ // watch the expression, and update the UI on change.
+_ scope.$watch(attrs.myCurrentTime, function(value) {
+       *               format = value;
+       *               updateTime();
+       *             });
+       *
+       *             stopTime = $interval(updateTime, 1000);
+       *
+       *             // listen on DOM destroy (removal) event, and cancel the next UI update
+       *             // to prevent updating time after the DOM element was removed.
+       *             element.on('$destroy', function() {
+_ $interval.cancel(stopTime);
+_ });
+_ }
+_ }]);
+_ </script>
+_
+_ <div>
+_ <div ng-controller="ExampleController">
+_ <label>Date format: <input ng-model="format"></label> <hr/>
+_ Current time is: <span my-current-time="format"></span>
+_ <hr/>
+_ Blood 1 : <font color='red'>{{blood_1}}</font>
+_ Blood 2 : <font color='red'>{{blood_2}}</font>
+_ <button type="button" data-ng-click="fight()">Fight</button>
+_ <button type="button" data-ng-click="stopFight()">StopFight</button>
+_ <button type="button" data-ng-click="resetFight()">resetFight</button>
+_ </div>
+_ </div> \*
+_ </file>
+_ </example>
+\*/

package/src/core/location.js

@@ -10,7 +10,6 @@ import {
   isString,
   isUndefined,
   minErr,
-  nodeName_,
   parseKeyValue,
   toInt,
   toKeyValue,
@@ -932,7 +931,7 @@ export function $LocationProvider() {
         let elm = jqLite(event.target);
 
         // traverse the DOM up to find first A tag
-        while (nodeName_(elm[0]) !== "a") {
+        while (elm[0].nodeName.toLowerCase() !== "a") {
           // ignore rewriting if no A tag (reached root element, or no parent - removed from document)
           if (elm[0] === $rootElement[0] || !(elm = elm.parent())[0]) return;
         }