@angular-wave/angular.ts 0.0.1

package/src/core/taskTrackerFactory.js

@@ -0,0 +1,125 @@
+import { valueFn } from "./utils";
+
+/**
+ * ! This is a private undocumented service !
+ *
+ * @name $$taskTrackerFactory
+ * @description
+ * A function to create `TaskTracker` instances.
+ *
+ * A `TaskTracker` can keep track of pending tasks (grouped by type) and can notify interested
+ * parties when all pending tasks (or tasks of a specific type) have been completed.
+ *
+ * @param {$log} log - A logger instance (such as `$log`). Used to log error during callback
+ *     execution.
+ *
+ *
+ */
+export function $$TaskTrackerFactoryProvider() {
+  // eslint-disable-next-line no-use-before-define
+  this.$get = valueFn((log) => new TaskTracker(log));
+}
+
+export function TaskTracker(log) {
+  const self = this;
+  const taskCounts = {};
+  const taskCallbacks = [];
+
+  const ALL_TASKS_TYPE = (self.ALL_TASKS_TYPE = "$$all$$");
+  const DEFAULT_TASK_TYPE = (self.DEFAULT_TASK_TYPE = "$$default$$");
+
+  /**
+   * Execute the specified function and decrement the appropriate `taskCounts` counter.
+   * If the counter reaches 0, all corresponding `taskCallbacks` are executed.
+   *
+   * @param {Function} fn - The function to execute.
+   * @param {string=} [taskType=DEFAULT_TASK_TYPE] - The type of task that is being completed.
+   */
+  self.completeTask = completeTask;
+
+  /**
+   * Increase the task count for the specified task type (or the default task type if non is
+   * specified).
+   *
+   * @param {string=} [taskType=DEFAULT_TASK_TYPE] - The type of task whose count will be increased.
+   */
+  self.incTaskCount = incTaskCount;
+
+  /**
+   * Execute the specified callback when all pending tasks have been completed.
+   *
+   * If there are no pending tasks, the callback is executed immediately. You can optionally limit
+   * the tasks that will be waited for to a specific type, by passing a `taskType`.
+   *
+   * @param {function} callback - The function to call when there are no pending tasks.
+   * @param {string=} [taskType=ALL_TASKS_TYPE] - The type of tasks that will be waited for.
+   */
+  self.notifyWhenNoPendingTasks = notifyWhenNoPendingTasks;
+
+  function completeTask(fn, taskType) {
+    taskType = taskType || DEFAULT_TASK_TYPE;
+
+    try {
+      fn();
+    } finally {
+      decTaskCount(taskType);
+
+      const countForType = taskCounts[taskType];
+      const countForAll = taskCounts[ALL_TASKS_TYPE];
+
+      // If at least one of the queues (`ALL_TASKS_TYPE` or `taskType`) is empty, run callbacks.
+      if (!countForAll || !countForType) {
+        const getNextCallback = !countForAll
+          ? getLastCallback
+          : getLastCallbackForType;
+        let nextCb;
+
+        while ((nextCb = getNextCallback(taskType))) {
+          try {
+            nextCb();
+          } catch (e) {
+            log.error(e);
+          }
+        }
+      }
+    }
+  }
+
+  function decTaskCount(taskType) {
+    taskType = taskType || DEFAULT_TASK_TYPE;
+    if (taskCounts[taskType]) {
+      taskCounts[taskType]--;
+      taskCounts[ALL_TASKS_TYPE]--;
+    }
+  }
+
+  function getLastCallback() {
+    const cbInfo = taskCallbacks.pop();
+    return cbInfo && cbInfo.cb;
+  }
+
+  function getLastCallbackForType(taskType) {
+    for (let i = taskCallbacks.length - 1; i >= 0; --i) {
+      const cbInfo = taskCallbacks[i];
+      if (cbInfo.type === taskType) {
+        taskCallbacks.splice(i, 1);
+        return cbInfo.cb;
+      }
+    }
+  }
+
+  function incTaskCount(taskType) {
+    taskType = taskType || DEFAULT_TASK_TYPE;
+    taskCounts[taskType] = (taskCounts[taskType] || 0) + 1;
+    taskCounts[ALL_TASKS_TYPE] = (taskCounts[ALL_TASKS_TYPE] || 0) + 1;
+  }
+
+  function notifyWhenNoPendingTasks(callback, taskType) {
+    taskType = taskType || ALL_TASKS_TYPE;
+    if (!taskCounts[taskType]) {
+      callback();
+    } else {
+      taskCallbacks.push({ type: taskType, cb: callback });
+    }
+  }
+}

