@angular-wave/angular.ts 0.0.11 → 0.0.13

package/src/router/adapter/injectables.js

@@ -0,0 +1,314 @@
+/**
+ * The current (or pending) State Parameters
+ *
+ * An injectable global **Service Object** which holds the state parameters for the latest **SUCCESSFUL** transition.
+ *
+ * The values are not updated until *after* a `Transition` successfully completes.
+ *
+ * **Also:** an injectable **Per-Transition Object** object which holds the pending state parameters for the pending `Transition` currently running.
+ *
+ * ### Deprecation warning:
+ *
+ * The value injected for `$stateParams` is different depending on where it is injected.
+ *
+ * - When injected into an angular service, the object injected is the global **Service Object** with the parameter values for the latest successful `Transition`.
+ * - When injected into transition hooks, resolves, or view controllers, the object is the **Per-Transition Object** with the parameter values for the running `Transition`.
+ *
+ * Because of these confusing details, this service is deprecated.
+ *
+ * ### Instead of using the global `$stateParams` service object,
+ * inject [[$uiRouterGlobals]] and use [[UIRouterGlobals.params]]
+ *
+ * ```js
+ * MyService.$inject = ['$uiRouterGlobals'];
+ * function MyService($uiRouterGlobals) {
+ *   return {
+ *     paramValues: function () {
+ *       return $uiRouterGlobals.params;
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### Instead of using the per-transition `$stateParams` object,
+ * inject the current `Transition` (as [[$transition$]]) and use [[Transition.params]]
+ *
+ * ```js
+ * MyController.$inject = ['$transition$'];
+ * function MyController($transition$) {
+ *   var username = $transition$.params().username;
+ *   // .. do something with username
+ * }
+ * ```
+ *
+ * ---
+ *
+ * This object can be injected into other services.
+ *
+ * #### Deprecated Example:
+ * ```js
+ * SomeService.$inject = ['$http', '$stateParams'];
+ * function SomeService($http, $stateParams) {
+ *   return {
+ *     getUser: function() {
+ *       return $http.get('/api/users/' + $stateParams.username);
+ *     }
+ *   }
+ * };
+ * angular.service('SomeService', SomeService);
+ * ```
+ * @deprecated
+ */
+let $stateParams;
+/**
+ * Global UI-Router variables
+ *
+ * The router global state as a **Service Object** (injectable during runtime).
+ *
+ * This object contains globals such as the current state and current parameter values.
+ */
+let $uiRouterGlobals;
+/**
+ * The UI-Router instance
+ *
+ * The [[UIRouter]] singleton (the router instance) as a **Service Object** (injectable during runtime).
+ *
+ * This object is the UI-Router singleton instance, created by angular dependency injection during application bootstrap.
+ * It has references to the other UI-Router services
+ *
+ * #### Note: This object is also exposed as [[$uiRouterProvider]] for injection during angular config time.
+ */
+let $uiRouter;
+/**
+ * The UI-Router instance
+ *
+ * The [[UIRouter]] singleton (the router instance) as a **Provider Object** (injectable during config phase).
+ *
+ * This object is the UI-Router singleton instance, created by angular dependency injection during application bootstrap.
+ * It has references to the other UI-Router services
+ *
+ * #### Note: This object is also exposed as [[$uiRouter]] for injection during runtime.
+ */
+let $uiRouterProvider;
+/**
+ * Transition debug/tracing
+ *
+ * The [[Trace]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * Enables or disables Transition tracing which can help to debug issues.
+ */
+let $trace;
+/**
+ * The Transition Service
+ *
+ * The [[TransitionService]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * This angular service exposes the [[TransitionService]] singleton, which is primarily
+ * used to register global transition hooks.
+ *
+ * #### Note: This object is also exposed as [[$transitionsProvider]] for injection during the config phase.
+ */
+let $transitions;
+/**
+ * The Transition Service
+ *
+ * The [[TransitionService]] singleton as a **Provider Object** (injectable during config phase)
+ *
+ * This angular service exposes the [[TransitionService]] singleton, which is primarily
+ * used to register global transition hooks.
+ *
+ * #### Note: This object is also exposed as [[$transitions]] for injection during runtime.
+ */
+let $transitionsProvider;
+/**
+ * The current [[Transition]] object
+ *
+ * The current [[Transition]] object as a **Per-Transition Object** (injectable into Resolve, Hooks, Controllers)
+ *
+ * This object returns information about the current transition, including:
+ *
+ * - To/from states
+ * - To/from parameters
+ * - Transition options
+ * - States being entered, exited, and retained
+ * - Resolve data
+ * - A Promise for the transition
+ * - Any transition failure information
+ * - An injector for both Service and Per-Transition Objects
+ */
+let $transition$;
+/**
+ * The State Service
+ *
+ * The [[StateService]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * This service used to manage and query information on registered states.
+ * It exposes state related APIs including:
+ *
+ * - Start a [[Transition]]
+ * - Imperatively lazy load states
+ * - Check if a state is currently active
+ * - Look up states by name
+ * - Build URLs for a state+parameters
+ * - Configure the global Transition error handler
+ *
+ * This angular service exposes the [[StateService]] singleton.
+ */
+let $state;
+/**
+ * The State Registry
+ *
+ * The [[StateRegistry]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * This service is used to register/deregister states.
+ * It has state registration related APIs including:
+ *
+ * - Register/deregister states
+ * - Listen for state registration/deregistration
+ * - Get states by name
+ * - Add state decorators (to customize the state creation process)
+ *
+ * #### Note: This object is also exposed as [[$stateRegistryProvider]] for injection during the config phase.
+ */
+let $stateRegistry;
+/**
+ * The State Registry
+ *
+ * The [[StateRegistry]] singleton as a **Provider Object** (injectable during config time).
+ *
+ * This service is used to register/deregister states.
+ * It has state registration related APIs including:
+ *
+ * - Register/deregister states
+ * - Listen for state registration/deregistration
+ * - Get states by name
+ * - Add state decorators (to customize the state creation process)
+ *
+ * #### Note: This object is also exposed as [[$stateRegistry]] for injection during runtime.
+ */
+let $stateRegistryProvider;
+/**
+ * The View Scroll provider
+ *
+ * The [[UIViewScrollProvider]] as a **Provider Object** (injectable during config time).
+ *
+ * This angular service exposes the [[UIViewScrollProvider]] singleton and is
+ * used to disable UI-Router's scroll behavior.
+ */
+let $uiViewScrollProvider;
+/**
+ * The View Scroll function
+ *
+ * The View Scroll function as a **Service Object** (injectable during runtime).
+ *
+ * This is a function that scrolls an element into view.
+ * The element is scrolled after a `$timeout` so the DOM has time to refresh.
+ *
+ * If you prefer to rely on `$anchorScroll` to scroll the view to the anchor,
+ * this can be enabled by calling [[UIViewScrollProvider.useAnchorScroll]].
+ *
+ * Note: this function is used by the [[directives.uiView]] when the `autoscroll` expression evaluates to true.
+ */
+let $uiViewScroll;
+/**
+ * The StateProvider
+ *
+ * An angular1-only [[StateProvider]] as a **Provider Object** (injectable during config time).
+ *
+ * This angular service exposes the [[StateProvider]] singleton.
+ *
+ * The `StateProvider` is primarily used to register states or add custom state decorators.
+ *
+ * ##### Note: This provider is a ng1 vestige.
+ * It is a passthrough to [[$stateRegistry]] and [[$state]].
+ */
+let $stateProvider;
+/**
+ * The URL Service Provider
+ *
+ * The [[UrlService]] singleton as a **Provider Object** (injectable during the angular config phase).
+ *
+ * A service used to configure and interact with the URL.
+ * It has URL related APIs including:
+ *
+ * - register custom Parameter types `UrlService.config.type` ([[UrlConfigApi.type]])
+ * - add URL rules: `UrlService.rules.when` ([[UrlRulesApi.when]])
+ * - configure behavior when no url matches: `UrlService.rules.otherwise` ([[UrlRulesApi.otherwise]])
+ * - delay initial URL synchronization [[UrlService.deferIntercept]].
+ * - get or set the current url: [[UrlService.url]]
+ *
+ * ##### Note: This service can also be injected during runtime as [[$urlService]].
+ */
+let $urlServiceProvider;
+/**
+ * The URL Service
+ *
+ * The [[UrlService]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * Note: This service can also be injected during the config phase as [[$urlServiceProvider]].
+ *
+ * Used to configure the URL.
+ * It has URL related APIs including:
+ *
+ * - register custom Parameter types `UrlService.config.type` ([[UrlConfigApi.type]])
+ * - add URL rules: `UrlService.rules.when` ([[UrlRulesApi.when]])
+ * - configure behavior when no url matches: `UrlService.rules.otherwise` ([[UrlRulesApi.otherwise]])
+ * - delay initial URL synchronization [[UrlService.deferIntercept]].
+ * - get or set the current url: [[UrlService.url]]
+ *
+ * ##### Note: This service can also be injected during the config phase as [[$urlServiceProvider]].
+ */
+let $urlService;
+/**
+ * The URL Router Provider
+ *
+ * ### Deprecation warning: This object is now considered internal. Use [[$urlServiceProvider]] instead.
+ *
+ * The [[UrlRouter]] singleton as a **Provider Object** (injectable during config time).
+ *
+ * #### Note: This object is also exposed as [[$urlRouter]] for injection during runtime.
+ *
+ * @deprecated
+ */
+let $urlRouterProvider;
+/**
+ * The Url Router
+ *
+ * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
+ *
+ * The [[UrlRouter]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * #### Note: This object is also exposed as [[$urlRouterProvider]] for injection during angular config time.
+ *
+ * @deprecated
+ */
+let $urlRouter;
+/**
+ * The URL Matcher Factory
+ *
+ * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
+ *
+ * The [[UrlMatcherFactory]] singleton as a **Service Object** (injectable during runtime).
+ *
+ * This service is used to set url mapping options, define custom parameter types, and create [[UrlMatcher]] objects.
+ *
+ * #### Note: This object is also exposed as [[$urlMatcherFactoryProvider]] for injection during angular config time.
+ *
+ * @deprecated
+ */
+let $urlMatcherFactory;
+/**
+ * The URL Matcher Factory
+ *
+ * ### Deprecation warning: This object is now considered internal. Use [[$urlService]] instead.
+ *
+ * The [[UrlMatcherFactory]] singleton as a **Provider Object** (injectable during config time).
+ *
+ * This service is used to set url mapping options, define custom parameter types, and create [[UrlMatcher]] objects.
+ *
+ * #### Note: This object is also exposed as [[$urlMatcherFactory]] for injection during runtime.
+ *
+ * @deprecated
+ */
+let $urlMatcherFactoryProvider;
+export {};

