@angular-wave/angular.ts 0.0.1

package/src/core/controller.js

@@ -0,0 +1,225 @@
+import {
+  assertArgFn,
+  assertNotHasOwnProperty,
+  minErr,
+  extend,
+  isArray,
+  isObject,
+  isString,
+  getter,
+  isFunction,
+} from "./utils";
+
+const $controllerMinErr = minErr("$controller");
+
+const CNTRL_REG = /^(\S+)(\s+as\s+([\w$]+))?$/;
+export function identifierForController(controller, ident) {
+  if (ident && isString(ident)) return ident;
+  if (isString(controller)) {
+    const match = CNTRL_REG.exec(controller);
+    if (match) return match[3];
+  }
+}
+
+/**
+ * @ngdoc provider
+ * @name $controllerProvider
+ *
+ *
+ * @description
+ * The {@link ng.$controller $controller service} is used by AngularJS to create new
+ * controllers.
+ *
+ * This provider allows controller registration via the
+ * {@link ng.$controllerProvider#register register} method.
+ */
+export function $ControllerProvider() {
+  const controllers = {};
+
+  /**
+   * @ngdoc method
+   * @name $controllerProvider#has
+   * @param {string} name Controller name to check.
+   */
+  this.has = function (name) {
+    return Object.prototype.hasOwnProperty.call(controllers, name);
+  };
+
+  /**
+   * @ngdoc method
+   * @name $controllerProvider#register
+   * @param {string|Object} name Controller name, or an object map of controllers where the keys are
+   *    the names and the values are the constructors.
+   * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
+   *    annotations in the array notation).
+   */
+  this.register = function (name, constructor) {
+    assertNotHasOwnProperty(name, "controller");
+    if (isObject(name)) {
+      extend(controllers, name);
+    } else {
+      controllers[name] = constructor;
+    }
+  };
+
+  this.$get = [
+    "$injector",
+    function ($injector) {
+      /**
+       * @ngdoc service
+       * @name $controller
+       * @requires $injector
+       *
+       * @param {Function|string} expression If called with a function then it's considered to be the
+       *    controller constructor function. Otherwise it's considered to be a string which is used
+       *    to retrieve the controller constructor using the following steps:
+       *
+       *    * check if a controller with given name is registered via `$controllerProvider`
+       *    * check if evaluating the string on the current scope returns a constructor
+       *
+       *    The string can use the `controller as property` syntax, where the controller instance is published
+       *    as the specified property on the `scope`; the `scope` must be injected into `locals` param for this
+       *    to work correctly.
+       *
+       * @param {Object} locals Injection locals for Controller.
+       * @return {Object} Instance of given controller.
+       *
+       * @description
+       * `$controller` service is responsible for instantiating controllers.
+       *
+       * It's just a simple call to {@link auto.$injector $injector}, but extracted into
+       * a service, so that one can override this service with [BC version](https://gist.github.com/1649788).
+       */
+      return function $controller(expression, locals, later, ident) {
+        // PRIVATE API:
+        //   param `later` --- indicates that the controller's constructor is invoked at a later time.
+        //                     If true, $controller will allocate the object with the correct
+        //                     prototype chain, but will not invoke the controller until a returned
+        //                     callback is invoked.
+        //   param `ident` --- An optional label which overrides the label parsed from the controller
+        //                     expression, if any.
+        let instance;
+        let match;
+        let constructor;
+        let identifier;
+        later = later === true;
+        if (ident && isString(ident)) {
+          identifier = ident;
+        }
+
+        if (isString(expression)) {
+          match = /** @type {string} */ (expression).match(CNTRL_REG);
+          if (!match) {
+            throw $controllerMinErr(
+              "ctrlfmt",
+              "Badly formed controller string '{0}'. " +
+                "Must match `__name__ as __id__` or `__name__`.",
+              expression,
+            );
+          }
+          constructor = match[1];
+          identifier = identifier || match[3];
+          expression = Object.prototype.hasOwnProperty.call(
+            controllers,
+            constructor,
+          )
+            ? controllers[constructor]
+            : getter(locals.$scope, constructor, true);
+
+          if (!expression) {
+            throw $controllerMinErr(
+              "ctrlreg",
+              "The controller with the name '{0}' is not registered.",
+              constructor,
+            );
+          }
+
+          assertArgFn(expression, constructor, true);
+        }
+
+        if (later) {
+          // Instantiate controller later:
+          // This machinery is used to create an instance of the object before calling the
+          // controller's constructor itself.
+          //
+          // This allows properties to be added to the controller before the constructor is
+          // invoked. Primarily, this is used for isolate scope bindings in $compile.
+          //
+          // This feature is not intended for use by applications, and is thus not documented
+          // publicly.
+          // Object creation: http://jsperf.com/create-constructor/2
+          const controllerPrototype = (
+            isArray(expression) ? expression[expression.length - 1] : expression
+          ).prototype;
+          instance = Object.create(controllerPrototype || null);
+
+          if (identifier) {
+            addIdentifier(
+              locals,
+              identifier,
+              instance,
+              constructor || expression.name,
+            );
+          }
+
+          return extend(
+            () => {
+              const result = $injector.invoke(
+                expression,
+                instance,
+                locals,
+                constructor,
+              );
+              if (
+                result !== instance &&
+                (isObject(result) || isFunction(result))
+              ) {
+                instance = result;
+                if (identifier) {
+                  // If result changed, re-assign controllerAs value to scope.
+                  addIdentifier(
+                    locals,
+                    identifier,
+                    instance,
+                    constructor || expression.name,
+                  );
+                }
+              }
+              return instance;
+            },
+            {
+              instance,
+              identifier,
+            },
+          );
+        }
+
+        instance = $injector.instantiate(expression, locals, constructor);
+
+        if (identifier) {
+          addIdentifier(
+            locals,
+            identifier,
+            instance,
+            constructor || expression.name,
+          );
+        }
+
+        return instance;
+      };
+
+      function addIdentifier(locals, identifier, instance, name) {
+        if (!(locals && isObject(locals.$scope))) {
+          throw minErr("$controller")(
+            "noscp",
+            "Cannot export controller '{0}' as '{1}'! No $scope object provided via `locals`.",
+            name,
+            identifier,
+          );
+        }
+
+        locals.$scope[identifier] = instance;
+      }
+    },
+  ];
+}

