@angular-wave/angular.ts 0.0.16 → 0.0.17

package/types/router/core/url/urlService.d.ts

@@ -0,0 +1,206 @@
+import { UIRouter } from '../router';
+import { LocationServices } from '../common';
+import { MatchResult, UrlParts, UrlSyncApi } from './interface';
+import { UrlRules } from './urlRules';
+import { UrlConfig } from './urlConfig';
+/**
+ * API for URL management
+ */
+export declare class UrlService implements LocationServices, UrlSyncApi {
+    private router;
+    /** @internal */ private _stopListeningFn;
+    /** @internal */ interceptDeferred: boolean;
+    /**
+     * The nested [[UrlRules]] API for managing URL rules and rewrites
+     *
+     * See: [[UrlRules]] for details
+     */
+    rules: UrlRules;
+    /**
+     * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
+     *
+     * See: [[UrlConfig]] for details
+     */
+    config: UrlConfig;
+    /** @internal */
+    constructor(/** @internal */ router: UIRouter);
+    /** @internal */
+    dispose(): void;
+    /**
+     * Gets the current URL parts
+     *
+     * This method returns the different parts of the current URL (the [[path]], [[search]], and [[hash]]) as a [[UrlParts]] object.
+     */
+    parts(): UrlParts;
+    /**
+     * Activates the best rule for the current URL
+     *
+     * Checks the current URL for a matching [[UrlRule]], then invokes that rule's handler.
+     * This method is called internally any time the URL has changed.
+     *
+     * This effectively activates the state (or redirect, etc) which matches the current URL.
+     *
+     * #### Example:
+     * ```js
+     * urlService.deferIntercept();
+     *
+     * fetch('/states.json').then(resp => resp.json()).then(data => {
+     *   data.forEach(state => $stateRegistry.register(state));
+     *   urlService.listen();
+     *   // Find the matching URL and invoke the handler.
+     *   urlService.sync();
+     * });
+     * ```
+     */
+    sync(evt?: any): void;
+    /**
+     * Starts or stops listening for URL changes
+     *
+     * Call this sometime after calling [[deferIntercept]] to start monitoring the url.
+     * This causes UI-Router to start listening for changes to the URL, if it wasn't already listening.
+     *
+     * If called with `false`, UI-Router will stop listening (call listen(true) to start listening again).
+     *
+     * #### Example:
+     * ```js
+     * urlService.deferIntercept();
+     *
+     * fetch('/states.json').then(resp => resp.json()).then(data => {
+     *   data.forEach(state => $stateRegistry.register(state));
+     *   // Start responding to URL changes
+     *   urlService.listen();
+     *   urlService.sync();
+     * });
+     * ```
+     *
+     * @param enabled `true` or `false` to start or stop listening to URL changes
+     */
+    listen(enabled?: boolean): Function;
+    /**
+     * 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
+     * // Prevent UI-Router from automatically intercepting URL changes when it starts;
+     * urlService.deferIntercept();
+     *
+     * fetch('/states.json').then(resp => resp.json()).then(data => {
+     *   data.forEach(state => $stateRegistry.register(state));
+     *   urlService.listen();
+     *   urlService.sync();
+     * });
+     * ```
+     *
+     * @param defer Indicates whether to defer location change interception.
+     *        Passing no parameter is equivalent to `true`.
+     */
+    deferIntercept(defer?: boolean): void;
+    /**
+     * Matches a URL
+     *
+     * Given a URL (as a [[UrlParts]] object), check all rules and determine the best matching rule.
+     * Return the result as a [[MatchResult]].
+     */
+    match(url: UrlParts): MatchResult;
+    /**
+     * Gets the current url, or updates the url
+     *
+     * ### Getting the current URL
+     *
+     * When no arguments are passed, returns the current URL.
+     * The URL is normalized using the internal [[path]]/[[search]]/[[hash]] values.
+     *
+     * For example, the URL may be stored in the hash ([[HashLocationServices]]) or
+     * have a base HREF prepended ([[PushStateLocationServices]]).
+     *
+     * The raw URL in the browser might be:
+     *
+     * ```
+     * http://mysite.com/somepath/index.html#/internal/path/123?param1=foo#anchor
+     * ```
+     *
+     * or
+     *
+     * ```
+     * http://mysite.com/basepath/internal/path/123?param1=foo#anchor
+     * ```
+     *
+     * then this method returns:
+     *
+     * ```
+     * /internal/path/123?param1=foo#anchor
+     * ```
+     *
+     *
+     * #### Example:
+     * ```js
+     * locationServices.url(); // "/some/path?query=value#anchor"
+     * ```
+     *
+     * ### Updating the URL
+     *
+     * When `newurl` arguments is provided, changes the URL to reflect `newurl`
+     *
+     * #### Example:
+     * ```js
+     * locationServices.url("/some/path?query=value#anchor", true);
+     * ```
+     *
+     * @param newurl The new value for the URL.
+     *               This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.
+     *               It should not include the protocol, site, port, or base path of an absolute HREF.
+     * @param replace When true, replaces the current history entry (instead of appending it) with this new url
+     * @param state The history's state object, i.e., pushState (if the LocationServices implementation supports it)
+     *
+     * @return the url (after potentially being processed)
+     */
+    url: (newurl?: string, replace?: boolean, state?: any) => string;
+    /**
+     * Gets the path part of the current url
+     *
+     * If the current URL is `/some/path?query=value#anchor`, this returns `/some/path`
+     *
+     * @return the path portion of the url
+     */
+    path: () => string;
+    /**
+     * Gets the search part of the current url as an object
+     *
+     * If the current URL is `/some/path?query=value#anchor`, this returns `{ query: 'value' }`
+     *
+     * @return the search (query) portion of the url, as an object
+     */
+    search: () => {
+        [key: string]: any;
+    };
+    /**
+     * Gets the hash part of the current url
+     *
+     * If the current URL is `/some/path?query=value#anchor`, this returns `anchor`
+     *
+     * @return the hash (anchor) portion of the url
+     */
+    hash: () => string;
+    /**
+     * @internal
+     *
+     * Registers a low level url change handler
+     *
+     * Note: Because this is a low level handler, it's not recommended for general use.
+     *
+     * #### Example:
+     * ```js
+     * let deregisterFn = locationServices.onChange((evt) => console.log("url change", evt));
+     * ```
+     *
+     * @param callback a function that will be called when the url is changing
+     * @return a function that de-registers the callback
+     */
+    onChange: (callback: EventListener) => Function;
+}

