@angular-wave/angular.ts 0.0.60 → 0.0.61

package/types-back/router/directives/viewDirective.d.ts

@@ -1,144 +0,0 @@
-/** @publicapi @module directives */ /** */
-import { IDirective } from "../..";
-import { ActiveNGView } from "../core";
-import { Ng1ViewConfig } from "../statebuilders/views";
-
-/** @hidden */
-export declare type NGViewData = {
-  $cfg: Ng1ViewConfig;
-  $ngView: ActiveNGView;
-};
-/** @hidden */
-export declare type NGViewAnimData = {
-  $animEnter: Promise<any>;
-  $animLeave: Promise<any>;
-  $$animLeave: {
-    resolve: () => any;
-  };
-};
-/**
- * `ui-view`: A viewport directive which is filled in by a view from the active state.
- *
- * ### Attributes
- *
- * - `name`: (Optional) A view name.
- *   The name should be unique amongst the other views in the same state.
- *   You can have views of the same name that live in different states.
- *   The ui-view can be targeted in a View using the name ([[Ng1StateDeclaration.views]]).
- *
- * - `autoscroll`: an expression. When it evaluates to true, the `ui-view` will be scrolled into view when it is activated.
- *   Uses [[$ngViewScroll]] to do the scrolling.
- *
- * - `onload`: Expression to evaluate whenever the view updates.
- *
- * #### Example:
- * A view can be unnamed or named.
- * ```html
- * <!-- Unnamed -->
- * <div ui-view></div>
- *
- * <!-- Named -->
- * <div ui-view="viewName"></div>
- *
- * <!-- Named (different style) -->
- * <ui-view name="viewName"></ui-view>
- * ```
- *
- * You can only have one unnamed view within any template (or root html). If you are only using a
- * single view and it is unnamed then you can populate it like so:
- *
- * ```html
- * <div ui-view></div>
- * $stateProvider.state("home", {
- *   template: "<h1>HELLO!</h1>"
- * })
- * ```
- *
- * The above is a convenient shortcut equivalent to specifying your view explicitly with the
- * [[Ng1StateDeclaration.views]] config property, by name, in this case an empty name:
- *
- * ```js
- * $stateProvider.state("home", {
- *   views: {
- *     "": {
- *       template: "<h1>HELLO!</h1>"
- *     }
- *   }
- * })
- * ```
- *
- * But typically you'll only use the views property if you name your view or have more than one view
- * in the same template. There's not really a compelling reason to name a view if its the only one,
- * but you could if you wanted, like so:
- *
- * ```html
- * <div ui-view="main"></div>
- * ```
- *
- * ```js
- * $stateProvider.state("home", {
- *   views: {
- *     "main": {
- *       template: "<h1>HELLO!</h1>"
- *     }
- *   }
- * })
- * ```
- *
- * Really though, you'll use views to set up multiple views:
- *
- * ```html
- * <div ui-view></div>
- * <div ui-view="chart"></div>
- * <div ui-view="data"></div>
- * ```
- *
- * ```js
- * $stateProvider.state("home", {
- *   views: {
- *     "": {
- *       template: "<h1>HELLO!</h1>"
- *     },
- *     "chart": {
- *       template: "<chart_thing/>"
- *     },
- *     "data": {
- *       template: "<data_thing/>"
- *     }
- *   }
- * })
- * ```
- *
- * #### Examples for `autoscroll`:
- * ```html
- * <!-- If autoscroll present with no expression,
- *      then scroll ui-view into view -->
- * <ui-view autoscroll/>
- *
- * <!-- If autoscroll present with valid expression,
- *      then scroll ui-view into view if expression evaluates to true -->
- * <ui-view autoscroll='true'/>
- * <ui-view autoscroll='false'/>
- * <ui-view autoscroll='scopeVariable'/>
- * ```
- *
- * Resolve data:
- *
- * The resolved data from the state's `resolve` block is placed on the scope as `$resolve` (this
- * can be customized using [[Ng1ViewDeclaration.resolveAs]]).  This can be then accessed from the template.
- *
- * Note that when `controllerAs` is being used, `$resolve` is set on the controller instance *after* the
- * controller is instantiated.  The `$onInit()` hook can be used to perform initialization code which
- * depends on `$resolve` data.
- *
- * #### Example:
- * ```js
- * $stateProvider.state('home', {
- *   template: '<my-component user="$resolve.user"></my-component>',
- *   resolve: {
- *     user: function(UserService) { return UserService.fetchUser(); }
- *   }
- * });
- * ```
- */
-export declare let ngView: IDirective;

