diff --git a/angular-idle/angular-idle-tests.ts b/angular-idle/angular-idle-tests.ts
index fc39bf72a..e6eb1a9f2 100644
--- a/angular-idle/angular-idle-tests.ts
+++ b/angular-idle/angular-idle-tests.ts
@@ -1,23 +1,53 @@
///
angular.module('app', ['ngIdle'])
- .config(['$keepaliveProvider', '$idleProvider',
- ($keepaliveProvider: ng.idle.IKeepAliveProvider, $idleProvider: ng.idle.IIdleProvider) => {
- $idleProvider.activeOn('mousemove keydown DOMMouseScroll mousewheel mousedown');
- $idleProvider.idleDuration(5);
- $idleProvider.warningDuration(5);
- $idleProvider.keepalive(true)
- $idleProvider.autoResume(true);
- $keepaliveProvider.interval(10);
+ .config(['KeepaliveProvider', 'IdleProvider', 'TitleProvider',
+ (keepaliveProvider: angular.idle.IKeepAliveProvider, idleProvider: angular.idle.IIdleProvider,
+ titleProvider: angular.idle.ITitleProvider) => {
+ idleProvider.interrupt('mousemove keydown DOMMouseScroll mousewheel mousedown');
+ idleProvider.idle(5);
+ idleProvider.timeout(5);
+ idleProvider.keepalive(true)
+ idleProvider.autoResume(true);
+
+ const config: ng.IRequestConfig = {
+ url: "http://google.com",
+ method: "GET"
+ };
+
+ keepaliveProvider.http(config.url); // should accept string and ng.IRequestConfig
+ keepaliveProvider.http(config);
+ keepaliveProvider.interval(10);
+
+ titleProvider.enabled(true);
}])
- .run(['$keepalive', '$idle', ($keepalive: ng.idle.IKeepAliveService, $idle: ng.idle.IIdleService) => {
- $idle.watch();
-
- if ($idle.running() || $idle.idling()) {
- $idle.unwatch();
+ .run(['Keepalive', 'Idle', 'Title', (Keepalive: angular.idle.IKeepAliveService, Idle: angular.idle.IIdleService,
+ Title: angular.idle.ITitleService) => {
+ Idle.setTimeout(Idle.getTimeout());
+ Idle.setIdle(Idle.getIdle());
+
+ Idle.watch();
+ Idle.interrupt();
+
+ const expired: boolean = Idle.isExpired();
+
+ if (Idle.running() || Idle.idling()) {
+ Idle.unwatch();
}
-
- $keepalive.start();
- $keepalive.ping();
- $keepalive.stop();
+
+ Keepalive.start();
+ Keepalive.ping();
+ Keepalive.stop();
+ Keepalive.setInterval(10);
+
+ Title.setEnabled(Title.isEnabled());
+ Title.original(Title.original());
+ Title.value(Title.value());
+ Title.store(false);
+ Title.store();
+ Title.restore();
+ Title.idleMessage(Title.idleMessage());
+ Title.timedOutMessage(Title.timedOutMessage());
+ Title.setAsIdle(120);
+ Title.setAsTimedOut();
}]);
\ No newline at end of file
diff --git a/angular-idle/angular-idle.d.ts b/angular-idle/angular-idle.d.ts
index 4e1e98fb5..725beac67 100644
--- a/angular-idle/angular-idle.d.ts
+++ b/angular-idle/angular-idle.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for ng-idle v0.3.5
+// Type definitions for ng-idle v1.1.1
// Project: http://hackedbychinese.github.io/ng-idle/
// Definitions by: mthamil
// Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -8,7 +8,99 @@
declare module angular.idle {
/**
- * Used to configure the $keepalive service.
+ * Used to configure the Title service.
+ */
+ interface ITitleProvider extends IServiceProvider {
+
+ /**
+ * Enables or disables the Title functionality.
+ *
+ * @param enabled Boolean, default is true.
+ */
+ enabled(enabled: boolean): void;
+ }
+
+ interface ITitleService {
+
+ /**
+ * Allows the title functionality to be enabled or disabled on the fly.
+ */
+ setEnabled(enabled: boolean): void;
+
+ /**
+ * Returns whether or not the title functionality has been enabled.
+ */
+ isEnabled(): boolean;
+
+ /**
+ * Will store val as the "original" title of the document.
+ *
+ * Tracking the original title is important when restoring the title after displaying, for example, the idle warning message.
+ */
+ original(val: string): void;
+
+ /**
+ * Returns the "original" title value that has been previously set.
+ *
+ * Tracking the original title is important when restoring the title after displaying, for example, the idle warning message.
+ */
+ original(): string;
+
+ /**
+ * Changes the actual title of the document.
+ */
+ value(val: string): void;
+
+ /**
+ * Returns the current document title.
+ */
+ value(): string;
+
+ /**
+ * If overwrite is false or unspecified, updates the "original" title with the current document title
+ * if it has not already been stored. If overwrite is true, the current document title is stored regardless.
+ */
+ store(overwrite?: boolean): void;
+
+ /**
+ * Sets the title to the original value (if it was stored or set previously).
+ */
+ restore(): void;
+
+ /**
+ * Sets the text to use as the message displayed when the user is idle.
+ */
+ idleMessage(val: string): void;
+
+ /**
+ * Gets the text to use as the message displayed when the user is idle.
+ */
+ idleMessage(): string;
+
+ /**
+ * Sets the text to use as the message displayed when the user is timed out.
+ */
+ timedOutMessage(val: string): void;
+
+ /**
+ * Gets the text to use as the message displayed when the user is timed out.
+ */
+ timedOutMessage(): string;
+
+ /**
+ * Stores the original title if it hasn't been already, determines the number minutes, seconds,
+ * and total seconds from countdown, and displays the idleMessage with the aforementioned values interpolated.
+ */
+ setAsIdle(countdown: number): void;
+
+ /**
+ * Stores the original title if it hasn't been already, and displays the timedOutMessage.
+ */
+ setAsTimedOut(): void;
+ }
+
+ /**
+ * Used to configure the Keepalive service.
*/
interface IKeepAliveProvider extends IServiceProvider {
@@ -18,24 +110,24 @@ declare module angular.idle {
* You can specify a string, which it will assume to be a URL to a simple GET request.
* Otherwise, you can use the same options $http takes. However, cache will always be false.
*
- * @param value May be string or object, default is null.
+ * @param value May be string or IRequestConfig, default is null.
*/
- http(value: any): void;
+ http(value: string | IRequestConfig): void;
/**
* This specifies how often the keepalive event is triggered and the
* HTTP request is issued.
*
- * @param seconds Integer, default is 5 minutes. Must be greater than 0.
+ * @param seconds Integer, default is 10 minutes. Must be greater than 0.
*/
interval(seconds: number): void;
}
/**
- * $keepalive will use a timeout to periodically wake, broadcast a $keepalive event on the root scope,
- * and optionally make an $http request. By default, the $idle service will stop and start $keepalive
+ * Keepalive will use a timeout to periodically wake, broadcast a Keepalive event on the root scope,
+ * and optionally make an $http request. By default, the Idle service will stop and start Keepalive
* when a user becomes idle or returns from idle, respectively. It is also started automatically when
- * $idle.watch() is called. This can be disabled by configuring the $idleProvider.
+ * Idle.watch() is called. This can be disabled by configuring the IdleProvider.
*/
interface IKeepAliveService {
@@ -53,20 +145,25 @@ declare module angular.idle {
* Performs one ping only.
*/
ping(): void;
+
+ /**
+ * Changes the interval value at runtime.
+ * You will need to restart the pinging process by calling start() manually for the changes to be reflected.
+ */
+ setInterval(seconds: number): void;
}
/**
- * Used to configure the $idle service.
+ * Used to configure the Idle service.
*/
interface IIdleProvider extends IServiceProvider {
-
/**
* Specifies the DOM events the service will watch to reset the idle timeout.
* Multiple events should be separated by a space.
*
* @param events string, default 'mousemove keydown DOMMouseScroll mousewheel mousedown'
*/
- activeOn(events: string): void;
+ interrupt(events: string): void;
/**
* The idle timeout duration in seconds. After this amount of time passes without the user
@@ -75,7 +172,7 @@ declare module angular.idle {
*
* @param seconds integer, default is 20min
*/
- idleDuration(seconds: number): void;
+ idle(seconds: number): void;
/**
* The amount of time the user has to respond (in seconds) before they have been considered
@@ -83,19 +180,20 @@ declare module angular.idle {
*
* @param seconds integer, default is 30s
*/
- warningDuration(seconds: number): void;
+ timeout(seconds: number): void;
/**
- * When true, user activity will automatically interrupt the warning countdown and reset the
- * idle state. If false, you will need to manually call watch() when you want to start
- * watching for idleness again.
+ * When true or idle, user activity will automatically interrupt the warning countdown
+ * and reset the idle state. If false or off, you will need to manually call watch()
+ * when you want to start watching for idleness again. If notIdle, user activity will
+ * only automatically interrupt if the user is not yet idle.
*
- * @param enabled boolean, default is true
+ * @param enabled boolean or string, possible values: off/false, idle/true, or notIdle
*/
- autoResume(enabled: boolean): void;
+ autoResume(enabled: boolean | string): void;
/**
- * When true, the $keepalive service is automatically stopped and started as needed.
+ * When true, the Keepalive service is automatically stopped and started as needed.
*
* @param enabled boolean, default is true
*/
@@ -103,13 +201,39 @@ declare module angular.idle {
}
/**
- * $idle, once watch() is called, will start a timeout which if expires, will enter a warning state
+ * Idle, once watch() is called, will start a timeout which if expires, will enter a warning state
* countdown. Once the countdown reaches zero, idle will broadcast a timeout event indicating the
* user has timed out (where your app should log them out or whatever you like). If the user performs
* an action that triggers a watched DOM event that bubbles up to document.body, this will reset the
* idle/warning state and start the process over again.
*/
interface IIdleService {
+ /**
+ * Gets the current idle value
+ */
+ getIdle(): number;
+
+ /**
+ * Gets the current timeout value
+ */
+ getTimeout(): number;
+
+ /**
+ * Updates the idle value (see IdleProvider.idle()) and
+ * restarts the watch if its running.
+ */
+ setIdle(idle: number): void;
+
+ /**
+ * Updates the timeout value (see IdleProvider.timeout()) and
+ * restarts the watch if its running.
+ */
+ setTimeout(timeout: number): void;
+
+ /**
+ * Whether user has timed out (meaning idleDuration + timeout has passed without any activity)
+ */
+ isExpired(): boolean;
/**
* Whether or not the watch() has been called and it is watching for idleness.
@@ -130,5 +254,10 @@ declare module angular.idle {
* Stops watching for idleness, and resets the idle/warning state.
*/
unwatch(): void;
+
+ /**
+ * Manually trigger the idle interrupt that normally occurs during user activity.
+ */
+ interrupt(): any;
}
}