@angular-wave/angular.ts 0.0.1

package/src/services/httpBackend.js

@@ -0,0 +1,206 @@
+import { urlResolve } from "../core/urlUtils";
+import { forEach, isDefined, isPromiseLike, isUndefined } from "../core/utils";
+
+/**
+ * @ngdoc service
+ * @name $xhrFactory
+ *
+ *
+ * @description
+ * Factory function used to create XMLHttpRequest objects.
+ *
+ * Replace or decorate this service to create your own custom XMLHttpRequest objects.
+ *
+ * ```
+ * angular.module('myApp', [])
+ * .factory('$xhrFactory', function() {
+ *   return function createXhr(method, url) {
+ *     return new window.XMLHttpRequest({mozSystem: true});
+ *   };
+ * });
+ * ```
+ *
+ * @param {string} method HTTP method of the request (GET, POST, PUT, ..)
+ * @param {string} url URL of the request.
+ */
+export function $xhrFactoryProvider() {
+  this.$get = () => {
+    return function createXhr() {
+      return new window.XMLHttpRequest();
+    };
+  };
+}
+
+/**
+ * @ngdoc service
+ * @name $httpBackend
+ * @requires $document
+ * @requires $xhrFactory
+ *
+ *
+ * @description
+ * HTTP backend used by the {@link ng.$http service} that delegates to
+ * XMLHttpRequest object and deals with browser incompatibilities.
+ *
+ * You should never need to use this service directly, instead use the higher-level abstractions:
+ * {@link ng.$http $http}.
+ *
+ */
+export function $HttpBackendProvider() {
+  this.$get = [
+    "$browser",
+    "$xhrFactory",
+    function ($browser, $xhrFactory) {
+      return createHttpBackend($browser, $xhrFactory, $browser.defer);
+    },
+  ];
+}
+
+export function createHttpBackend($browser, createXhr, $browserDefer) {
+  // TODO(vojta): fix the signature
+  return function (
+    method,
+    url,
+    post,
+    callback,
+    headers,
+    timeout,
+    withCredentials,
+    responseType,
+    eventHandlers,
+    uploadEventHandlers,
+  ) {
+    url = url || $browser.url();
+
+    let xhr = createXhr(method, url);
+    let abortedByTimeout = false;
+
+    xhr.open(method, url, true);
+    forEach(headers, (value, key) => {
+      if (isDefined(value)) {
+        xhr.setRequestHeader(key, value);
+      }
+    });
+
+    xhr.onload = function () {
+      const statusText = xhr.statusText || "";
+
+      // responseText is the old-school way of retrieving response (supported by IE9)
+      // response/responseType properties were introduced in XHR Level2 spec (supported by IE10)
+      const response = "response" in xhr ? xhr.response : xhr.responseText;
+
+      let status = xhr.status;
+
+      // fix status code when it is 0 (0 status is undocumented).
+      // Occurs when accessing file resources or on Android 4.1 stock browser
+      // while retrieving files from application cache.
+      if (status === 0) {
+        status = response ? 200 : urlResolve(url).protocol === "file" ? 404 : 0;
+      }
+
+      completeRequest(
+        callback,
+        status,
+        response,
+        xhr.getAllResponseHeaders(),
+        statusText,
+        "complete",
+      );
+    };
+
+    xhr.onerror = function () {
+      // The response is always empty
+      // See https://xhr.spec.whatwg.org/#request-error-steps and https://fetch.spec.whatwg.org/#concept-network-error
+      completeRequest(callback, -1, null, null, "", "error");
+    };
+    xhr.ontimeout = function () {
+      // The response is always empty
+      // See https://xhr.spec.whatwg.org/#request-error-steps and https://fetch.spec.whatwg.org/#concept-network-error
+      completeRequest(callback, -1, null, null, "", "timeout");
+    };
+
+    xhr.onabort = function () {
+      completeRequest(
+        callback,
+        -1,
+        null,
+        null,
+        "",
+        abortedByTimeout ? "timeout" : "abort",
+      );
+    };
+
+    forEach(eventHandlers, (value, key) => {
+      xhr.addEventListener(key, value);
+    });
+
+    forEach(uploadEventHandlers, (value, key) => {
+      xhr.upload.addEventListener(key, value);
+    });
+
+    if (withCredentials) {
+      xhr.withCredentials = true;
+    }
+
+    if (responseType) {
+      try {
+        xhr.responseType = responseType;
+      } catch (e) {
+        // WebKit added support for the json responseType value on 09/03/2013
+        // https://bugs.webkit.org/show_bug.cgi?id=73648. Versions of Safari prior to 7 are
+        // known to throw when setting the value "json" as the response type. Other older
+        // browsers implementing the responseType
+        //
+        // The json response type can be ignored if not supported, because JSON payloads are
+        // parsed on the client-side regardless.
+        if (responseType !== "json") {
+          throw e;
+        }
+      }
+    }
+
+    xhr.send(isUndefined(post) ? null : post);
+
+    // Since we are using xhr.abort() when a request times out, we have to set a flag that
+    // indicates to requestAborted if the request timed out or was aborted.
+    //
+    // http.timeout = numerical timeout   timeout
+    // http.timeout = $timeout            timeout
+    // http.timeout = promise             abort
+    // xhr.abort()                        abort (The xhr object is normally inaccessible, but
+    //                                    can be exposed with the xhrFactory)
+    if (timeout > 0) {
+      var timeoutId = $browserDefer(() => {
+        timeoutRequest("timeout");
+      }, timeout);
+    } else if (isPromiseLike(timeout)) {
+      timeout.then(() => {
+        timeoutRequest(isDefined(timeout.$$timeoutId) ? "timeout" : "abort");
+      });
+    }
+
+    function timeoutRequest(reason) {
+      abortedByTimeout = reason === "timeout";
+      if (xhr) {
+        xhr.abort();
+      }
+    }
+
+    function completeRequest(
+      callback,
+      status,
+      response,
+      headersString,
+      statusText,
+      xhrStatus,
+    ) {
+      // cancel timeout and subsequent timeout promise resolution
+      if (isDefined(timeoutId)) {
+        $browserDefer.cancel(timeoutId);
+      }
+      xhr = null;
+
+      callback(status, response, headersString, statusText, xhrStatus);
+    }
+  };
+}

