@angular-wave/angular.ts 0.0.6 → 0.0.8

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,132 @@
+/\*\*
+
+- @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,123 @@
+/**
+_ @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;
         }

package/src/core/sce.js

@@ -5,7 +5,6 @@ import {
 } from "./urlUtils";
 import {
   forEach,
-  isDefined,
   isFunction,
   isRegExp,
   isString,
@@ -88,16 +87,6 @@ export function adjustMatcher(matcher) {
   );
 }
 
-function adjustMatchers(matchers) {
-  const adjustedMatchers = [];
-  if (isDefined(matchers)) {
-    forEach(matchers, (matcher) => {
-      adjustedMatchers.push(adjustMatcher(matcher));
-    });
-  }
-  return adjustedMatchers;
-}
-
 /**
  * @ngdoc service
  * @name $sceDelegate
@@ -222,7 +211,7 @@ export function $SceDelegateProvider() {
    */
   this.trustedResourceUrlList = function (value) {
     if (arguments.length) {
-      trustedResourceUrlList = adjustMatchers(value);
+      trustedResourceUrlList = value.map((v) => adjustMatcher(v));
     }
     return trustedResourceUrlList;
   };
@@ -254,7 +243,7 @@ export function $SceDelegateProvider() {
    */
   this.bannedResourceUrlList = function (value) {
     if (arguments.length) {
-      bannedResourceUrlList = adjustMatchers(value);
+      bannedResourceUrlList = value.map((v) => adjustMatcher(v));
     }
     return bannedResourceUrlList;
   };