@angular-wave/angular.ts 0.0.12 → 0.0.14

package/src/router/core/transition/hookRegistry.js

@@ -1,11 +1,4 @@
-import {
-  extend,
-  removeFrom,
-  tail,
-  values,
-  identity,
-  mapObj,
-} from "../common/common";
+import { extend, removeFrom, tail, identity, mapObj } from "../common/common";
 import { isString, isFunction } from "../common/predicates";
 import { Glob } from "../common/glob";
 import {
@@ -125,7 +118,7 @@ export class RegisteredHook {
       this._getDefaultMatchCriteria(),
       this.matchCriteria,
     );
-    const paths = values(this.tranSvc._pluginapi._getPathTypes());
+    const paths = Object.values(this.tranSvc._pluginapi._getPathTypes());
     return paths.reduce((mn, pathtype) => {
       // STATE scope criteria matches against every node in the path.
       // TRANSITION scope criteria matches against only the last node in the path
@@ -149,7 +142,7 @@ export class RegisteredHook {
   matches(treeChanges, transition) {
     const matches = this._getMatchingNodes(treeChanges, transition);
     // Check if all the criteria matched the TreeChanges object
-    const allMatched = values(matches).every(identity);
+    const allMatched = Object.values(matches).every(identity);
     return allMatched ? matches : null;
   }
   deregister() {

package/src/router/core/transition/transitionService.js

@@ -26,7 +26,7 @@ import { registerLazyLoadHook } from "../hooks/lazyLoad";
 import { TransitionEventType } from "./transitionEventType";
 import { TransitionHook } from "./transitionHook";
 import { isDefined } from "../common/predicates";
-import { removeFrom, values, createProxyFunctions } from "../common/common";
+import { removeFrom, createProxyFunctions } from "../common/common";
 import { val } from "../common/hof";
 import { registerIgnoredTransitionHook } from "../hooks/ignoredTransition";
 import { registerInvalidTransitionHook } from "../hooks/invalidTransition";
@@ -148,7 +148,7 @@ export class TransitionService {
    * @internal
    */
   dispose(router) {
-    values(this._registeredHooks).forEach((hooksArray) =>
+    Object.values(this._registeredHooks).forEach((hooksArray) =>
       hooksArray.forEach((hook) => {
         hook._deregistered = true;
         removeFrom(hooksArray, hook);

package/src/router/router.js

@@ -1,6 +1,5 @@
 import {
   $uiRouterProvider,
-  getUrlRouterProvider,
   getProviderFor,
   getStateProvider,
   router,
@@ -9,17 +8,24 @@ import {
 } from "./adapter/services";
 import { TemplateFactory } from "./adapter/templateFactory";
 import { trace } from "./core/common/trace";
+import { $ViewScrollProvider } from "./adapter/viewScroll";
+import { $IsStateFilter, $IncludedByStateFilter } from "./adapter/stateFilters";
+import {
+  uiSrefActiveDirective,
+  uiStateDirective,
+  uiSrefDirective,
+} from "./adapter/directives/stateDirectives";
+import { uiView, $ViewDirectiveFill } from "./adapter/directives/viewDirective";
 
 export function initRouter() {
   window.angular.module("ui.router.angular1", []);
   const mod_init = window.angular.module("ui.router.init", ["ng"]);
   const mod_util = window.angular.module("ui.router.util", ["ui.router.init"]);
-  const mod_rtr = window.angular.module("ui.router.router", ["ui.router.util"]);
   const mod_state = window.angular.module("ui.router.state", [
-    "ui.router.router",
     "ui.router.util",
     "ui.router.angular1",
   ]);
+
   const mod_main = window.angular.module("ui.router", [
     "ui.router.init",
     "ui.router.state",
@@ -27,26 +33,44 @@ export function initRouter() {
   ]);
 
   mod_init.provider("$uiRouter", $uiRouterProvider);
-  mod_rtr.provider("$urlRouter", ["$uiRouterProvider", getUrlRouterProvider]);
   mod_util.provider("$urlService", getProviderFor("urlService"));
   mod_util.provider("$urlMatcherFactory", [
     "$uiRouterProvider",
-    () => router.urlMatcherFactory,
-  ]);
-  mod_util.provider("$templateFactory", () => new TemplateFactory());
-  mod_state.provider("$stateRegistry", getProviderFor("stateRegistry"));
-  mod_state.provider("$uiRouterGlobals", getProviderFor("globals"));
-  mod_state.provider("$transitions", getProviderFor("transitionService"));
-  mod_state.provider("$state", ["$uiRouterProvider", getStateProvider]);
-  mod_state.factory("$stateParams", [
-    "$uiRouter",
-    ($uiRouter) => $uiRouter.globals.params,
+    function RouterProvide() {
+      return router.urlMatcherFactory;
+    },
   ]);
-  mod_main.factory("$view", () => router.viewService);
-  mod_main.service("$trace", () => trace);
+  mod_util.provider("$templateFactory", function () {
+    return new TemplateFactory();
+  });
+  mod_state
+    .provider("$stateRegistry", getProviderFor("stateRegistry"))
+    .provider("$uiRouterGlobals", getProviderFor("globals"))
+    .provider("$transitions", getProviderFor("transitionService"))
+    .provider("$state", ["$uiRouterProvider", getStateProvider])
+    .provider("$uiViewScroll", $ViewScrollProvider)
+    .factory("$stateParams", [
+      "$uiRouter",
+      function StateParamse($uiRouter) {
+        return $uiRouter.globals.params;
+      },
+    ])
+    .filter("isState", $IsStateFilter)
+    .filter("includedByState", $IncludedByStateFilter)
+    .directive("uiSref", uiSrefDirective)
+    .directive("uiSrefActive", uiSrefActiveDirective)
+    .directive("uiSrefActiveEq", uiSrefActiveDirective)
+    .directive("uiState", uiStateDirective)
+    .directive("uiView", uiView)
+    .directive("uiView", $ViewDirectiveFill);
+  mod_main.factory("$view", function View() {
+    return router.viewService;
+  });
+  mod_main.service("$trace", function Trace() {
+    return trace;
+  });
   mod_main.run(watchDigests);
-  mod_util.run(["$urlMatcherFactory", function ($urlMatcherFactory) {}]);
-  mod_state.run(["$state", function ($state) {}]);
-  mod_rtr.run(["$urlRouter", function ($urlRouter) {}]);
+  mod_util.run(["$urlMatcherFactory", function MatcherFac() {}]);
+  mod_state.run(["$state", function State() {}]);
   mod_init.run(runBlock);
 }

package/test/module-test.html

@@ -3,17 +3,24 @@
   <head>
     <script></script>
     <script type="module" src="../src/index.js"></script>
-  </head>
-  <body ng-app>
-    <div ng-init='list = [{ name: "x" }, { name: "y" }, { name: "z" }]'>
-      <label>Name:</label>
-      <input type="text" ng-model="yourName" placeholder="Enter a name here" />
-      <hr />
-      <h1>Hello {{yourName}}!</h1>
+    <script>
+      document.addEventListener("DOMContentLoaded", () => {
+        var myApp = window.angular.module("test", ["ui.router"]);
+        myApp.config(function ($stateProvider) {
+          var helloState = {
+            name: "hello",
+            url: "/",
+            template: "<h3>hello world!</h3>",
+          };
 
-      <ul ng-repeat="i in list">
-        <li>{{ i.name }}</li>
-      </ul>
-    </div>
+          $stateProvider.state(helloState);
+        });
+      });
+    </script>
+  </head>
+  <body ng-app="test">
+    {{ 2 + 2 }}
+    <a ui-sref="hello" ui-sref-active="active">Hello</a>
+    <ui-view></ui-view>
   </body>
 </html>

package/test/ng/directive/if.spec.js

@@ -103,7 +103,6 @@ describe("ngIf", () => {
 
     it("should destroy the child scope every time the expression evaluates to false", () => {
       $scope.value = true;
-      debugger;
       element.append($compile('<div ng-if="value"></div>')($scope));
       $scope.$apply();
 

package/test/original-test.html

@@ -1,21 +1,33 @@
 <!doctype html>
 <html>
   <head>
-    <script src="../legacy/build/angular.js"></script>
-  </head>
-  <body>
-    Test:
-    <my-component></my-component>
-    {{ 2 + 2 }}
-  </body>
+    <script src="../legacy/angular.js"></script>
+    <script src="//unpkg.com/@uirouter/angularjs/release/angular-ui-router.min.js"></script>
+    <script>
+      var myApp = angular.module("helloworld", ["ui.router"]);
+
+      myApp.config(function ($stateProvider) {
+        var helloState = {
+          name: "hello",
+          url: "/",
+          template: "<h3>hello world!</h3>",
+        };
 
-  <script>
-    document.addEventListener("DOMContentLoaded", () => {
-      window.angular.module("myModule", []).component("myComponent", {
-        template: "<div>ME</div>",
+        var aboutState = {
+          name: "about",
+          url: "/about",
+          template: "<h3>Its the UI-Router hello world app!</h3>",
+        };
+
+        $stateProvider.state(helloState);
+        $stateProvider.state(aboutState);
       });
-      window.angular.bootstrap(document, ["myModule"]);
-      //angularInit(document, window.angular.bootstrap);
-    });
-  </script>
+    </script>
+  </head>
+  <body ng-app="helloworld">
+    <a ui-sref="hello" ui-sref-active="active">Hello</a>
+    {{ 2 + 2}}
+    <ui-view></ui-view>
+    {{ 2 + 2}}
+  </body>
 </html>

package/src/router/adapter/urlRouterProvider.js

@@ -1,196 +0,0 @@
-/** @publicapi @module url */ /** */
-
-import { BaseUrlRule } from "../core/url/urlRule";
-import { isString, isFunction, isArray, identity } from "../../core/utils";
-import { services } from "../core/common/coreservices";
-
-/**
- * Manages rules for client-side URL
- *
- * ### Deprecation warning:
- * This class is now considered to be an internal API
- * Use the [[UrlService]] instead.
- * For configuring URL rules, use the [[UrlRulesApi]] which can be found as [[UrlService.rules]].
- *
- * This class manages the router rules for what to do when the URL changes.
- *
- * This provider remains for backwards compatibility.
- *
- * @internalapi
- * @deprecated
- */
-export class UrlRouterProvider {
-  static injectableHandler(router, handler) {
-    return (match) =>
-      services.$injector.invoke(handler, null, {
-        $match: match,
-        $stateParams: router.globals.params,
-      });
-  }
-  /** @hidden */
-  constructor(/** @hidden */ router) {
-    this.router = router;
-  }
-  /** @hidden */
-  $get() {
-    const urlService = this.router.urlService;
-    this.router.urlRouter.update(true);
-    if (!urlService.interceptDeferred) urlService.listen();
-    return this.router.urlRouter;
-  }
-  /**
-   * Registers a url handler function.
-   *
-   * Registers a low level url handler (a `rule`).
-   * A rule detects specific URL patterns and returns a redirect, or performs some action.
-   *
-   * If a rule returns a string, the URL is replaced with the string, and all rules are fired again.
-   *
-   * #### Example:
-   * ```js
-   * var app = angular.module('app', ['ui.router.router']);
-   *
-   * app.config(function ($urlRouterProvider) {
-   *   // Here's an example of how you might allow case insensitive urls
-   *   $urlRouterProvider.rule(function ($injector, $location) {
-   *     var path = $location.path(),
-   *         normalized = path.toLowerCase();
-   *
-   *     if (path !== normalized) {
-   *       return normalized;
-   *     }
-   *   });
-   * });
-   * ```
-   *
-   * @param ruleFn
-   * Handler function that takes `$injector` and `$location` services as arguments.
-   * You can use them to detect a url and return a different url as a string.
-   *
-   * @return [[UrlRouterProvider]] (`this`)
-   */
-  rule(ruleFn) {
-    if (!isFunction(ruleFn)) throw new Error("'rule' must be a function");
-    const match = () => ruleFn(services.$injector, this.router.locationService);
-    const rule = new BaseUrlRule(match, identity);
-    this.router.urlService.rules.rule(rule);
-    return this;
-  }
-  /**
-   * Defines the path or behavior to use when no url can be matched.
-   *
-   * #### Example:
-   * ```js
-   * var app = angular.module('app', ['ui.router.router']);
-   *
-   * app.config(function ($urlRouterProvider) {
-   *   // if the path doesn't match any of the urls you configured
-   *   // otherwise will take care of routing the user to the
-   *   // specified url
-   *   $urlRouterProvider.otherwise('/index');
-   *
-   *   // Example of using function rule as param
-   *   $urlRouterProvider.otherwise(function ($injector, $location) {
-   *     return '/a/valid/url';
-   *   });
-   * });
-   * ```
-   *
-   * @param rule
-   * The url path you want to redirect to or a function rule that returns the url path or performs a `$state.go()`.
-   * The function version is passed two params: `$injector` and `$location` services, and should return a url string.
-   *
-   * @return {object} `$urlRouterProvider` - `$urlRouterProvider` instance
-   */
-  otherwise(rule) {
-    const urlRules = this.router.urlService.rules;
-    if (isString(rule)) {
-      urlRules.otherwise(rule);
-    } else if (isFunction(rule)) {
-      urlRules.otherwise(() =>
-        rule(services.$injector, this.router.locationService),
-      );
-    } else {
-      throw new Error("'rule' must be a string or function");
-    }
-    return this;
-  }
-  /**
-   * Registers a handler for a given url matching.
-   *
-   * If the handler is a string, it is
-   * treated as a redirect, and is interpolated according to the syntax of match
-   * (i.e. like `String.replace()` for `RegExp`, or like a `UrlMatcher` pattern otherwise).
-   *
-   * If the handler is a function, it is injectable.
-   * It gets invoked if `$location` matches.
-   * You have the option of inject the match object as `$match`.
-   *
-   * The handler can return
-   *
-   * - **falsy** to indicate that the rule didn't match after all, then `$urlRouter`
-   *   will continue trying to find another one that matches.
-   * - **string** which is treated as a redirect and passed to `$location.url()`
-   * - **void** or any **truthy** value tells `$urlRouter` that the url was handled.
-   *
-   * #### Example:
-   * ```js
-   * var app = angular.module('app', ['ui.router.router']);
-   *
-   * app.config(function ($urlRouterProvider) {
-   *   $urlRouterProvider.when($state.url, function ($match, $stateParams) {
-   *     if ($state.$current.navigable !== state ||
-   *         !equalForKeys($match, $stateParams) {
-   *      $state.transitionTo(state, $match, false);
-   *     }
-   *   });
-   * });
-   * ```
-   *
-   * @param what A pattern string to match, compiled as a [[UrlMatcher]].
-   * @param handler The path (or function that returns a path) that you want to redirect your user to.
-   * @param ruleCallback [optional] A callback that receives the `rule` registered with [[UrlMatcher.rule]]
-   *
-   * Note: the handler may also invoke arbitrary code, such as `$state.go()`
-   */
-  when(what, handler) {
-    if (isArray(handler) || isFunction(handler)) {
-      handler = UrlRouterProvider.injectableHandler(this.router, handler);
-    }
-    this.router.urlService.rules.when(what, handler);
-    return this;
-  }
-  /**
-   * Disables monitoring of the URL.
-   *
-   * Call this method before UI-Router has bootstrapped.
-   * It will stop UI-Router from performing the initial url sync.
-   *
-   * This can be useful to perform some asynchronous initialization before the router starts.
-   * Once the initialization is complete, call [[listen]] to tell UI-Router to start watching and synchronizing the URL.
-   *
-   * #### Example:
-   * ```js
-   * var app = angular.module('app', ['ui.router']);
-   *
-   * app.config(function ($urlRouterProvider) {
-   *   // Prevent $urlRouter from automatically intercepting URL changes;
-   *   $urlRouterProvider.deferIntercept();
-   * })
-   *
-   * app.run(function (MyService, $urlRouter, $http) {
-   *   $http.get("/stuff").then(function(resp) {
-   *     MyService.doStuff(resp.data);
-   *     $urlRouter.listen();
-   *     $urlRouter.sync();
-   *   });
-   * });
-   * ```
-   *
-   * @param defer Indicates whether to defer location change interception.
-   *        Passing no parameter is equivalent to `true`.
-   */
-  deferIntercept(defer) {
-    this.router.urlService.deferIntercept(defer);
-  }
-}

package/src/router/core/vanilla/baseLocationService.js

@@ -1,31 +0,0 @@
-import { deregAll, isDefined, removeFrom, root } from "../common/index";
-import { buildUrl, getParams, parseUrl } from "./utils";
-/** A base `LocationServices` */
-export class BaseLocationServices {
-  constructor(router, fireAfterUpdate) {
-    this.fireAfterUpdate = fireAfterUpdate;
-    this._listeners = [];
-    this._listener = (evt) => this._listeners.forEach((cb) => cb(evt));
-    this.hash = () => parseUrl(this._get()).hash;
-    this.path = () => parseUrl(this._get()).path;
-    this.search = () => getParams(parseUrl(this._get()).search);
-    this._location = root.location;
-    this._history = root.history;
-  }
-  url(url, replace = true) {
-    if (isDefined(url) && url !== this._get()) {
-      this._set(null, null, url, replace);
-      if (this.fireAfterUpdate) {
-        this._listeners.forEach((cb) => cb({ url }));
-      }
-    }
-    return buildUrl(this);
-  }
-  onChange(cb) {
-    this._listeners.push(cb);
-    return () => removeFrom(this._listeners, cb);
-  }
-  dispose(router) {
-    deregAll(this._listeners);
-  }
-}

package/src/router/core/vanilla/browserLocationConfig.js

@@ -1,42 +0,0 @@
-import { isDefined, isUndefined } from "../common/predicates";
-/** A `LocationConfig` that delegates to the browser's `location` object */
-export class BrowserLocationConfig {
-  constructor(router, _isHtml5 = false) {
-    this._isHtml5 = _isHtml5;
-    this._baseHref = undefined;
-    this._hashPrefix = "";
-  }
-  port() {
-    if (location.port) {
-      return Number(location.port);
-    }
-    return this.protocol() === "https" ? 443 : 80;
-  }
-  protocol() {
-    return location.protocol.replace(/:/g, "");
-  }
-  host() {
-    return location.hostname;
-  }
-  html5Mode() {
-    return this._isHtml5;
-  }
-  hashPrefix(newprefix) {
-    return isDefined(newprefix)
-      ? (this._hashPrefix = newprefix)
-      : this._hashPrefix;
-  }
-  baseHref(href) {
-    if (isDefined(href)) this._baseHref = href;
-    if (isUndefined(this._baseHref)) this._baseHref = this.getBaseHref();
-    return this._baseHref;
-  }
-  getBaseHref() {
-    const baseTag = document.getElementsByTagName("base")[0];
-    if (baseTag && baseTag.href) {
-      return baseTag.href.replace(/^([^/:]*:)?\/\/[^/]*/, "");
-    }
-    return this._isHtml5 ? "/" : location.pathname || "/";
-  }
-  dispose() {}
-}

package/src/router/core/vanilla/hashLocationService.js

@@ -1,19 +0,0 @@
-import { root, trimHashVal } from "../common/index";
-import { BaseLocationServices } from "./baseLocationService";
-/** A `LocationServices` that uses the browser hash "#" to get/set the current location */
-export class HashLocationService extends BaseLocationServices {
-  constructor(router) {
-    super(router, false);
-    root.addEventListener("hashchange", this._listener, false);
-  }
-  _get() {
-    return trimHashVal(this._location.hash);
-  }
-  _set(state, title, url, replace) {
-    this._location.hash = url;
-  }
-  dispose(router) {
-    super.dispose(router);
-    root.removeEventListener("hashchange", this._listener);
-  }
-}

package/src/router/core/vanilla/injector.js

@@ -1,98 +0,0 @@
-import {
-  extend,
-  assertPredicate,
-  isFunction,
-  isArray,
-  isInjectable,
-} from "../common/index";
-// globally available injectables
-const globals = {};
-const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
-const ARGUMENT_NAMES = /([^\s,]+)/g;
-/**
- * A basic angular1-like injector api
- *
- * This object implements four methods similar to the
- * [angular 1 dependency injector](https://docs.angularjs.org/api/auto/service/$injector)
- *
- * UI-Router evolved from an angular 1 library to a framework agnostic library.
- * However, some of the `@uirouter/core` code uses these ng1 style APIs to support ng1 style dependency injection.
- *
- * This object provides a naive implementation of a globally scoped dependency injection system.
- * It supports the following DI approaches:
- *
- * ### Function parameter names
- *
- * A function's `.toString()` is called, and the parameter names are parsed.
- * This only works when the parameter names aren't "mangled" by a minifier such as UglifyJS.
- *
- * ```js
- * function injectedFunction(FooService, BarService) {
- *   // FooService and BarService are injected
- * }
- * ```
- *
- * ### Function annotation
- *
- * A function may be annotated with an array of dependency names as the `$inject` property.
- *
- * ```js
- * injectedFunction.$inject = [ 'FooService', 'BarService' ];
- * function injectedFunction(fs, bs) {
- *   // FooService and BarService are injected as fs and bs parameters
- * }
- * ```
- *
- * ### Array notation
- *
- * An array provides the names of the dependencies to inject (as strings).
- * The function is the last element of the array.
- *
- * ```js
- * [ 'FooService', 'BarService', function (fs, bs) {
- *   // FooService and BarService are injected as fs and bs parameters
- * }]
- * ```
- *
- * @type {$InjectorLike}
- */
-export const $injector = {
-  /** Gets an object from DI based on a string token */
-  get: (name) => globals[name],
-  /** Returns true if an object named `name` exists in global DI */
-  has: (name) => $injector.get(name) != null,
-  /**
-   * Injects a function
-   *
-   * @param fn the function to inject
-   * @param context the function's `this` binding
-   * @param locals An object with additional DI tokens and values, such as `{ someToken: { foo: 1 } }`
-   */
-  invoke: (fn, context, locals) => {
-    const all = extend({}, globals, locals || {});
-    const params = $injector.annotate(fn);
-    const ensureExist = assertPredicate(
-      (key) => all.hasOwnProperty(key),
-      (key) => `DI can't find injectable: '${key}'`,
-    );
-    const args = params.filter(ensureExist).map((x) => all[x]);
-    if (isFunction(fn)) return fn.apply(context, args);
-    else return fn.slice(-1)[0].apply(context, args);
-  },
-  /**
-   * Returns a function's dependencies
-   *
-   * Analyzes a function (or array) and returns an array of DI tokens that the function requires.
-   * @return an array of `string`s
-   */
-  annotate: (fn) => {
-    if (!isInjectable(fn)) throw new Error(`Not an injectable function: ${fn}`);
-    if (fn && fn.$inject) return fn.$inject;
-    if (isArray(fn)) return fn.slice(0, -1);
-    const fnStr = fn.toString().replace(STRIP_COMMENTS, "");
-    const result = fnStr
-      .slice(fnStr.indexOf("(") + 1, fnStr.indexOf(")"))
-      .match(ARGUMENT_NAMES);
-    return result || [];
-  },
-};

package/src/router/core/vanilla/interface.js

@@ -1 +0,0 @@
-export {};

package/src/router/core/vanilla/memoryLocationConfig.js

@@ -1,20 +0,0 @@
-import { isDefined } from "../common/predicates";
-import { noop } from "../common/index";
-/** A `LocationConfig` mock that gets/sets all config from an in-memory object */
-export class MemoryLocationConfig {
-  constructor() {
-    this.dispose = noop;
-    this._baseHref = "";
-    this._port = 80;
-    this._protocol = "http";
-    this._host = "localhost";
-    this._hashPrefix = "";
-    this.port = () => this._port;
-    this.protocol = () => this._protocol;
-    this.host = () => this._host;
-    this.baseHref = () => this._baseHref;
-    this.html5Mode = () => false;
-    this.hashPrefix = (newval) =>
-      isDefined(newval) ? (this._hashPrefix = newval) : this._hashPrefix;
-  }
-}

package/src/router/core/vanilla/memoryLocationService.js

@@ -1,13 +0,0 @@
-import { BaseLocationServices } from "./baseLocationService";
-/** A `LocationServices` that gets/sets the current location from an in-memory object */
-export class MemoryLocationService extends BaseLocationServices {
-  constructor(router) {
-    super(router, true);
-  }
-  _get() {
-    return this._url;
-  }
-  _set(state, title, url, replace) {
-    this._url = url;
-  }
-}