package/types/router/core/vanilla.d.ts

@@ -0,0 +1 @@
+export * from './vanilla/index';

package/types/router/core/view/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interface';
+export * from './view';

package/types/router/core/view/interface.d.ts

@@ -0,0 +1,46 @@
+import { _ViewDeclaration } from '../state/interface';
+import { PathNode } from '../path/pathNode';
+/** The context ref can be anything that has a `name` and a `parent` reference to another IContextRef */
+export interface ViewContext {
+    name: string;
+    parent: ViewContext;
+}
+export interface ActiveUIView {
+    /** type of framework, e.g., "ng1" or "ng2" */
+    $type: string;
+    /** An auto-incremented id */
+    id: number;
+    /** The ui-view short name */
+    name: string;
+    /** The ui-view's fully qualified name */
+    fqn: string;
+    /** The ViewConfig that is currently loaded into the ui-view */
+    config: ViewConfig;
+    /** The state context in which the ui-view tag was created. */
+    creationContext: ViewContext;
+    /** A callback that should apply a ViewConfig (or clear the ui-view, if config is undefined) */
+    configUpdated: (config: ViewConfig) => void;
+}
+/**
+ * This interface represents a [[_ViewDeclaration]] that is bound to a [[PathNode]].
+ *
+ * A `ViewConfig` is the runtime definition of a single view.
+ *
+ * During a transition, `ViewConfig`s are created for each [[_ViewDeclaration]] defined on each "entering" [[StateObject]].
+ * Then, the [[ViewService]] finds any matching `ui-view`(s) in the DOM, and supplies the ui-view
+ * with the `ViewConfig`.  The `ui-view` then loads itself using the information found in the `ViewConfig`.
+ *
+ * A `ViewConfig` if matched with a `ui-view` by finding all `ui-view`s which were created in the
+ * context named by the `uiViewContextAnchor`, and finding the `ui-view` or child `ui-view` that matches
+ * the `uiViewName` address.
+ */
+export interface ViewConfig {
+    $id: number;
+    /** The normalized view declaration from [[State.views]] */
+    viewDecl: _ViewDeclaration;
+    /** The node the ViewConfig is bound to */
+    path: PathNode[];
+    loaded: boolean;
+    /** Fetches templates, runs dynamic (controller|template)Provider code, lazy loads Components, etc */
+    load(): Promise<ViewConfig>;
+}

package/types/router/core/view/view.d.ts