package/types-back/router/index.d.ts

@@ -1,17 +0,0 @@
-/**
- * Main entry point for angular 1.x build
- */ /** */
-export * from "./interface";
-export * from "./services";
-export * from "./statebuilders/views";
-export * from "./stateProvider";
-import "./injectables";
-import "./directives/stateDirectives";
-import "./stateFilters";
-import "./directives/viewDirective";
-import "./viewScroll";
-declare const _default: "router";
-export default _default;
-import * as core from "./core/index";
-export { core };
-export * from "./core/index";

package/types-back/router/interface.d.ts

@@ -1,500 +0,0 @@
-import {
-  StateDeclaration,
-  _ViewDeclaration,
-  IInjectable,
-  Transition,
-  HookResult,
-} from "./core";
-/**
- * The signature for Angular 1 State Transition Hooks.
- *
- * State hooks are registered as onEnter/onRetain/onExit in state declarations.
- * State hooks can additionally be injected with $transition$ and $state$ for
- * the current [[Transition]] and [[StateObject]] in the transition.
- *
- * Transition State Hooks are callback functions that hook into the lifecycle events of specific states during a transition.
- * As a transition runs, it may exit some states, retain (keep) states, and enter states.
- * As each lifecycle event occurs, the hooks which are registered for the event and that state are called (in priority order).
- *
- * #### See also:
- *
- * - [[IHookRegistry.onExit]]
- * - [[IHookRegistry.onRetain]]
- * - [[IHookRegistry.onEnter]]
- *
- * #### Example:
- * ```js
- * onEnter: function() { console.log('Entering'); }
- * ```
- *
- * Not minification-safe
- * ```js
- * onRetain: function($state$) { console.log('Retained ' + $state$.name); }
- * ```
- *
- * Annotated for minification-safety
- * ```js
- * onExit: [ '$transition$', '$state', function($transition$, $state) {
- *   // always redirect to 'foo' state when being exited
- *   if ($transition$.to().name !== 'foo') {
- *     return $state.target('foo');
- *   }
- * } ]
- * ```
- *
- * @returns an optional [[HookResult]] which may alter the transition
- */
-export interface Ng1StateTransitionHook {
-  (...injectables: any[]): HookResult;
-}
-/**
- * @internalapi
- * an intermediate interface.
- *
- * Used to reset [[StateDeclaration]] typings to `any` so the [[Ng1StateDeclaration]] interface can then narrow them */
-export interface _Ng1StateDeclaration extends StateDeclaration {
-  onExit?: any;
-  onRetain?: any;
-  onEnter?: any;
-  views?: any;
-}
-/**
- * The StateDeclaration object is used to define a state or nested state.
- * It should be registered with the [[StateRegistry]].
- *
- * #### Example:
- * ```js
- * // StateDeclaration object
- * var foldersState = {
- *   name: 'folders',
- *   url: '/folders',
- *   resolve: {
- *     allfolders: function(FolderService) {
- *       return FolderService.list();
- *     }
- *   },
- *   template: "<ul><li ng-repeat='folder in allfolders'>{{folder.name}}</li></ul>",
- *   controller: function(allfolders, $scope) {
- *     $scope.allfolders = allfolders;
- *   }
- * }
- * ```
- *
- * Since this interface extends [[Ng1ViewDeclaration]], any view declaration properties can be set directly
- * on the state declaration and they will be applied to the view with the name `$default`.  For example:
- *
- * ```js
- * var state = {
- *   name: 'foo',
- *   url: '/foo',
- *   template: '<h1>foo</h1>',
- *   controller: 'FooController'
- * }
- * ```
- *
- * is simply syntactic sugar for:
- *
- * ```js
- * var state = {
- *   name: 'foo',
- *   url: '/foo',
- *   views: {
- *     $default: {
- *       template: '<h1>foo</h1>',
- *       controller: 'FooController'
- *     }
- *   }
- * }
- * ```
- *
- * If a state definition contains a `views:` object, any view properties set directly on the state are ignored.
- * Thus, this is an invalid state defintion:
- *
- * ```js
- * var state = {
- *   name: 'foo',
- *   url: '/foo',
- *   controller: 'FooController', // invalid because views: exists
- *   views: {
- *     header: {
- *       template: '<h1>header</h1>'
- *     }
- *   }
- * }
- * ```
- */
-export interface Ng1StateDeclaration
-  extends _Ng1StateDeclaration,
-    Ng1ViewDeclaration {}
-export interface Ng1ViewDeclaration extends _ViewDeclaration {
-  /**
-   * The name of the component to use for this view.
-   *
-   * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
-   *
-   * The name of an [angular 1.5+ `.component()`](https://docs.angularjs.org/guide/component) (or directive with
-   * bindToController and/or scope declaration) which will be used for this view.
-   *
-   * Resolve data can be provided to the component via the component's `bindings` object (for 1.3+ directives, the
-   * `bindToController` is used; for other directives, the `scope` declaration is used).  For each binding declared
-   * on the component, any resolve with the same name is set on the component's controller instance.  The binding
-   * is provided to the component as a one-time-binding.  In general, components should likewise declare their
-   * input bindings as [one-way ("&lt;")](https://docs.angularjs.org/api/ng/service/$compile#-scope-).
-   *
-   * Note: inside a "views:" block, a bare string `"foo"` is shorthand for `{ component: "foo" }`
-   *
-   * Note: Mapping from resolve names to component inputs may be specified using [[bindings]].
-   *
-   * #### Example:
-   * ```js
-   * .state('profile', {
-   *   // Use the <my-profile></my-profile> component for the Unnamed view
-   *   component: 'MyProfile',
-   * }
-   *
-   * .state('messages', {
-   *   // use the <nav-bar></nav-bar> component for the view named 'header'
-   *   // use the <message-list></message-list> component for the view named 'content'
-   *   views: {
-   *     header: { component: 'NavBar' },
-   *     content: { component: 'MessageList' }
-   *   }
-   * }
-   *
-   * .state('contacts', {
-   *   // Inside a "views:" block, a bare string "NavBar" is shorthand for { component: "NavBar" }
-   *   // use the <nav-bar></nav-bar> component for the view named 'header'
-   *   // use the <contact-list></contact-list> component for the view named 'content'
-   *   views: {
-   *     header: 'NavBar',
-   *     content: 'ContactList'
-   *   }
-   * }
-   * ```
-   *
-   *
-   * Note: When using `component` to define a view, you may _not_ use any of: `template`, `templateUrl`,
-   * `templateProvider`, `controller`, `controllerProvider`, `controllerAs`.
-   *
-   *
-   * See also: Todd Motto's angular 1.3 and 1.4 [backport of .component()](https://github.com/toddmotto/angular-component)
-   */
-  component?: string;
-  /**
-   * An object which maps `resolve`s to [[component]] `bindings`.
-   *
-   * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
-   *
-   * When using a [[component]] declaration (`component: 'myComponent'`), each input binding for the component is supplied
-   * data from a resolve of the same name, by default.  You may supply data from a different resolve name by mapping it here.
-   *
-   * Each key in this object is the name of one of the component's input bindings.
-   * Each value is the name of the resolve that should be provided to that binding.
-   *
-   * Any component bindings that are omitted from this map get the default behavior of mapping to a resolve of the
-   * same name.
-   *
-   * #### Example:
-   * ```js
-   * $stateProvider.state('foo', {
-   *   resolve: {
-   *     foo: function(FooService) { return FooService.get(); },
-   *     bar: function(BarService) { return BarService.get(); }
-   *   },
-   *   component: 'Baz',
-   *   // The component's `baz` binding gets data from the `bar` resolve
-   *   // The component's `foo` binding gets data from the `foo` resolve (default behavior)
-   *   bindings: {
-   *     baz: 'bar'
-   *   }
-   * });
-   *
-   * app.component('Baz', {
-   *   templateUrl: 'baz.html',
-   *   controller: 'BazController',
-   *   bindings: {
-   *     foo: '<', // foo binding
-   *     baz: '<'  // baz binding
-   *   }
-   * });
-   * ```
-   *
-   */
-  bindings?: {
-    [key: string]: string;
-  };
-  /**
-   * Dynamic component provider function.
-   *
-   * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
-   *
-   * This is an injectable provider function which returns the name of the component to use.
-   * The provider will invoked during a Transition in which the view's state is entered.
-   * The provider is called after the resolve data is fetched.
-   *
-   * #### Example:
-   * ```js
-   * componentProvider: function(MyResolveData, $transition$) {
-   *   if (MyResolveData.foo) {
-   *     return "fooComponent"
-   *   } else if ($transition$.to().name === 'bar') {
-   *     return "barComponent";
-   *   }
-   * }
-   * ```
-   */
-  componentProvider?: IInjectable;
-  /**
-   * The view's controller function or name
-   *
-   * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
-   *
-   * The controller function, or the name of a registered controller.  The controller function will be used
-   * to control the contents of the [[directives.ngView]] directive.
-   *
-   * If specified as a string, controllerAs can be declared here, i.e., "FooController as foo" instead of in
-   * a separate [[controllerAs]] property.
-   *
-   * See: [[Ng1Controller]] for information about component-level router hooks.
-   */
-  controller?: IInjectable | string;
-  /**
-   * A controller alias name.
-   *
-   * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
-   *
-   * If present, the controller will be published to scope under the `controllerAs` name.
-   * See: https://docs.angularjs.org/api/ng/directive/ngController
-   */
-  controllerAs?: string;
-  /**
-   * Dynamic controller provider function.
-   *
-   * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
-   *
-   * This is an injectable provider function which returns the actual controller function, or the name
-   * of a registered controller.  The provider will invoked during a Transition in which the view's state is
-   * entered.  The provider is called after the resolve data is fetched.
-   *
-   * #### Example:
-   * ```js
-   * controllerProvider: function(MyResolveData, $transition$) {
-   *   if (MyResolveData.foo) {
-   *     return "FooCtrl"
-   *   } else if ($transition$.to().name === 'bar') {
-   *     return "BarCtrl";
-   *   } else {
-   *     return function($scope) {
-   *       $scope.baz = "Qux";
-   *     }
-   *   }
-   * }
-   * ```
-   */
-  controllerProvider?: IInjectable;
-  /**
-   * The scope variable name to use for resolve data.
-   *
-   * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
-   *
-   * When a view is activated, the resolved data for the state which the view belongs to is put on the scope.
-   * This property sets the name of the scope variable to use for the resolved data.
-   *
-   * Defaults to `$resolve`.
-   */
-  resolveAs?: string;
-  /**
-   * The HTML template for the view.
-   *
-   * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
-   *
-   * HTML template as a string, or a function which returns an html template as a string.
-   * This template will be used to render the corresponding [[directives.ngView]] directive.
-   *
-   * This property takes precedence over templateUrl.
-   *
-   * If `template` is a function, it will be called with the Transition parameters as the first argument.
-   *
-   * #### Example:
-   * ```js
-   * template: "<h1>inline template definition</h1><div ui-view></div>"
-   * ```
-   *
-   * #### Example:
-   * ```js
-   * template: function(params) {
-   *   return "<h1>generated template</h1>";
-   * }
-   * ```
-   */
-  template?: Function | string;
-  /**
-   * The URL for the HTML template for the view.
-   *
-   * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
-   *
-   * A path or a function that returns a path to an html template.
-   * The template will be fetched and used to render the corresponding [[directives.ngView]] directive.
-   *
-   * If `templateUrl` is a function, it will be called with the Transition parameters as the first argument.
-   *
-   * #### Example:
-   * ```js
-   * templateUrl: "/templates/home.html"
-   * ```
-   *
-   * #### Example:
-   * ```js
-   * templateUrl: function(params) {
-   *   return myTemplates[params.pageId];
-   * }
-   * ```
-   */
-  templateUrl?: string | Function;
-  /**
-   * Injected function which returns the HTML template.
-   *
-   * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
-   *
-   * Injected function which returns the HTML template.
-   * The template will be used to render the corresponding [[directives.ngView]] directive.
-   *
-   * #### Example:
-   * ```js
-   * templateProvider: function(MyTemplateService, $transition$) {
-   *   return MyTemplateService.getTemplate($transition$.params().pageId);
-   * }
-   * ```
-   */
-  templateProvider?: IInjectable;
-}
-/**
- * The shape of a controller for a view (and/or component), defining the controller callbacks.
- *
- * A view in Router is comprised of either a `component` ([[Ng1ViewDeclaration.component]]) or a combination of a
- * `template` (or `templateProvider`) and a `controller` (or `controllerProvider`).
- *
- * The `controller` object (or the `component`'s controller object) can define component-level controller callbacks,
- * which Router will call at the appropriate times.  These callbacks are similar to Transition Hooks
- * ([[IHookRegistry]]), but are only called if the view is currently active.
- *
- * This interface defines the Router component callbacks.
- *
- */
-export interface Ng1Controller {
-  /** @hidden */
-  $onInit(): void;
-  /**
-   * This callback is called when parameter values have changed.
-   *
-   * This callback can be used to respond to changing parameter values in the current state, or in parent/child states.
-   * This callback is especially handy when using dynamic parameters ([[ParamDeclaration.dynamic]])
-   *
-   * Called when:
-   * - The view is still active
-   * - A new transition has completed successfully
-   * - The state for the view (controller) was not reloaded
-   * - At least one parameter value was changed
-   *
-   * Called with:
-   * @param newValues an object containing the changed parameter values
-   * @param $transition$ the new Transition which triggered this callback
-   *
-   * #### Example:
-   * ```js
-   * angular.module('foo').controller('FancyCtrl', function() {
-   *   this.uiOnParamsChanged = function(newParams) {
-   *     console.log("new params: ", newParams);
-   *   }
-   * });
-   * ```
-   */
-  uiOnParamsChanged(newValues: any, $transition$: Transition): void;
-  /**
-   * This callback is called when the view's state is about to be exited.
-   *
-   * This callback is used to inform a view that it is about to be exited, due to a new [[Transition]].
-   * The callback can ask for user confirmation, and cancel or alter the new Transition.  The callback should
-   * return a value, or a promise for a value.  If a promise is returned, the new Transition waits until the
-   * promise settles.
-   *
-   *
-   * Called when:
-   * - The view is still active
-   * - A new Transition is about to run
-   * - The new Transition will exit the view's state
-   *
-   * Called with:
-   * - The new Transition
-   *
-   * Relevant return Values:
-   * - `false`: The transition is cancelled.
-   * - A rejected promise: The transition is cancelled.
-   * - [[TargetState]]: The transition is redirected to the new target state.
-   * - Anything else: the transition will continue normally (the state and view will be deactivated)
-   *
-   * #### Example:
-   * ```js
-   * app.component('myComponent', {
-   *   template: '<input ng-model="$ctrl.data" type="text">',
-   *   bindings: { 'data': '<' },
-   *   controller: function() {
-   *
-   *     this.originalData = angular.copy(this.data);
-   *
-   *     this.uiCanExit = function() {
-   *       if (!angular.equals(this.data, this.originalData)) {
-   *         // Note: This could also return a Promise and request async
-   *         // confirmation using something like ui-bootstrap $modal
-   *         return window.confirm("Data has changed.  Exit anyway and lose changes?");
-   *       }
-   *     }
-   *   }
-   * }
-   * ```
-   *
-   * @param transition the new Transition that is about to exit the component's state
-   * @return a HookResult, or a promise for a HookResult
-   */
-  uiCanExit(transition: Transition): HookResult;
-}
-/**
- * Manages which template-loading mechanism to use.
- *
- * Defaults to `$templateRequest` on Angular versions starting from 1.3, `$http` otherwise.
- */
-export interface TemplateFactoryProvider {
-  /**
-   * Forces $templateFactory to use $http instead of $templateRequest.
-   *
-   * Router uses `$templateRequest` by default on angular 1.3+.
-   * Use this method to choose to use `$http` instead.
-   *
-   * ---
-   *
-   * ## Security warning
-   *
-   * This might cause XSS, as $http doesn't enforce the regular security checks for
-   * templates that have been introduced in Angular 1.3.
-   *
-   * See the $sce documentation, section
-   * <a href="https://docs.angularjs.org/api/ng/service/$sce#impact-on-loading-templates">
-   * Impact on loading templates</a> for more details about this mechanism.
-   *
-   * *Note: forcing this to `false` on Angular 1.2.x will crash, because `$templateRequest` is not implemented.*
-   *
-   * @param useUnsafeHttpService `true` to use `$http` to fetch templates
-   */
-  useHttpService(useUnsafeHttpService: boolean): any;
-}
-declare module "@uirouter/core/lib/state/stateRegistry" {
-  interface StateRegistry {
-    register(
-      state:
-        | Ng1StateDeclaration
-        | {
-            new (): Ng1StateDeclaration;
-          },
-    ): any;
-  }
-}