package/src/router/adapter/interface.js

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

package/src/router/adapter/locationServices.js

@@ -0,0 +1,84 @@
+/** @publicapi @module ng1 */ /** */
+import { isDefined, isObject } from "../../core/utils";
+import { val } from "../core/common/hof";
+import { createProxyFunctions, removeFrom } from "../core/common/common";
+/**
+ * Implements UI-Router LocationServices and LocationConfig using Angular 1's $location service
+ * @internalapi
+ */
+export class Ng1LocationServices {
+  /**
+   * Applys ng1-specific path parameter encoding
+   *
+   * The Angular 1 `$location` service is a bit weird.
+   * It doesn't allow slashes to be encoded/decoded bi-directionally.
+   *
+   * See the writeup at https://github.com/angular-ui/ui-router/issues/2598
+   *
+   * This code patches the `path` parameter type so it encoded/decodes slashes as ~2F
+   *
+   * @param router
+   */
+  static monkeyPatchPathParameterType(router) {
+    const pathType = router.urlMatcherFactory.type("path");
+    pathType.encode = (x) =>
+      x != null
+        ? x.toString().replace(/(~|\/)/g, (m) => ({ "~": "~~", "/": "~2F" })[m])
+        : x;
+    pathType.decode = (x) =>
+      x != null
+        ? x
+            .toString()
+            .replace(/(~~|~2F)/g, (m) => ({ "~~": "~", "~2F": "/" })[m])
+        : x;
+  }
+  dispose() {}
+  constructor($locationProvider) {
+    // .onChange() registry
+    this._urlListeners = [];
+    this.$locationProvider = $locationProvider;
+    const _lp = val($locationProvider);
+    createProxyFunctions(_lp, this, _lp, ["hashPrefix"]);
+  }
+  onChange(callback) {
+    this._urlListeners.push(callback);
+    return () => removeFrom(this._urlListeners)(callback);
+  }
+  html5Mode() {
+    let html5Mode = this.$locationProvider.html5Mode();
+    html5Mode = isObject(html5Mode) ? html5Mode.enabled : html5Mode;
+    return html5Mode && typeof history !== "undefined";
+  }
+  baseHref() {
+    return (
+      this._baseHref ||
+      (this._baseHref =
+        this.$browser.baseHref() || this.$window.location.pathname)
+    );
+  }
+  url(newUrl, replace = false, state) {
+    if (isDefined(newUrl)) this.$location.url(newUrl);
+    if (replace) this.$location.replace();
+    if (state) this.$location.state(state);
+    return this.$location.url();
+  }
+  _runtimeServices($rootScope, $location, $browser) {
+    this.$location = $location;
+    this.$browser = $browser;
+    this.$window = window;
+    // Bind $locationChangeSuccess to the listeners registered in LocationService.onChange
+    $rootScope.$on("$locationChangeSuccess", (evt) =>
+      this._urlListeners.forEach((fn) => fn(evt)),
+    );
+    const _loc = val($location);
+    // Bind these LocationService functions to $location
+    createProxyFunctions(_loc, this, _loc, [
+      "replace",
+      "path",
+      "search",
+      "hash",
+    ]);
+    // Bind these LocationConfig functions to $location
+    createProxyFunctions(_loc, this, _loc, ["port", "protocol", "host"]);
+  }
+}