package/src/services/log.js

@@ -0,0 +1,160 @@
+/**
+ * @ngdoc service
+ * @name $log
+ *
+ * @description
+ * Simple service for logging. Default implementation safely writes the message
+ * into the browser's console (if present).
+ *
+ * The main purpose of this service is to simplify debugging and troubleshooting.
+ *
+ * To reveal the location of the calls to `$log` in the JavaScript console,
+ * you can "blackbox" the AngularJS source in your browser:
+ *
+ * [Mozilla description of blackboxing](https://developer.mozilla.org/en-US/docs/Tools/Debugger/How_to/Black_box_a_source).
+ * [Chrome description of blackboxing](https://developer.chrome.com/devtools/docs/blackboxing).
+ *
+ * Note: Not all browsers support blackboxing.
+ *
+ * The default is to log `debug` messages. You can use
+ * {@link ng.$logProvider ng.$logProvider#debugEnabled} to change this.
+ *
+ * @example
+   <example module="logExample" name="log-service">
+     <file name="script.js">
+       angular.module('logExample', [])
+         .controller('LogController', ['$scope', '$log', function($scope, $log) {
+           $scope.$log = $log;
+           $scope.message = 'Hello World!';
+         }]);
+     </file>
+     <file name="index.html">
+       <div ng-controller="LogController">
+         <p>Reload this page with open console, enter text and hit the log button...</p>
+         <label>Message:
+         <input type="text" ng-model="message" /></label>
+         <button ng-click="$log.log(message)">log</button>
+         <button ng-click="$log.warn(message)">warn</button>
+         <button ng-click="$log.info(message)">info</button>
+         <button ng-click="$log.error(message)">error</button>
+         <button ng-click="$log.debug(message)">debug</button>
+       </div>
+     </file>
+   </example>
+ */
+
+import { forEach, isDefined, isError } from "../core/utils";
+
+/**
+ * @ngdoc provider
+ * @name $logProvider
+ * @type {ng.ILogProvider}
+ *
+ * @description
+ * Use the `$logProvider` to configure how the application logs messages
+ */
+export function $LogProvider() {
+  let debug = true;
+  const self = this;
+
+  /**
+   * @ngdoc method
+   * @name $logProvider#debugEnabled
+   * @description
+   * @param {boolean=} flag enable or disable debug level messages
+   * @returns {*} current value if used as getter or itself (chaining) if used as setter
+   */
+  this.debugEnabled = function (flag) {
+    if (isDefined(flag)) {
+      debug = flag;
+      return this;
+    }
+    return debug;
+  };
+
+  function formatError(arg) {
+    if (isError(arg)) {
+      if (arg.stack) {
+        arg =
+          arg.message && arg.stack.indexOf(arg.message) === -1
+            ? `Error: ${arg.message}\n${arg.stack}`
+            : arg.stack;
+      } else if (arg.sourceURL) {
+        arg = `${arg.message}\n${arg.sourceURL}:${arg.line}`;
+      }
+    }
+    return arg;
+  }
+
+  function consoleLog(type) {
+    const console = window.console || {};
+    const logFn = console[type] || console.log || (() => {});
+
+    return function () {
+      var args = [];
+      forEach(arguments, function (arg) {
+        args.push(formatError(arg));
+      });
+      return logFn.apply(console, args);
+    };
+  }
+
+  this.$get = [
+    function () {
+      return {
+        /**
+         * @ngdoc method
+         * @name $log#log
+         *
+         * @description
+         * Write a log message
+         */
+        log: consoleLog("log"),
+
+        /**
+         * @ngdoc method
+         * @name $log#info
+         *
+         * @description
+         * Write an information message
+         */
+        info: consoleLog("info"),
+
+        /**
+         * @ngdoc method
+         * @name $log#warn
+         *
+         * @description
+         * Write a warning message
+         */
+        warn: consoleLog("warn"),
+
+        /**
+         * @ngdoc method
+         * @name $log#error
+         *
+         * @description
+         * Write an error message
+         */
+        error: consoleLog("error"),
+
+        /**
+         * @ngdoc method
+         * @name $log#debug
+         *
+         * @description
+         * Write a debug message
+         */
+        debug: (function () {
+          const fn = consoleLog("debug");
+
+          return function () {
+            if (debug) {
+              fn.apply(self, arguments);
+            }
+          };
+        })(),
+      };
+    },
+  ];
+}