package/types-back/router/legacy/resolveService.d.ts

@@ -1,47 +0,0 @@
-import { Obj } from "../core";
-/** @hidden */
-export declare const resolveFactory: () => {
-  /**
-   * Asynchronously injects a resolve block.
-   *
-   * This emulates most of the behavior of the ui-router 0.2.x $resolve.resolve() service API.
-   *
-   * ### Not bundled by default
-   *
-   * This API is no longer not part of the standard `@uirouter/angularjs` bundle.
-   * For users of the prebuilt bundles, add the `release/resolveService.min.js` UMD bundle.
-   * For bundlers (webpack, browserify, etc), add `@uirouter/angularjs/lib/legacy/resolveService`.
-   *
-   * ---
-   *
-   * Given an object `invocables`, where keys are strings and values are injectable functions,
-   * injects each function, and waits for the resulting promise to resolve.
-   * When all resulting promises are resolved, returns the results as an object.
-   *
-   * #### Example:
-   * ```js
-   * let invocables = {
-   *   foo: [ '$http', ($http) =>
-   *            $http.get('/api/foo').then(resp => resp.data) ],
-   *   bar: [ 'foo', '$http', (foo, $http) =>
-   *            $http.get('/api/bar/' + foo.barId).then(resp => resp.data) ]
-   * }
-   * $resolve.resolve(invocables)
-   *     .then(results => console.log(results.foo, results.bar))
-   * // Logs foo and bar:
-   * // { id: 123, barId: 456, fooData: 'foo data' }
-   * // { id: 456, barData: 'bar data' }
-   * ```
-   *
-   * @param invocables an object which looks like an [[StateDeclaration.resolve]] object; keys are resolve names and values are injectable functions
-   * @param locals key/value pre-resolved data (locals)
-   * @param parent a promise for a "parent resolve"
-   */
-  resolve: (
-    invocables: {
-      [key: string]: Function;
-    },
-    locals?: {},
-    parent?: Promise<any>,
-  ) => Promise<Obj>;
-};