@@ -0,0 +1,167 @@
+import { TypedMap } from '../common/common';
+import { PathNode } from '../path/pathNode';
+import { ActiveUIView, ViewContext, ViewConfig } from './interface';
+import { _ViewDeclaration } from '../state/interface';
+import { UIRouter } from '../router';
+export declare type ViewConfigFactory = (path: PathNode[], decl: _ViewDeclaration) => ViewConfig | ViewConfig[];
+export interface ViewServicePluginAPI {
+    _rootViewContext(context?: ViewContext): ViewContext;
+    _viewConfigFactory(viewType: string, factory: ViewConfigFactory): any;
+    /** @param id router.$id + "." + uiView.id */
+    _registeredUIView(id: string): ActiveUIView;
+    _registeredUIViews(): ActiveUIView[];
+    _activeViewConfigs(): ViewConfig[];
+    _onSync(listener: ViewSyncListener): Function;
+}
+export interface ViewTuple {
+    uiView: ActiveUIView;
+    viewConfig: ViewConfig;
+}
+export interface ViewSyncListener {
+    (viewTuples: ViewTuple[]): void;
+}
+/**
+ * The View service
+ *
+ * This service pairs existing `ui-view` components (which live in the DOM)
+ * with view configs (from the state declaration objects: [[StateDeclaration.views]]).
+ *
+ * - After a successful Transition, the views from the newly entered states are activated via [[activateViewConfig]].
+ *   The views from exited states are deactivated via [[deactivateViewConfig]].
+ *   (See: the [[registerActivateViews]] Transition Hook)
+ *
+ * - As `ui-view` components pop in and out of existence, they register themselves using [[registerUIView]].
+ *
+ * - When the [[sync]] function is called, the registered `ui-view`(s) ([[ActiveUIView]])
+ * are configured with the matching [[ViewConfig]](s)
+ *
+ */
+export declare class ViewService {
+    private router;
+    /** @internal */ private _uiViews;
+    /** @internal */ private _viewConfigs;
+    /** @internal */ private _rootContext;
+    /** @internal */ private _viewConfigFactories;
+    /** @internal */ private _listeners;
+    /** @internal */
+    _pluginapi: ViewServicePluginAPI;
+    /**
+     * Given a ui-view and a ViewConfig, determines if they "match".
+     *
+     * A ui-view has a fully qualified name (fqn) and a context object.  The fqn is built from its overall location in
+     * the DOM, describing its nesting relationship to any parent ui-view tags it is nested inside of.
+     *
+     * A ViewConfig has a target ui-view name and a context anchor.  The ui-view name can be a simple name, or
+     * can be a segmented ui-view path, describing a portion of a ui-view fqn.
+     *
+     * In order for a ui-view to match ViewConfig, ui-view's $type must match the ViewConfig's $type
+     *
+     * If the ViewConfig's target ui-view name is a simple name (no dots), then a ui-view matches if:
+     * - the ui-view's name matches the ViewConfig's target name
+     * - the ui-view's context matches the ViewConfig's anchor
+     *
+     * If the ViewConfig's target ui-view name is a segmented name (with dots), then a ui-view matches if:
+     * - There exists a parent ui-view where:
+     *    - the parent ui-view's name matches the first segment (index 0) of the ViewConfig's target name
+     *    - the parent ui-view's context matches the ViewConfig's anchor
+     * - And the remaining segments (index 1..n) of the ViewConfig's target name match the tail of the ui-view's fqn
+     *
+     * Example:
+     *
+     * DOM:
+     * <ui-view>                        <!-- created in the root context (name: "") -->
+     *   <ui-view name="foo">                <!-- created in the context named: "A"      -->
+     *     <ui-view>                    <!-- created in the context named: "A.B"    -->
+     *       <ui-view name="bar">            <!-- created in the context named: "A.B.C"  -->
+     *       </ui-view>
+     *     </ui-view>
+     *   </ui-view>
+     * </ui-view>
+     *
+     * uiViews: [
+     *  { fqn: "$default",                  creationContext: { name: "" } },
+     *  { fqn: "$default.foo",              creationContext: { name: "A" } },
+     *  { fqn: "$default.foo.$default",     creationContext: { name: "A.B" } }
+     *  { fqn: "$default.foo.$default.bar", creationContext: { name: "A.B.C" } }
+     * ]
+     *
+     * These four view configs all match the ui-view with the fqn: "$default.foo.$default.bar":
+     *
+     * - ViewConfig1: { uiViewName: "bar",                       uiViewContextAnchor: "A.B.C" }
+     * - ViewConfig2: { uiViewName: "$default.bar",              uiViewContextAnchor: "A.B" }
+     * - ViewConfig3: { uiViewName: "foo.$default.bar",          uiViewContextAnchor: "A" }
+     * - ViewConfig4: { uiViewName: "$default.foo.$default.bar", uiViewContextAnchor: "" }
+     *
+     * Using ViewConfig3 as an example, it matches the ui-view with fqn "$default.foo.$default.bar" because:
+     * - The ViewConfig's segmented target name is: [ "foo", "$default", "bar" ]
+     * - There exists a parent ui-view (which has fqn: "$default.foo") where:
+     *    - the parent ui-view's name "foo" matches the first segment "foo" of the ViewConfig's target name
+     *    - the parent ui-view's context "A" matches the ViewConfig's anchor context "A"
+     * - And the remaining segments [ "$default", "bar" ].join("."_ of the ViewConfig's target name match
+     *   the tail of the ui-view's fqn "default.bar"
+     *
+     * @internal
+     */
+    static matches: (uiViewsByFqn: TypedMap<ActiveUIView>, uiView: ActiveUIView) => (viewConfig: ViewConfig) => boolean;
+    /**
+     * Normalizes a view's name from a state.views configuration block.
+     *
+     * This should be used by a framework implementation to calculate the values for
+     * [[_ViewDeclaration.$uiViewName]] and [[_ViewDeclaration.$uiViewContextAnchor]].
+     *
+     * @param context the context object (state declaration) that the view belongs to
+     * @param rawViewName the name of the view, as declared in the [[StateDeclaration.views]]
+     *
+     * @returns the normalized uiViewName and uiViewContextAnchor that the view targets
+     */
+    static normalizeUIViewTarget(context: ViewContext, rawViewName?: string): {
+        uiViewName: string;
+        uiViewContextAnchor: string;
+    };
+    /** @internal */
+    constructor(/** @internal */ router: UIRouter);
+    /** @internal */
+    private _rootViewContext;
+    /** @internal */
+    private _viewConfigFactory;
+    createViewConfig(path: PathNode[], decl: _ViewDeclaration): ViewConfig[];
+    /**
+     * Deactivates a ViewConfig.
+     *
+     * This function deactivates a `ViewConfig`.
+     * After calling [[sync]], it will un-pair from any `ui-view` with which it is currently paired.
+     *
+     * @param viewConfig The ViewConfig view to deregister.
+     */
+    deactivateViewConfig(viewConfig: ViewConfig): void;
+    activateViewConfig(viewConfig: ViewConfig): void;
+    sync(): void;
+    /**
+     * Registers a `ui-view` component
+     *
+     * When a `ui-view` component is created, it uses this method to register itself.
+     * After registration the [[sync]] method is used to ensure all `ui-view` are configured with the proper [[ViewConfig]].
+     *
+     * Note: the `ui-view` component uses the `ViewConfig` to determine what view should be loaded inside the `ui-view`,
+     * and what the view's state context is.
+     *
+     * Note: There is no corresponding `deregisterUIView`.
+     *       A `ui-view` should hang on to the return value of `registerUIView` and invoke it to deregister itself.
+     *
+     * @param uiView The metadata for a UIView
+     * @return a de-registration function used when the view is destroyed.
+     */
+    registerUIView(uiView: ActiveUIView): () => void;
+    /**
+     * Returns the list of views currently available on the page, by fully-qualified name.
+     *
+     * @return {Array} Returns an array of fully-qualified view names.
+     */
+    available(): any[];
+    /**
+     * Returns the list of views on the page containing loaded content.
+     *
+     * @return {Array} Returns an array of fully-qualified view names.
+     */
+    active(): any[];
+}

package/types/router/directives/stateDirectives.d.ts

@@ -0,0 +1,3 @@
+/** @hidden Used for typedoc */
+export interface ng1_directive {
+}

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

@@ -0,0 +1,143 @@
+/** @publicapi @module directives */ /** */
+import { ActiveUIView } from './core';
+import { Ng1ViewConfig } from '../statebuilders/views';
+import { ng1_directive } from './stateDirectives';
+/** @hidden */
+export declare type UIViewData = {
+    $cfg: Ng1ViewConfig;
+    $uiView: ActiveUIView;
+};
+/** @hidden */
+export declare type UIViewAnimData = {
+    $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 [[$uiViewScroll]] 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 uiView: ng1_directive;

package/types/router/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Main entry point for angular 1.x build
+ * @publicapi @module ng1
+ */ /** */
+export * from './interface';
+export * from './services';
+export * from './statebuilders/views';
+export * from './stateProvider';
+export * from './urlRouterProvider';
+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';