1/**
2 * Heartbeat API
3 *
4 * Heartbeat is a simple server polling API that sends XHR requests to
5 * the server every 15 - 60 seconds and triggers events (or callbacks) upon
6 * receiving data. Currently these 'ticks' handle transports for post locking,
7 * login-expiration warnings, autosave, and related tasks while a user is logged in.
8 *
9 * Available PHP filters (in ajax-actions.php):
10 * - heartbeat_received
11 * - heartbeat_send
12 * - heartbeat_tick
13 * - heartbeat_nopriv_received
14 * - heartbeat_nopriv_send
15 * - heartbeat_nopriv_tick
16 * @see wp_ajax_nopriv_heartbeat(), wp_ajax_heartbeat()
17 *
18 * Custom jQuery events:
19 * - heartbeat-send
20 * - heartbeat-tick
21 * - heartbeat-error
22 * - heartbeat-connection-lost
23 * - heartbeat-connection-restored
24 * - heartbeat-nonces-expired
25 *
26 * @since 3.6.0
27 * @output wp-includes/js/heartbeat.js
28 */
29
30( function( $, window, undefined ) {
31
32 /**
33 * Constructs the Heartbeat API.
34 *
35 * @since 3.6.0
36 *
37 * @return {Object} An instance of the Heartbeat class.
38 * @constructor
39 */
40 var Heartbeat = function() {
41 var $document = $(document),
42 settings = {
43 // Suspend/resume.
44 suspend: false,
45
46 // Whether suspending is enabled.
47 suspendEnabled: true,
48
49 // Current screen id, defaults to the JS global 'pagenow' when present
50 // (in the admin) or 'front'.
51 screenId: '',
52
53 // XHR request URL, defaults to the JS global 'ajaxurl' when present.
54 url: '',
55
56 // Timestamp, start of the last connection request.
57 lastTick: 0,
58
59 // Container for the enqueued items.
60 queue: {},
61
62 // Connect interval (in seconds).
63 mainInterval: 60,
64
65 // Used when the interval is set to 5 seconds temporarily.
66 tempInterval: 0,
67
68 // Used when the interval is reset.
69 originalInterval: 0,
70
71 // Used to limit the number of Ajax requests.
72 minimalInterval: 0,
73
74 // Used together with tempInterval.
75 countdown: 0,
76
77 // Whether a connection is currently in progress.
78 connecting: false,
79
80 // Whether a connection error occurred.
81 connectionError: false,
82
83 // Used to track non-critical errors.
84 errorcount: 0,
85
86 // Whether at least one connection has been completed successfully.
87 hasConnected: false,
88
89 // Whether the current browser window is in focus and the user is active.
90 hasFocus: true,
91
92 // Timestamp, last time the user was active. Checked every 30 seconds.
93 userActivity: 0,
94
95 // Flag whether events tracking user activity were set.
96 userActivityEvents: false,
97
98 // Timer that keeps track of how long a user has focus.
99 checkFocusTimer: 0,
100
101 // Timer that keeps track of how long needs to be waited before connecting to
102 // the server again.
103 beatTimer: 0
104 };
105
106 /**
107 * Sets local variables and events, then starts the heartbeat.
108 *
109 * @since 3.8.0
110 * @access private
111 *
112 * @return {void}
113 */
114 function initialize() {
115 var options, hidden, visibilityState, visibilitychange;
116
117 if ( typeof window.pagenow === 'string' ) {
118 settings.screenId = window.pagenow;
119 }
120
121 if ( typeof window.ajaxurl === 'string' ) {
122 settings.url = window.ajaxurl;
123 }
124
125 // Pull in options passed from PHP.
126 if ( typeof window.heartbeatSettings === 'object' ) {
127 options = window.heartbeatSettings;
128
129 // The XHR URL can be passed as option when window.ajaxurl is not set.
130 if ( ! settings.url && options.ajaxurl ) {
131 settings.url = options.ajaxurl;
132 }
133
134 /*
135 * Logic check: the interval can be from 1 to 3600 seconds and can be set temporarily
136 * to 5 seconds. It can be set in the initial options or changed later from JS
137 * or from PHP through the AJAX responses.
138 */
139 if ( options.interval ) {
140 settings.mainInterval = options.interval;
141
142 if ( settings.mainInterval < 1 ) {
143 settings.mainInterval = 1;
144 } else if ( settings.mainInterval > 3600 ) {
145 settings.mainInterval = 3600;
146 }
147 }
148
149 /*
150 * Used to limit the number of Ajax requests. Overrides all other intervals
151 * if they are shorter. Needed for some hosts that cannot handle frequent requests
152 * and the user may exceed the allocated server CPU time, etc. The minimal interval
153 * can be up to 600 seconds, however setting it to longer than 120 seconds
154 * will limit or disable some of the functionality (like post locks).
155 * Once set at initialization, minimalInterval cannot be changed/overridden.
156 */
157 if ( options.minimalInterval ) {
158 options.minimalInterval = parseInt( options.minimalInterval, 10 );
159 settings.minimalInterval = options.minimalInterval > 0 && options.minimalInterval <= 600 ? options.minimalInterval : 0;
160 }
161
162 if ( settings.minimalInterval && settings.mainInterval < settings.minimalInterval ) {
163 settings.mainInterval = settings.minimalInterval;
164 }
165
166 // 'screenId' can be added from settings on the front end where the JS global
167 // 'pagenow' is not set.
168 if ( ! settings.screenId ) {
169 settings.screenId = options.screenId || 'front';
170 }
171
172 if ( options.suspension === 'disable' ) {
173 settings.suspendEnabled = false;
174 }
175 }
176
177 // Convert to milliseconds.
178 settings.mainInterval = settings.mainInterval * 1000;
179 settings.originalInterval = settings.mainInterval;
180 if ( settings.minimalInterval ) {
181 settings.minimalInterval = settings.minimalInterval * 1000;
182 }
183
184 /*
185 * Switch the interval to 120 seconds by using the Page Visibility API.
186 * If the browser doesn't support it (Safari < 7, Android < 4.4, IE < 10), the
187 * interval will be increased to 120 seconds after 5 minutes of mouse and keyboard
188 * inactivity.
189 */
190 if ( typeof document.hidden !== 'undefined' ) {
191 hidden = 'hidden';
192 visibilitychange = 'visibilitychange';
193 visibilityState = 'visibilityState';
194 } else if ( typeof document.msHidden !== 'undefined' ) { // IE10.
195 hidden = 'msHidden';
196 visibilitychange = 'msvisibilitychange';
197 visibilityState = 'msVisibilityState';
198 } else if ( typeof document.webkitHidden !== 'undefined' ) { // Android.
199 hidden = 'webkitHidden';
200 visibilitychange = 'webkitvisibilitychange';
201 visibilityState = 'webkitVisibilityState';
202 }
203
204 if ( hidden ) {
205 if ( document[hidden] ) {
206 settings.hasFocus = false;
207 }
208
209 $document.on( visibilitychange + '.wp-heartbeat', function() {
210 if ( document[visibilityState] === 'hidden' ) {
211 blurred();
212 window.clearInterval( settings.checkFocusTimer );
213 } else {
214 focused();
215 if ( document.hasFocus ) {
216 settings.checkFocusTimer = window.setInterval( checkFocus, 10000 );
217 }
218 }
219 });
220 }
221
222 // Use document.hasFocus() if available.
223 if ( document.hasFocus ) {
224 settings.checkFocusTimer = window.setInterval( checkFocus, 10000 );
225 }
226
227 $(window).on( 'pagehide.wp-heartbeat', function() {
228 // Don't connect anymore.
229 suspend();
230
231 // Abort the last request if not completed.
232 if ( settings.xhr && settings.xhr.readyState !== 4 ) {
233 settings.xhr.abort();
234 }
235 });
236
237 $(window).on(
238 'pageshow.wp-heartbeat',
239 /**
240 * Handles pageshow event, specifically when page navigation is restored from back/forward cache.
241 *
242 * @param {jQuery.Event} event
243 * @param {PageTransitionEvent} event.originalEvent
244 */
245 function ( event ) {
246 if ( event.originalEvent.persisted ) {
247 /*
248 * When page navigation is stored via bfcache (Back/Forward Cache), consider this the same as
249 * if the user had just switched to the tab since the behavior is similar.
250 */
251 focused();
252 }
253 }
254 );
255
256 // Check for user activity every 30 seconds.
257 window.setInterval( checkUserActivity, 30000 );
258
259 // Start one tick after DOM ready.
260 $( function() {
261 settings.lastTick = time();
262 scheduleNextTick();
263 });
264 }
265
266 /**
267 * Returns the current time according to the browser.
268 *
269 * @since 3.6.0
270 * @access private
271 *
272 * @return {number} Returns the current time.
273 */
274 function time() {
275 return (new Date()).getTime();
276 }
277
278 /**
279 * Checks if the iframe is from the same origin.
280 *
281 * @since 3.6.0
282 * @access private
283 *
284 * @return {boolean} Returns whether or not the iframe is from the same origin.
285 */
286 function isLocalFrame( frame ) {
287 var origin, src = frame.src;
288
289 /*
290 * Need to compare strings as WebKit doesn't throw JS errors when iframes have
291 * different origin. It throws uncatchable exceptions.
292 */
293 if ( src && /^https?:\/\//.test( src ) ) {
294 origin = window.location.origin ? window.location.origin : window.location.protocol + '//' + window.location.host;
295
296 if ( src.indexOf( origin ) !== 0 ) {
297 return false;
298 }
299 }
300
301 try {
302 if ( frame.contentWindow.document ) {
303 return true;
304 }
305 } catch(e) {}
306
307 return false;
308 }
309
310 /**
311 * Checks if the document's focus has changed.
312 *
313 * @since 4.1.0
314 * @access private
315 *
316 * @return {void}
317 */
318 function checkFocus() {
319 if ( settings.hasFocus && ! document.hasFocus() ) {
320 blurred();
321 } else if ( ! settings.hasFocus && document.hasFocus() ) {
322 focused();
323 }
324 }
325
326 /**
327 * Sets error state and fires an event on XHR errors or timeout.
328 *
329 * @since 3.8.0
330 * @access private
331 *
332 * @param {string} error The error type passed from the XHR.
333 * @param {number} status The HTTP status code passed from jqXHR
334 * (200, 404, 500, etc.).
335 *
336 * @return {void}
337 */
338 function setErrorState( error, status ) {
339 var trigger;
340
341 if ( error ) {
342 switch ( error ) {
343 case 'abort':
344 // Do nothing.
345 break;
346 case 'timeout':
347 // No response for 30 seconds.
348 trigger = true;
349 break;
350 case 'error':
351 if ( 503 === status && settings.hasConnected ) {
352 trigger = true;
353 break;
354 }
355 /* falls through */
356 case 'parsererror':
357 case 'empty':
358 case 'unknown':
359 settings.errorcount++;
360
361 if ( settings.errorcount > 2 && settings.hasConnected ) {
362 trigger = true;
363 }
364
365 break;
366 }
367
368 if ( trigger && ! hasConnectionError() ) {
369 settings.connectionError = true;
370 $document.trigger( 'heartbeat-connection-lost', [error, status] );
371 wp.hooks.doAction( 'heartbeat.connection-lost', error, status );
372 }
373 }
374 }
375
376 /**
377 * Clears the error state and fires an event if there is a connection error.
378 *
379 * @since 3.8.0
380 * @access private
381 *
382 * @return {void}
383 */
384 function clearErrorState() {
385 // Has connected successfully.
386 settings.hasConnected = true;
387
388 if ( hasConnectionError() ) {
389 settings.errorcount = 0;
390 settings.connectionError = false;
391 $document.trigger( 'heartbeat-connection-restored' );
392 wp.hooks.doAction( 'heartbeat.connection-restored' );
393 }
394 }
395
396 /**
397 * Gathers the data and connects to the server.
398 *
399 * @since 3.6.0
400 * @access private
401 *
402 * @return {void}
403 */
404 function connect() {
405 var ajaxData, heartbeatData;
406
407 // If the connection to the server is slower than the interval,
408 // heartbeat connects as soon as the previous connection's response is received.
409 if ( settings.connecting || settings.suspend ) {
410 return;
411 }
412
413 settings.lastTick = time();
414
415 heartbeatData = $.extend( {}, settings.queue );
416 // Clear the data queue. Anything added after this point will be sent on the next tick.
417 settings.queue = {};
418
419 $document.trigger( 'heartbeat-send', [ heartbeatData ] );
420 wp.hooks.doAction( 'heartbeat.send', heartbeatData );
421
422 ajaxData = {
423 data: heartbeatData,
424 interval: settings.tempInterval ? settings.tempInterval / 1000 : settings.mainInterval / 1000,
425 _nonce: typeof window.heartbeatSettings === 'object' ? window.heartbeatSettings.nonce : '',
426 action: 'heartbeat',
427 screen_id: settings.screenId,
428 has_focus: settings.hasFocus
429 };
430
431 if ( 'customize' === settings.screenId ) {
432 ajaxData.wp_customize = 'on';
433 }
434
435 settings.connecting = true;
436 settings.xhr = $.ajax({
437 url: settings.url,
438 type: 'post',
439 timeout: 30000, // Throw an error if not completed after 30 seconds.
440 data: ajaxData,
441 dataType: 'json'
442 }).always( function() {
443 settings.connecting = false;
444 scheduleNextTick();
445 }).done( function( response, textStatus, jqXHR ) {
446 var newInterval;
447
448 if ( ! response ) {
449 setErrorState( 'empty' );
450 return;
451 }
452
453 clearErrorState();
454
455 if ( response.nonces_expired ) {
456 $document.trigger( 'heartbeat-nonces-expired' );
457 wp.hooks.doAction( 'heartbeat.nonces-expired' );
458 }
459
460 // Change the interval from PHP.
461 if ( response.heartbeat_interval ) {
462 newInterval = response.heartbeat_interval;
463 delete response.heartbeat_interval;
464 }
465
466 // Update the heartbeat nonce if set.
467 if ( response.heartbeat_nonce && typeof window.heartbeatSettings === 'object' ) {
468 window.heartbeatSettings.nonce = response.heartbeat_nonce;
469 delete response.heartbeat_nonce;
470 }
471
472 // Update the Rest API nonce if set and wp-api loaded.
473 if ( response.rest_nonce && typeof window.wpApiSettings === 'object' ) {
474 window.wpApiSettings.nonce = response.rest_nonce;
475 // This nonce is required for api-fetch through heartbeat.tick.
476 // delete response.rest_nonce;
477 }
478
479 $document.trigger( 'heartbeat-tick', [response, textStatus, jqXHR] );
480 wp.hooks.doAction( 'heartbeat.tick', response, textStatus, jqXHR );
481
482 // Do this last. Can trigger the next XHR if connection time > 5 seconds and newInterval == 'fast'.
483 if ( newInterval ) {
484 interval( newInterval );
485 }
486 }).fail( function( jqXHR, textStatus, error ) {
487 setErrorState( textStatus || 'unknown', jqXHR.status );
488 $document.trigger( 'heartbeat-error', [jqXHR, textStatus, error] );
489 wp.hooks.doAction( 'heartbeat.error', jqXHR, textStatus, error );
490 });
491 }
492
493 /**
494 * Schedules the next connection.
495 *
496 * Fires immediately if the connection time is longer than the interval.
497 *
498 * @since 3.8.0
499 * @access private
500 *
501 * @return {void}
502 */
503 function scheduleNextTick() {
504 var delta = time() - settings.lastTick,
505 interval = settings.mainInterval;
506
507 if ( settings.suspend ) {
508 return;
509 }
510
511 if ( ! settings.hasFocus ) {
512 interval = 120000; // 120 seconds. Post locks expire after 150 seconds.
513 } else if ( settings.countdown > 0 && settings.tempInterval ) {
514 interval = settings.tempInterval;
515 settings.countdown--;
516
517 if ( settings.countdown < 1 ) {
518 settings.tempInterval = 0;
519 }
520 }
521
522 if ( settings.minimalInterval && interval < settings.minimalInterval ) {
523 interval = settings.minimalInterval;
524 }
525
526 window.clearTimeout( settings.beatTimer );
527
528 if ( delta < interval ) {
529 settings.beatTimer = window.setTimeout(
530 function() {
531 connect();
532 },
533 interval - delta
534 );
535 } else {
536 connect();
537 }
538 }
539
540 /**
541 * Sets the internal state when the browser window becomes hidden or loses focus.
542 *
543 * @since 3.6.0
544 * @access private
545 *
546 * @return {void}
547 */
548 function blurred() {
549 settings.hasFocus = false;
550 }
551
552 /**
553 * Sets the internal state when the browser window becomes visible or is in focus.
554 *
555 * @since 3.6.0
556 * @access private
557 *
558 * @return {void}
559 */
560 function focused() {
561 settings.userActivity = time();
562
563 // Resume if suspended.
564 resume();
565
566 if ( ! settings.hasFocus ) {
567 settings.hasFocus = true;
568 scheduleNextTick();
569 }
570 }
571
572 /**
573 * Suspends connecting.
574 */
575 function suspend() {
576 settings.suspend = true;
577 }
578
579 /**
580 * Resumes connecting.
581 */
582 function resume() {
583 settings.suspend = false;
584 }
585
586 /**
587 * Runs when the user becomes active after a period of inactivity.
588 *
589 * @since 3.6.0
590 * @access private
591 *
592 * @return {void}
593 */
594 function userIsActive() {
595 settings.userActivityEvents = false;
596 $document.off( '.wp-heartbeat-active' );
597
598 $('iframe').each( function( i, frame ) {
599 if ( isLocalFrame( frame ) ) {
600 $( frame.contentWindow ).off( '.wp-heartbeat-active' );
601 }
602 });
603
604 focused();
605 }
606
607 /**
608 * Checks for user activity.
609 *
610 * Runs every 30 seconds. Sets 'hasFocus = true' if user is active and the window
611 * is in the background. Sets 'hasFocus = false' if the user has been inactive
612 * (no mouse or keyboard activity) for 5 minutes even when the window has focus.
613 *
614 * @since 3.8.0
615 * @access private
616 *
617 * @return {void}
618 */
619 function checkUserActivity() {
620 var lastActive = settings.userActivity ? time() - settings.userActivity : 0;
621
622 // Throttle down when no mouse or keyboard activity for 5 minutes.
623 if ( lastActive > 300000 && settings.hasFocus ) {
624 blurred();
625 }
626
627 // Suspend after 10 minutes of inactivity when suspending is enabled.
628 // Always suspend after 60 minutes of inactivity. This will release the post lock, etc.
629 if ( ( settings.suspendEnabled && lastActive > 600000 ) || lastActive > 3600000 ) {
630 suspend();
631 }
632
633 if ( ! settings.userActivityEvents ) {
634 $document.on( 'mouseover.wp-heartbeat-active keyup.wp-heartbeat-active touchend.wp-heartbeat-active', function() {
635 userIsActive();
636 });
637
638 $('iframe').each( function( i, frame ) {
639 if ( isLocalFrame( frame ) ) {
640 $( frame.contentWindow ).on( 'mouseover.wp-heartbeat-active keyup.wp-heartbeat-active touchend.wp-heartbeat-active', function() {
641 userIsActive();
642 });
643 }
644 });
645
646 settings.userActivityEvents = true;
647 }
648 }
649
650 // Public methods.
651
652 /**
653 * Checks whether the window (or any local iframe in it) has focus, or the user
654 * is active.
655 *
656 * @since 3.6.0
657 * @memberOf wp.heartbeat.prototype
658 *
659 * @return {boolean} True if the window or the user is active.
660 */
661 function hasFocus() {
662 return settings.hasFocus;
663 }
664
665 /**
666 * Checks whether there is a connection error.
667 *
668 * @since 3.6.0
669 *
670 * @memberOf wp.heartbeat.prototype
671 *
672 * @return {boolean} True if a connection error was found.
673 */
674 function hasConnectionError() {
675 return settings.connectionError;
676 }
677
678 /**
679 * Connects as soon as possible regardless of 'hasFocus' state.
680 *
681 * Will not open two concurrent connections. If a connection is in progress,
682 * will connect again immediately after the current connection completes.
683 *
684 * @since 3.8.0
685 *
686 * @memberOf wp.heartbeat.prototype
687 *
688 * @return {void}
689 */
690 function connectNow() {
691 settings.lastTick = 0;
692 scheduleNextTick();
693 }
694
695 /**
696 * Disables suspending.
697 *
698 * Should be used only when Heartbeat is performing critical tasks like
699 * autosave, post-locking, etc. Using this on many screens may overload
700 * the user's hosting account if several browser windows/tabs are left open
701 * for a long time.
702 *
703 * @since 3.8.0
704 *
705 * @memberOf wp.heartbeat.prototype
706 *
707 * @return {void}
708 */
709 function disableSuspend() {
710 settings.suspendEnabled = false;
711 }
712
713 /**
714 * Gets/Sets the interval.
715 *
716 * When setting to 'fast' or 5, the interval is 5 seconds for the next 30 ticks
717 * (for 2 minutes and 30 seconds) by default. In this case the number of 'ticks'
718 * can be passed as second argument. If the window doesn't have focus,
719 * the interval slows down to 2 minutes.
720 *
721 * @since 3.6.0
722 *
723 * @memberOf wp.heartbeat.prototype
724 *
725 * @param {string|number} speed Interval: 'fast' or integer between 1 and 3600 (seconds).
726 * Fast equals 5.
727 * @param {number} ticks Tells how many ticks before the interval reverts back.
728 * Value must be between 1 and 30. Used with speed = 'fast' or 5.
729 *
730 * @return {number} Current interval in seconds.
731 */
732 function interval( speed, ticks ) {
733 var newInterval,
734 oldInterval = settings.tempInterval ? settings.tempInterval : settings.mainInterval;
735
736 if ( speed ) {
737 if ( 'fast' === speed ) {
738 // Special case, see below.
739 newInterval = 5000;
740 } else if ( 'long-polling' === speed ) {
741 // Allow long polling (experimental).
742 settings.mainInterval = 0;
743 return 0;
744 } else {
745 speed = parseInt( speed, 10 );
746
747 if ( speed >= 1 && speed <= 3600 ) {
748 newInterval = speed * 1000;
749 } else {
750 newInterval = settings.originalInterval;
751 }
752 }
753
754 if ( settings.minimalInterval && newInterval < settings.minimalInterval ) {
755 newInterval = settings.minimalInterval;
756 }
757
758 // Special case, runs for a number of ticks then reverts to the previous interval.
759 if ( 5000 === newInterval ) {
760 ticks = parseInt( ticks, 10 ) || 30;
761 ticks = ticks < 1 || ticks > 30 ? 30 : ticks;
762
763 settings.countdown = ticks;
764 settings.tempInterval = newInterval;
765 } else {
766 settings.countdown = 0;
767 settings.tempInterval = 0;
768 settings.mainInterval = newInterval;
769 }
770
771 /*
772 * Change the next connection time if new interval has been set.
773 * Will connect immediately if the time since the last connection
774 * is greater than the new interval.
775 */
776 if ( newInterval !== oldInterval ) {
777 scheduleNextTick();
778 }
779 }
780
781 return settings.tempInterval ? settings.tempInterval / 1000 : settings.mainInterval / 1000;
782 }
783
784 /**
785 * Enqueues data to send with the next XHR.
786 *
787 * As the data is send asynchronously, this function doesn't return the XHR
788 * response. To see the response, use the custom jQuery event 'heartbeat-tick'
789 * on the document, example:
790 * $(document).on( 'heartbeat-tick.myname', function( event, data, textStatus, jqXHR ) {
791 * // code
792 * });
793 * If the same 'handle' is used more than once, the data is not overwritten when
794 * the third argument is 'true'. Use `wp.heartbeat.isQueued('handle')` to see if
795 * any data is already queued for that handle.
796 *
797 * @since 3.6.0
798 *
799 * @memberOf wp.heartbeat.prototype
800 *
801 * @param {string} handle Unique handle for the data, used in PHP to
802 * receive the data.
803 * @param {*} data The data to send.
804 * @param {boolean} noOverwrite Whether to overwrite existing data in the queue.
805 *
806 * @return {boolean} True if the data was queued.
807 */
808 function enqueue( handle, data, noOverwrite ) {
809 if ( handle ) {
810 if ( noOverwrite && this.isQueued( handle ) ) {
811 return false;
812 }
813
814 settings.queue[handle] = data;
815 return true;
816 }
817 return false;
818 }
819
820 /**
821 * Checks if data with a particular handle is queued.
822 *
823 * @since 3.6.0
824 *
825 * @param {string} handle The handle for the data.
826 *
827 * @return {boolean} True if the data is queued with this handle.
828 */
829 function isQueued( handle ) {
830 if ( handle ) {
831 return settings.queue.hasOwnProperty( handle );
832 }
833 }
834
835 /**
836 * Removes data with a particular handle from the queue.
837 *
838 * @since 3.7.0
839 *
840 * @memberOf wp.heartbeat.prototype
841 *
842 * @param {string} handle The handle for the data.
843 *
844 * @return {void}
845 */
846 function dequeue( handle ) {
847 if ( handle ) {
848 delete settings.queue[handle];
849 }
850 }
851
852 /**
853 * Gets data that was enqueued with a particular handle.
854 *
855 * @since 3.7.0
856 *
857 * @memberOf wp.heartbeat.prototype
858 *
859 * @param {string} handle The handle for the data.
860 *
861 * @return {*} The data or undefined.
862 */
863 function getQueuedItem( handle ) {
864 if ( handle ) {
865 return this.isQueued( handle ) ? settings.queue[handle] : undefined;
866 }
867 }
868
869 initialize();
870
871 // Expose public methods.
872 return {
873 hasFocus: hasFocus,
874 connectNow: connectNow,
875 disableSuspend: disableSuspend,
876 interval: interval,
877 hasConnectionError: hasConnectionError,
878 enqueue: enqueue,
879 dequeue: dequeue,
880 isQueued: isQueued,
881 getQueuedItem: getQueuedItem
882 };
883 };
884
885 /**
886 * Ensure the global `wp` object exists.
887 *
888 * @namespace wp
889 */
890 window.wp = window.wp || {};
891
892 /**
893 * Contains the Heartbeat API.
894 *
895 * @namespace wp.heartbeat
896 * @type {Heartbeat}
897 */
898 window.wp.heartbeat = new Heartbeat();
899
900}( jQuery, window ));
901