@angular-wave/angular.ts 0.0.16 → 0.0.17

package/types/router/services.d.ts

@@ -0,0 +1,15 @@
+import { IRootScopeService } from '../';
+import { ResolveContext, TypedMap } from './core';
+import { StateProvider } from './stateProvider';
+declare module './core/lib/router' {
+    interface UIRouter {
+        /** @hidden */
+        stateProvider: StateProvider;
+    }
+}
+export declare function watchDigests($rootScope: IRootScopeService): void;
+export declare namespace watchDigests {
+    var $inject: string[];
+}
+/** @hidden TODO: find a place to move this */
+export declare const getLocals: (ctx: ResolveContext) => TypedMap<any>;

package/types/router/stateFilters.d.ts

@@ -0,0 +1,11 @@
+/** @publicapi @module ng1 */ /** */
+import { StateService } from './core';
+declare function $IsStateFilter($state: StateService): any;
+declare namespace $IsStateFilter {
+    var $inject: string[];
+}
+declare function $IncludedByStateFilter($state: StateService): any;
+declare namespace $IncludedByStateFilter {
+    var $inject: string[];
+}
+export { $IsStateFilter, $IncludedByStateFilter };

package/types/router/stateProvider.d.ts

@@ -0,0 +1,254 @@
+/** @publicapi @module ng1 */ /** */
+import { BuilderFunction, StateRegistry, StateService, OnInvalidCallback } from './core';
+import { Ng1StateDeclaration } from './interface';
+/**
+ * The Angular 1 `StateProvider`
+ *
+ * The `$stateProvider` works similar to Angular's v1 router, but it focuses purely
+ * on state.
+ *
+ * A state corresponds to a "place" in the application in terms of the overall UI and
+ * navigation. A state describes (via the controller / template / view properties) what
+ * the UI looks like and does at that place.
+ *
+ * States often have things in common, and the primary way of factoring out these
+ * commonalities in this model is via the state hierarchy, i.e. parent/child states aka
+ * nested states.
+ *
+ * The `$stateProvider` provides interfaces to declare these states for your app.
+ */
+export declare class StateProvider {
+    private stateRegistry;
+    private stateService;
+    constructor(stateRegistry: StateRegistry, stateService: StateService);
+    /**
+     * Decorates states when they are registered
+     *
+     * Allows you to extend (carefully) or override (at your own peril) the
+     * `stateBuilder` object used internally by [[StateRegistry]].
+     * This can be used to add custom functionality to ui-router,
+     * for example inferring templateUrl based on the state name.
+     *
+     * When passing only a name, it returns the current (original or decorated) builder
+     * function that matches `name`.
+     *
+     * The builder functions that can be decorated are listed below. Though not all
+     * necessarily have a good use case for decoration, that is up to you to decide.
+     *
+     * In addition, users can attach custom decorators, which will generate new
+     * properties within the state's internal definition. There is currently no clear
+     * use-case for this beyond accessing internal states (i.e. $state.$current),
+     * however, expect this to become increasingly relevant as we introduce additional
+     * meta-programming features.
+     *
+     * **Warning**: Decorators should not be interdependent because the order of
+     * execution of the builder functions in non-deterministic. Builder functions
+     * should only be dependent on the state definition object and super function.
+     *
+     *
+     * Existing builder functions and current return values:
+     *
+     * - **parent** `{object}` - returns the parent state object.
+     * - **data** `{object}` - returns state data, including any inherited data that is not
+     *   overridden by own values (if any).
+     * - **url** `{object}` - returns a {@link ui.router.util.type:UrlMatcher UrlMatcher}
+     *   or `null`.
+     * - **navigable** `{object}` - returns closest ancestor state that has a URL (aka is
+     *   navigable).
+     * - **params** `{object}` - returns an array of state params that are ensured to
+     *   be a super-set of parent's params.
+     * - **views** `{object}` - returns a views object where each key is an absolute view
+     *   name (i.e. "viewName@stateName") and each value is the config object
+     *   (template, controller) for the view. Even when you don't use the views object
+     *   explicitly on a state config, one is still created for you internally.
+     *   So by decorating this builder function you have access to decorating template
+     *   and controller properties.
+     * - **ownParams** `{object}` - returns an array of params that belong to the state,
+     *   not including any params defined by ancestor states.
+     * - **path** `{string}` - returns the full path from the root down to this state.
+     *   Needed for state activation.
+     * - **includes** `{object}` - returns an object that includes every state that
+     *   would pass a `$state.includes()` test.
+     *
+     * #### Example:
+     * Override the internal 'views' builder with a function that takes the state
+     * definition, and a reference to the internal function being overridden:
+     * ```js
+     * $stateProvider.decorator('views', function (state, parent) {
+     *   let result = {},
+     *       views = parent(state);
+     *
+     *   angular.forEach(views, function (config, name) {
+     *     let autoName = (state.name + '.' + name).replace('.', '/');
+     *     config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';
+     *     result[name] = config;
+     *   });
+     *   return result;
+     * });
+     *
+     * $stateProvider.state('home', {
+     *   views: {
+     *     'contact.list': { controller: 'ListController' },
+     *     'contact.item': { controller: 'ItemController' }
+     *   }
+     * });
+     * ```
+     *
+     *
+     * ```js
+     * // Auto-populates list and item views with /partials/home/contact/list.html,
+     * // and /partials/home/contact/item.html, respectively.
+     * $state.go('home');
+     * ```
+     *
+     * @param {string} name The name of the builder function to decorate.
+     * @param {object} func A function that is responsible for decorating the original
+     * builder function. The function receives two parameters:
+     *
+     *   - `{object}` - state - The state config object.
+     *   - `{object}` - super - The original builder function.
+     *
+     * @return {object} $stateProvider - $stateProvider instance
+     */
+    decorator(name: string, func: BuilderFunction): Function | this;
+    /**
+     * Registers a state
+     *
+     * ### This is a passthrough to [[StateRegistry.register]].
+     *
+     * Registers a state configuration under a given state name.
+     * The stateConfig object has the following acceptable properties.
+     *
+     * <a id='template'></a>
+     *
+     * - **`template`** - {string|function=} - html template as a string or a function that returns
+     *   an html template as a string which should be used by the uiView directives. This property
+     *   takes precedence over templateUrl.
+     *
+     *   If `template` is a function, it will be called with the following parameters:
+     *
+     *   - {array.&lt;object&gt;} - state parameters extracted from the current $location.path() by
+     *     applying the current state
+     *
+     * <a id='templateUrl'></a>
+     *
+     * - **`templateUrl`** - {string|function=} - path or function that returns a path to an html
+     *   template that should be used by uiView.
+     *
+     *   If `templateUrl` is a function, it will be called with the following parameters:
+     *
+     *   - {array.&lt;object&gt;} - state parameters extracted from the current $location.path() by
+     *     applying the current state
+     *
+     * <a id='templateProvider'></a>
+     *
+     * - **`templateProvider`** - {function=} - Provider function that returns HTML content
+     *   string.
+     *
+     * <a id='controller'></a>
+     *
+     * - **`controller`** - {string|function=} -  Controller fn that should be associated with newly
+     *   related scope or the name of a registered controller if passed as a string.
+     *
+     * <a id='controllerProvider'></a>
+     *
+     * - **`controllerProvider`** - {function=} - Injectable provider function that returns
+     *   the actual controller or string.
+     *
+     * <a id='controllerAs'></a>
+     *
+     * - **`controllerAs`** – {string=} – A controller alias name. If present the controller will be
+     *   published to scope under the controllerAs name.
+     *
+     * <a id='resolve'></a>
+     *
+     * - **`resolve`** - {object.&lt;string, function&gt;=} - An optional map of dependencies which
+     *   should be injected into the controller. If any of these dependencies are promises,
+     *   the router will wait for them all to be resolved or one to be rejected before the
+     *   controller is instantiated. If all the promises are resolved successfully, the values
+     *   of the resolved promises are injected and $stateChangeSuccess event is fired. If any
+     *   of the promises are rejected the $stateChangeError event is fired. The map object is:
+     *
+     *   - key - {string}: name of dependency to be injected into controller
+     *   - factory - {string|function}: If string then it is alias for service. Otherwise if function,
+     *     it is injected and return value it treated as dependency. If result is a promise, it is
+     *     resolved before its value is injected into controller.
+     *
+     * <a id='url'></a>
+     *
+     * - **`url`** - {string=} - A url with optional parameters. When a state is navigated or
+     *   transitioned to, the `$stateParams` service will be populated with any
+     *   parameters that were passed.
+     *
+     * <a id='params'></a>
+     *
+     * - **`params`** - {object=} - An array of parameter names or regular expressions. Only
+     *   use this within a state if you are not using url. Otherwise you can specify your
+     *   parameters within the url. When a state is navigated or transitioned to, the
+     *   $stateParams service will be populated with any parameters that were passed.
+     *
+     * <a id='views'></a>
+     *
+     * - **`views`** - {object=} - Use the views property to set up multiple views or to target views
+     *   manually/explicitly.
+     *
+     * <a id='abstract'></a>
+     *
+     * - **`abstract`** - {boolean=} - An abstract state will never be directly activated,
+     *   but can provide inherited properties to its common children states.
+     *
+     * <a id='onEnter'></a>
+     *
+     * - **`onEnter`** - {object=} - Callback function for when a state is entered. Good way
+     *   to trigger an action or dispatch an event, such as opening a dialog.
+     * If minifying your scripts, make sure to use the `['injection1', 'injection2', function(injection1, injection2){}]` syntax.
+     *
+     * <a id='onExit'></a>
+     *
+     * - **`onExit`** - {object=} - Callback function for when a state is exited. Good way to
+     *   trigger an action or dispatch an event, such as opening a dialog.
+     * If minifying your scripts, make sure to use the `['injection1', 'injection2', function(injection1, injection2){}]` syntax.
+     *
+     * <a id='reloadOnSearch'></a>
+     *
+     * - **`reloadOnSearch = true`** - {boolean=} - If `false`, will not retrigger the same state
+     *   just because a search/query parameter has changed (via $location.search() or $location.hash()).
+     *   Useful for when you'd like to modify $location.search() without triggering a reload.
+     *
+     * <a id='data'></a>
+     *
+     * - **`data`** - {object=} - Arbitrary data object, useful for custom configuration.
+     *
+     * #### Example:
+     * Some state name examples
+     * ```js
+     * // stateName can be a single top-level name (must be unique).
+     * $stateProvider.state("home", {});
+     *
+     * // Or it can be a nested state name. This state is a child of the
+     * // above "home" state.
+     * $stateProvider.state("home.newest", {});
+     *
+     * // Nest states as deeply as needed.
+     * $stateProvider.state("home.newest.abc.xyz.inception", {});
+     *
+     * // state() returns $stateProvider, so you can chain state declarations.
+     * $stateProvider
+     *   .state("home", {})
+     *   .state("about", {})
+     *   .state("contacts", {});
+     * ```
+     *
+     * @param {string} name A unique state name, e.g. "home", "about", "contacts".
+     * To create a parent/child state use a dot, e.g. "about.sales", "home.newest".
+     * @param {object} definition State configuration object.
+     */
+    state(name: string, definition: Ng1StateDeclaration): StateProvider;
+    state(definition: Ng1StateDeclaration): StateProvider;
+    /**
+     * Registers an invalid state handler
+     *
+     * This is a passthrough to [[StateService.onInvalid]] for ng1.
+     */
+    onInvalid(callback: OnInvalidCallback): Function;
+}