package/src/router/adapter/services.js

@@ -0,0 +1,126 @@
+/**
+ * # Angular 1 types
+ *
+ * UI-Router core provides various Typescript types which you can use for code completion and validating parameter values, etc.
+ * The customizations to the core types for Angular UI-Router are documented here.
+ *
+ * The optional [[$resolve]] service is also documented here.
+ *
+ * @preferred @publicapi @module ng1
+ */
+import { services } from "../core/common/coreservices";
+import { applyPairs, unnestR } from "../core/common/common";
+import { isString, extend } from "../../core/utils";
+import { trace } from "../core/common/trace";
+import { UIRouter } from "../core/router";
+import {
+  ng1ViewsBuilder,
+  getNg1ViewConfigFactory,
+} from "./statebuilders/views";
+
+import { StateProvider } from "./stateProvider";
+import { getStateHookBuilder } from "./statebuilders/onEnterExitRetain";
+import { Ng1LocationServices } from "./locationServices";
+
+export let router = null;
+$uiRouterProvider.$inject = ["$locationProvider"];
+/** This angular 1 provider instantiates a Router and exposes its services via the angular injector */
+export function $uiRouterProvider($locationProvider) {
+  // Create a new instance of the Router when the $uiRouterProvider is initialized
+  router = this.router = new UIRouter();
+  router.stateProvider = new StateProvider(
+    router.stateRegistry,
+    router.stateService,
+  );
+  // Apply ng1 specific StateBuilder code for `views`, `resolve`, and `onExit/Retain/Enter` properties
+  router.stateRegistry.decorator("views", ng1ViewsBuilder);
+  router.stateRegistry.decorator("onExit", getStateHookBuilder("onExit"));
+  router.stateRegistry.decorator("onRetain", getStateHookBuilder("onRetain"));
+  router.stateRegistry.decorator("onEnter", getStateHookBuilder("onEnter"));
+  router.viewService._pluginapi._viewConfigFactory(
+    "ng1",
+    getNg1ViewConfigFactory(),
+  );
+  // Disable decoding of params by UrlMatcherFactory because $location already handles this
+  router.urlService.config._decodeParams = false;
+  const ng1LocationService =
+    (router.locationService =
+    router.locationConfig =
+      new Ng1LocationServices($locationProvider));
+  Ng1LocationServices.monkeyPatchPathParameterType(router);
+  // backwards compat: also expose router instance as $uiRouterProvider.router
+  router["router"] = router;
+  router["$get"] = $get;
+  $get.$inject = ["$location", "$browser", "$rootScope"];
+  function $get($location, $browser, $rootScope) {
+    ng1LocationService._runtimeServices($rootScope, $location, $browser);
+    delete router["router"];
+    delete router["$get"];
+    return router;
+  }
+  return router;
+}
+export const getProviderFor = (serviceName) => [
+  "$uiRouterProvider",
+  function UrlServiceProvider($urp) {
+    const service = $urp.router[serviceName];
+    service["$get"] = () => service;
+    return service;
+  },
+];
+// This effectively calls $get() on `$uiRouterProvider` to trigger init (when ng enters runtime)
+runBlock.$inject = ["$injector", "$q", "$uiRouter"];
+export function runBlock($injector, $q, $uiRouter) {
+  services.$injector = $injector;
+  services.$q = $q;
+  // https://github.com/angular-ui/ui-router/issues/3678
+  if (!Object.prototype.hasOwnProperty.call($injector, "strictDi")) {
+    try {
+      $injector.invoke(function (checkStrictDi) {});
+    } catch (error) {
+      $injector.strictDi = !!/strict mode/.exec(error && error.toString());
+    }
+  }
+  // The $injector is now available.
+  // Find any resolvables that had dependency annotation deferred
+  $uiRouter.stateRegistry
+    .get()
+    .map((x) => x.$$state().resolvables)
+    .reduce(unnestR, [])
+    .filter((x) => x.deps === "deferred")
+    .forEach(
+      (resolvable) =>
+        (resolvable.deps = $injector.annotate(
+          resolvable.resolveFn,
+          $injector.strictDi,
+        )),
+    );
+}
+
+// $state service and $stateProvider
+// $urlRouter service and $urlRouterProvider
+export function getStateProvider() {
+  debugger;
+  return extend(router.stateProvider, { $get: () => router.stateService });
+}
+
+watchDigests.$inject = ["$rootScope"];
+export function watchDigests($rootScope) {
+  $rootScope.$watch(function () {
+    trace.approximateDigests++;
+  });
+}
+
+/** @hidden TODO: find a place to move this */
+export const getLocals = (ctx) => {
+  const tokens = ctx.getTokens().filter(isString);
+  const tuples = tokens.map((key) => {
+    const resolvable = ctx.getResolvable(key);
+    const waitPolicy = ctx.getPolicy(resolvable).async;
+    return [
+      key,
+      waitPolicy === "NOWAIT" ? resolvable.promise : resolvable.data,
+    ];
+  });
+  return tuples.reduce(applyPairs, {});
+};