package/src/core/timeout.js

@@ -0,0 +1,121 @@
+import { markQExceptionHandled } from "./q";
+import { isDefined, isFunction, minErr, sliceArgs } from "./utils";
+
+const $timeoutMinErr = minErr("$timeout");
+
+export function $timeout($rootScope, $browser, $q, $$q, $exceptionHandler) {
+  const deferreds = {};
+
+  /**
+   * @ngdoc service
+   * @name $timeout
+   *
+   * @description
+   * AngularJS's wrapper for `window.setTimeout`. The `fn` function is wrapped into a try/catch
+   * block and delegates any exceptions to
+   * {@link ng.$exceptionHandler $exceptionHandler} service.
+   *
+   * The return value of calling `$timeout` is a promise, which will be resolved when
+   * the delay has passed and the timeout function, if provided, is executed.
+   *
+   * To cancel a timeout request, call `$timeout.cancel(promise)`.
+   *
+   * In tests you can use {@link ngMock.$timeout `$timeout.flush()`} to
+   * synchronously flush the queue of deferred functions.
+   *
+   * If you only want a promise that will be resolved after some specified delay
+   * then you can call `$timeout` without the `fn` function.
+   *
+   * @param {function()=} fn A function, whose execution should be delayed.
+   * @param {number=} [delay=0] Delay in milliseconds.
+   * @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} Promise that will be resolved when the timeout is reached. The promise
+   *   will be resolved with the return value of the `fn` function.
+   *
+   */
+  function timeout(fn, delay, invokeApply) {
+    if (!isFunction(fn)) {
+      invokeApply = delay;
+      delay = fn;
+      fn = () => {};
+    }
+
+    const args = sliceArgs(arguments, 3);
+    const skipApply = isDefined(invokeApply) && !invokeApply;
+    const deferred = (skipApply ? $$q : $q).defer();
+    const { promise } = deferred;
+    let timeoutId;
+
+    timeoutId = $browser.defer(
+      () => {
+        try {
+          deferred.resolve(fn.apply(null, args));
+        } catch (e) {
+          deferred.reject(e);
+          $exceptionHandler(e);
+        } finally {
+          delete deferreds[promise.$$timeoutId];
+        }
+
+        if (!skipApply) $rootScope.$apply();
+      },
+      delay,
+      "$timeout",
+    );
+
+    promise.$$timeoutId = timeoutId;
+    deferreds[timeoutId] = deferred;
+
+    return promise;
+  }
+
+  /**
+   * @ngdoc method
+   * @name $timeout#cancel
+   *
+   * @description
+   * Cancels a task associated with the `promise`. As a result of this, the promise will be
+   * resolved with a rejection.
+   *
+   * @param {Promise=} promise Promise returned by the `$timeout` function.
+   * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
+   *   canceled.
+   */
+  timeout.cancel = function (promise) {
+    if (!promise) return false;
+
+    if (!Object.prototype.hasOwnProperty.call(promise, "$$timeoutId")) {
+      throw $timeoutMinErr(
+        "badprom",
+        "`$timeout.cancel()` called with a promise that was not generated by `$timeout()`.",
+      );
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(deferreds, promise.$$timeoutId))
+      return false;
+    const id = promise.$$timeoutId;
+    const deferred = deferreds[id];
+
+    // Timeout cancels should not report an unhandled promise.
+    markQExceptionHandled(deferred.promise);
+    deferred.reject("canceled");
+    delete deferreds[id];
+
+    return $browser.defer.cancel(id);
+  };
+
+  return timeout;
+}
+
+export function $TimeoutProvider() {
+  this.$get = [
+    "$rootScope",
+    "$browser",
+    "$q",
+    "$$q",
+    "$exceptionHandler",
+    $timeout,
+  ];
+}