package/types/router/statebuilders/onEnterExitRetain.d.ts

@@ -0,0 +1,12 @@
+/** @publicapi @module ng1 */ /** */
+import { StateObject, TransitionStateHookFn } from './core';
+/**
+ * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
+ * `onRetain` callback hooks on a [[Ng1StateDeclaration]].
+ *
+ * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
+ * ensures that those hooks are injectable for @uirouter/angularjs (ng1).
+ *
+ * @internalapi
+ */
+export declare const getStateHookBuilder: (hookName: 'onEnter' | 'onExit' | 'onRetain') => (stateObject: StateObject) => TransitionStateHookFn;

package/types/router/statebuilders/views.d.ts

@@ -0,0 +1,41 @@
+/** @publicapi @module ng1 */ /** */
+import { StateObject, ViewConfig, ViewConfigFactory, PathNode, ResolveContext, IInjectable } from './core';
+import { Ng1ViewDeclaration } from '../interface';
+import { TemplateFactory } from '../templateFactory';
+/** @internalapi */
+export declare function getNg1ViewConfigFactory(): ViewConfigFactory;
+/**
+ * This is a [[StateBuilder.builder]] function for angular1 `views`.
+ *
+ * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
+ * handles the `views` property with logic specific to @uirouter/angularjs (ng1).
+ *
+ * If no `views: {}` property exists on the [[StateDeclaration]], then it creates the `views` object
+ * and applies the state-level configuration to a view named `$default`.
+ *
+ * @internalapi
+ */
+export declare function ng1ViewsBuilder(state: StateObject): {
+    [key: string]: Ng1ViewDeclaration;
+};
+/** @internalapi */
+export declare class Ng1ViewConfig implements ViewConfig {
+    path: PathNode[];
+    viewDecl: Ng1ViewDeclaration;
+    factory: TemplateFactory;
+    $id: number;
+    loaded: boolean;
+    controller: Function;
+    template: string;
+    component: string;
+    locals: any;
+    constructor(path: PathNode[], viewDecl: Ng1ViewDeclaration, factory: TemplateFactory);
+    load(): Promise<this>;
+    getTemplate: (uiView: any, context: ResolveContext) => string;
+    /**
+     * Gets the controller for a view configuration.
+     *
+     * @returns {Function|Promise.<Function>} Returns a controller, or a promise that resolves to a controller.
+     */
+    getController(context: ResolveContext): IInjectable | string | Promise<IInjectable | string>;
+}