package/src/router/adapter/stateFilters.js

@@ -0,0 +1,43 @@
+/** @publicapi @module ng1 */ /** */
+
+/**
+ * `isState` Filter: truthy if the current state is the parameter
+ *
+ * Translates to [[StateService.is]] `$state.is("stateName")`.
+ *
+ * #### Example:
+ * ```html
+ * <div ng-if="'stateName' | isState">show if state is 'stateName'</div>
+ * ```
+ */
+$IsStateFilter.$inject = ["$state"];
+function $IsStateFilter($state) {
+  const isFilter = function (state, params, options) {
+    return $state.is(state, params, options);
+  };
+  isFilter.$stateful = true;
+  return isFilter;
+}
+/**
+ * `includedByState` Filter: truthy if the current state includes the parameter
+ *
+ * Translates to [[StateService.includes]]` $state.is("fullOrPartialStateName")`.
+ *
+ * #### Example:
+ * ```html
+ * <div ng-if="'fullOrPartialStateName' | includedByState">show if state includes 'fullOrPartialStateName'</div>
+ * ```
+ */
+$IncludedByStateFilter.$inject = ["$state"];
+function $IncludedByStateFilter($state) {
+  const includesFilter = function (state, params, options) {
+    return $state.includes(state, params, options);
+  };
+  includesFilter.$stateful = true;
+  return includesFilter;
+}
+window.angular
+  .module("ui.router.state")
+  .filter("isState", $IsStateFilter)
+  .filter("includedByState", $IncludedByStateFilter);
+export { $IsStateFilter, $IncludedByStateFilter };