package/src/core/urlUtils.js

@@ -0,0 +1,187 @@
+/* eslint-disable no-use-before-define */
+
+import { isString } from "./utils";
+
+// service.
+const urlParsingNode = window.document.createElement("a");
+const originUrl = urlResolve(window.location.href);
+let baseUrlParsingNode;
+
+urlParsingNode.href = "http://[::1]";
+
+/**
+ *
+ * Implementation Notes for non-IE browsers
+ * ----------------------------------------
+ * Assigning a URL to the href property of an anchor DOM node, even one attached to the DOM,
+ * results both in the normalizing and parsing of the URL.  Normalizing means that a relative
+ * URL will be resolved into an absolute URL in the context of the application document.
+ * Parsing means that the anchor node's host, hostname, protocol, port, pathname and related
+ * properties are all populated to reflect the normalized URL.  This approach has wide
+ * compatibility - Safari 1+, Mozilla 1+ etc.  See
+ * http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
+ *
+ * Implementation Notes for IE
+ * ---------------------------
+ * IE <= 10 normalizes the URL when assigned to the anchor node similar to the other
+ * browsers.  However, the parsed components will not be set if the URL assigned did not specify
+ * them.  (e.g. if you assign a.href = "foo", then a.protocol, a.host, etc. will be empty.)  We
+ * work around that by performing the parsing in a 2nd step by taking a previously normalized
+ * URL (e.g. by assigning to a.href) and assigning it a.href again.  This correctly populates the
+ * properties such as protocol, hostname, port, etc.
+ *
+ * References:
+ *   http://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement
+ *   http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
+ *   http://url.spec.whatwg.org/#urlutils
+ *   https://github.com/angular/angular.js/pull/2902
+ *   http://james.padolsey.com/javascript/parsing-urls-with-the-dom/
+ *
+ * @kind function
+ * @param {string|object} url The URL to be parsed. If `url` is not a string, it will be returned
+ *     unchanged.
+ * @description Normalizes and parses a URL.
+ * @returns {object} Returns the normalized URL as a dictionary.
+ *
+ *   | member name   | Description                                                            |
+ *   |---------------|------------------------------------------------------------------------|
+ *   | href          | A normalized version of the provided URL if it was not an absolute URL |
+ *   | protocol      | The protocol without the trailing colon                                |
+ *   | host          | The host and port (if the port is non-default) of the normalizedUrl    |
+ *   | search        | The search params, minus the question mark                             |
+ *   | hash          | The hash string, minus the hash symbol                                 |
+ *   | hostname      | The hostname                                                           |
+ *   | port          | The port, without ":"                                                  |
+ *   | pathname      | The pathname, beginning with "/"                                       |
+ *
+ */
+export function urlResolve(url) {
+  if (!isString(url)) return url;
+
+  const href = url;
+
+  urlParsingNode.setAttribute("href", href);
+
+  let { hostname } = urlParsingNode;
+  // Support: IE 9-11 only, Edge 16-17 only (fixed in 18 Preview)
+  // IE/Edge don't wrap IPv6 addresses' hostnames in square brackets
+  // when parsed out of an anchor element.
+  const ipv6InBrackets = urlParsingNode.hostname === "[::1]";
+  if (!ipv6InBrackets && hostname.indexOf(":") > -1) {
+    hostname = `[${hostname}]`;
+  }
+
+  return {
+    href: urlParsingNode.href,
+    protocol: urlParsingNode.protocol
+      ? urlParsingNode.protocol.replace(/:$/, "")
+      : "",
+    host: urlParsingNode.host,
+    search: urlParsingNode.search
+      ? urlParsingNode.search.replace(/^\?/, "")
+      : "",
+    hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
+    hostname,
+    port: urlParsingNode.port,
+    pathname:
+      urlParsingNode.pathname.charAt(0) === "/"
+        ? urlParsingNode.pathname
+        : `/${urlParsingNode.pathname}`,
+  };
+}
+
+/**
+ * Parse a request URL and determine whether this is a same-origin request as the application
+ * document.
+ *
+ * @param {string|object} requestUrl The url of the request as a string that will be resolved
+ * or a parsed URL object.
+ * @returns {boolean} Whether the request is for the same origin as the application document.
+ */
+export function urlIsSameOrigin(requestUrl) {
+  return urlsAreSameOrigin(requestUrl, originUrl);
+}
+
+/**
+ * Parse a request URL and determine whether it is same-origin as the current document base URL.
+ *
+ * Note: The base URL is usually the same as the document location (`location.href`) but can
+ * be overriden by using the `<base>` tag.
+ *
+ * @param {string|object} requestUrl The url of the request as a string that will be resolved
+ * or a parsed URL object.
+ * @returns {boolean} Whether the URL is same-origin as the document base URL.
+ */
+export function urlIsSameOriginAsBaseUrl(requestUrl) {
+  return urlsAreSameOrigin(requestUrl, getBaseUrl());
+}
+
+/**
+ * Create a function that can check a URL's origin against a list of allowed/trusted origins.
+ * The current location's origin is implicitly trusted.
+ *
+ * @param {string[]} trustedOriginUrls - A list of URLs (strings), whose origins are trusted.
+ *
+ * @returns {Function} - A function that receives a URL (string or parsed URL object) and returns
+ *     whether it is of an allowed origin.
+ */
+export function urlIsAllowedOriginFactory(trustedOriginUrls) {
+  const parsedAllowedOriginUrls = [originUrl].concat(
+    trustedOriginUrls.map(urlResolve),
+  );
+
+  /**
+   * Check whether the specified URL (string or parsed URL object) has an origin that is allowed
+   * based on a list of trusted-origin URLs. The current location's origin is implicitly
+   * trusted.
+   *
+   * @param {string|Object} requestUrl - The URL to be checked (provided as a string that will be
+   *     resolved or a parsed URL object).
+   *
+   * @returns {boolean} - Whether the specified URL is of an allowed origin.
+   */
+  return function urlIsAllowedOrigin(requestUrl) {
+    const parsedUrl = urlResolve(requestUrl);
+    return parsedAllowedOriginUrls.some(
+      urlsAreSameOrigin.bind(null, parsedUrl),
+    );
+  };
+}
+
+/**
+ * Determine if two URLs share the same origin.
+ *
+ * @param {string|Object} url1 - First URL to compare as a string or a normalized URL in the form of
+ *     a dictionary object returned by `urlResolve()`.
+ * @param {string|object} url2 - Second URL to compare as a string or a normalized URL in the form
+ *     of a dictionary object returned by `urlResolve()`.
+ *
+ * @returns {boolean} - True if both URLs have the same origin, and false otherwise.
+ */
+export function urlsAreSameOrigin(url1, url2) {
+  url1 = urlResolve(url1);
+  url2 = urlResolve(url2);
+
+  return url1.protocol === url2.protocol && url1.host === url2.host;
+}
+
+/**
+ * Returns the current document base URL.
+ * @returns {string}
+ */
+export function getBaseUrl() {
+  if (window.document.baseURI) {
+    return window.document.baseURI;
+  }
+
+  // `document.baseURI` is available everywhere except IE
+  if (!baseUrlParsingNode) {
+    baseUrlParsingNode = window.document.createElement("a");
+    baseUrlParsingNode.href = ".";
+
+    // Work-around for IE bug described in Implementation Notes. The fix in `urlResolve()` is not
+    // suitable here because we need to track changes to the base URL.
+    baseUrlParsingNode = baseUrlParsingNode.cloneNode(false);
+  }
+  return baseUrlParsingNode.href;
+}