package/types/router/templateFactory.d.ts

@@ -0,0 +1,84 @@
+import { IAugmentedJQuery } from '../';
+import { IInjectable, ResolveContext, RawParams } from './core';
+import { Ng1ViewDeclaration, TemplateFactoryProvider } from './interface';
+/**
+ * Service which manages loading of templates from a ViewConfig.
+ */
+export declare class TemplateFactory implements TemplateFactoryProvider {
+    /** @hidden */ private _useHttp;
+    /** @hidden */ private $templateRequest;
+    /** @hidden */ private $templateCache;
+    /** @hidden */ private $http;
+    /** @hidden */ $get: (string | (($http: any, $templateCache: any, $injector: any) => this))[];
+    /** @hidden */
+    useHttpService(value: boolean): void;
+    /**
+     * Creates a template from a configuration object.
+     *
+     * @param config Configuration object for which to load a template.
+     * The following properties are search in the specified order, and the first one
+     * that is defined is used to create the template:
+     *
+     * @param params  Parameters to pass to the template function.
+     * @param context The resolve context associated with the template's view
+     *
+     * @return {string|object}  The template html as a string, or a promise for
+     * that string,or `null` if no template is configured.
+     */
+    fromConfig(config: Ng1ViewDeclaration, params: any, context: ResolveContext): Promise<{
+        template?: string;
+        component?: string;
+    }>;
+    /**
+     * Creates a template from a string or a function returning a string.
+     *
+     * @param template html template as a string or function that returns an html template as a string.
+     * @param params Parameters to pass to the template function.
+     *
+     * @return {string|object} The template html as a string, or a promise for that
+     * string.
+     */
+    fromString(template: string | Function, params?: RawParams): any;
+    /**
+     * Loads a template from the a URL via `$http` and `$templateCache`.
+     *
+     * @param {string|Function} url url of the template to load, or a function
+     * that returns a url.
+     * @param {Object} params Parameters to pass to the url function.
+     * @return {string|Promise.<string>} The template html as a string, or a promise
+     * for that string.
+     */
+    fromUrl(url: string | Function, params: any): any;
+    /**
+     * Creates a template by invoking an injectable provider function.
+     *
+     * @param provider Function to invoke via `locals`
+     * @param {Function} injectFn a function used to invoke the template provider
+     * @return {string|Promise.<string>} The template html as a string, or a promise
+     * for that string.
+     */
+    fromProvider(provider: IInjectable, params: any, context: ResolveContext): Promise<any>;
+    /**
+     * Creates a component's template by invoking an injectable provider function.
+     *
+     * @param provider Function to invoke via `locals`
+     * @param {Function} injectFn a function used to invoke the template provider
+     * @return {string} The template html as a string: "<component-name input1='::$resolve.foo'></component-name>".
+     */
+    fromComponentProvider(provider: IInjectable, params: any, context: ResolveContext): Promise<any>;
+    /**
+     * Creates a template from a component's name
+     *
+     * This implements route-to-component.
+     * It works by retrieving the component (directive) metadata from the injector.
+     * It analyses the component's bindings, then constructs a template that instantiates the component.
+     * The template wires input and output bindings to resolves or from the parent component.
+     *
+     * @param uiView {object} The parent ui-view (for binding outputs to callbacks)
+     * @param context The ResolveContext (for binding outputs to callbacks returned from resolves)
+     * @param component {string} Component's name in camel case.
+     * @param bindings An object defining the component's bindings: {foo: '<'}
+     * @return {string} The template as a string: "<component-name input1='::$resolve.foo'></component-name>".
+     */
+    makeComponentTemplate(uiView: IAugmentedJQuery, context: ResolveContext, component: string, bindings?: any): string;
+}

package/types/router/viewScroll.d.ts

@@ -0,0 +1,9 @@
+export interface UIViewScrollProvider {
+    /**
+     * Uses standard anchorScroll behavior
+     *
+     * Reverts [[$uiViewScroll]] back to using the core [`$anchorScroll`](http://docs.angularjs.org/api/ng.$anchorScroll)
+     * service for scrolling based on the url anchor.
+     */
+    useAnchorScroll(): void;
+}