package/src/core/exceptionHandler.js

@@ -0,0 +1,63 @@
+/* eslint-disable no-use-before-define */
+/**
+ * @ngdoc service
+ * @name $exceptionHandler
+ * @requires ng.$log
+ *
+ *
+ * @description
+ * Any uncaught exception in AngularJS expressions is delegated to this service.
+ * The default implementation simply delegates to `$log.error` which logs it into
+ * the browser console.
+ *
+ *
+ * ## Example:
+ *
+ * The example below will overwrite the default `$exceptionHandler` in order to (a) log uncaught
+ * errors to the backend for later inspection by the developers and (b) to use `$log.warn()` instead
+ * of `$log.error()`.
+ *
+ * ```js
+ *   angular.
+ *     module('exceptionOverwrite', []).
+ *     factory('$exceptionHandler', ['$log', 'logErrorsToBackend', function($log, logErrorsToBackend) {
+ *       return function myExceptionHandler(exception, cause) {
+ *         logErrorsToBackend(exception, cause);
+ *         $log.warn(exception, cause);
+ *       };
+ *     }]);
+ * ```
+ *
+ * <hr />
+ * Note, that code executed in event-listeners (even those registered using jqLite's `on`/`bind`
+ * methods) does not delegate exceptions to the {@link ng.$exceptionHandler $exceptionHandler}
+ * (unless executed during a digest).
+ *
+ * If you wish, you can manually delegate exceptions, e.g.
+ * `try { ... } catch(e) { $exceptionHandler(e); }`
+ *
+ * @param {Error} exception Exception associated with the error.
+ * @param {string=} cause Optional information about the context in which
+ *       the error was thrown.
+ *
+ */
+export function $ExceptionHandlerProvider() {
+  this.$get = [
+    "$log",
+    function ($log) {
+      return function () {
+        $log.error.apply($log, arguments);
+      };
+    },
+  ];
+}
+
+// let $log;
+
+// export function ExceptionHandler(log) {
+//   $log = log || window.console;
+
+//   return function(exception, cause) {
+//     $log.error.apply($log, arguments);
+//   };
+// }

package/src/core/filter.js

@@ -0,0 +1,146 @@
+import { forEach, isObject } from "./utils";
+import { filterFilter } from "../filters/filter";
+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 = {};
+      forEach(name, (filter, key) => {
+        filters[key] = register(key, filter);
+      });
+      return filters;
+    }
+    return $provide.factory(name + suffix, factory);
+  }
+  this.register = register;
+
+  this.$get = [
+    "$injector",
+    function ($injector) {
+      return function (name) {
+        return $injector.get(name + suffix);
+      };
+    },
+  ];
+
+  register("filter", filterFilter);
+  register("json", jsonFilter);
+  register("limitTo", limitToFilter);
+  register("orderBy", orderByFilter);
+}