package/src/services/templateRequest.js

@@ -0,0 +1,139 @@
+import { defaultHttpResponseTransform } from "./http";
+import { extend, isArray, isString, isUndefined, minErr } from "../core/utils";
+
+var $templateRequestMinErr = minErr("$templateRequest");
+
+/**
+ * @ngdoc provider
+ * @name $templateRequestProvider
+ * @this
+ *
+ * @description
+ * Used to configure the options passed to the {@link $http} service when making a template request.
+ *
+ * For example, it can be used for specifying the "Accept" header that is sent to the server, when
+ * requesting a template.
+ */
+export function TemplateRequestProvider() {
+  var httpOptions;
+
+  /**
+   * @ngdoc method
+   * @name $templateRequestProvider#httpOptions
+   * @description
+   * The options to be passed to the {@link $http} service when making the request.
+   * You can use this to override options such as the "Accept" header for template requests.
+   *
+   * The {@link $templateRequest} will set the `cache` and the `transformResponse` properties of the
+   * options if not overridden here.
+   *
+   * @param {string=} value new value for the {@link $http} options.
+   * @returns {string|self} Returns the {@link $http} options when used as getter and self if used as setter.
+   */
+  this.httpOptions = function (val) {
+    if (val) {
+      httpOptions = val;
+      return this;
+    }
+    return httpOptions;
+  };
+
+  /**
+   * @ngdoc service
+   * @name $templateRequest
+   *
+   * @description
+   * The `$templateRequest` service runs security checks then downloads the provided template using
+   * `$http` and, upon success, stores the contents inside of `$templateCache`. If the HTTP request
+   * fails or the response data of the HTTP request is empty, a `$compile` error will be thrown (the
+   * exception can be thwarted by setting the 2nd parameter of the function to true). Note that the
+   * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted
+   * when `tpl` is of type string and `$templateCache` has the matching entry.
+   *
+   * If you want to pass custom options to the `$http` service, such as setting the Accept header you
+   * can configure this via {@link $templateRequestProvider#httpOptions}.
+   *
+   * `$templateRequest` is used internally by {@link $compile}, {@link ngRoute.$route}, and directives such
+   * as {@link ngInclude} to download and cache templates.
+   *
+   * 3rd party modules should use `$templateRequest` if their services or directives are loading
+   * templates.
+   *
+   * @param {string|TrustedResourceUrl} tpl The HTTP request template URL
+   * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
+   *
+   * @return {Promise} a promise for the HTTP response data of the given URL.
+   *
+   * @property {number} totalPendingRequests total amount of pending template requests being downloaded.
+   */
+  this.$get = [
+    "$exceptionHandler",
+    "$templateCache",
+    "$http",
+    "$q",
+    "$sce",
+    function ($exceptionHandler, $templateCache, $http, $q, $sce) {
+      function handleRequestFn(tpl, ignoreRequestError) {
+        handleRequestFn.totalPendingRequests++;
+
+        // We consider the template cache holds only trusted templates, so
+        // there's no need to go through adding the template again to the trusted
+        // resources for keys that already are included in there. This also makes
+        // AngularJS accept any script directive, no matter its name. However, we
+        // still need to unwrap trusted types.
+        if (!isString(tpl) || isUndefined($templateCache.get(tpl))) {
+          tpl = $sce.getTrustedResourceUrl(tpl);
+        }
+
+        var transformResponse =
+          $http.defaults && $http.defaults.transformResponse;
+
+        if (isArray(transformResponse)) {
+          transformResponse = transformResponse.filter(function (transformer) {
+            return transformer !== defaultHttpResponseTransform;
+          });
+        } else if (transformResponse === defaultHttpResponseTransform) {
+          transformResponse = null;
+        }
+
+        return $http
+          .get(
+            tpl,
+            extend(
+              {
+                cache: $templateCache,
+                transformResponse: transformResponse,
+              },
+              httpOptions,
+            ),
+          )
+          .finally(function () {
+            handleRequestFn.totalPendingRequests--;
+          })
+          .then(function (response) {
+            return $templateCache.put(tpl, response.data);
+          }, handleError);
+
+        function handleError(resp) {
+          if (!ignoreRequestError) {
+            resp = $templateRequestMinErr(
+              "tpload",
+              "Failed to load template: {0} (HTTP status: {1} {2})",
+              tpl,
+              resp.status,
+              resp.statusText,
+            );
+
+            $exceptionHandler(resp);
+          }
+
+          return $q.reject(resp);
+        }
+      }
+
+      handleRequestFn.totalPendingRequests = 0;
+
+      return handleRequestFn;
+    },
+  ];
+}