Debian Codegraph @

debian/missing-sources/visibility.js

raw
1 ;(function (global) {
2 "use strict";
3
4 var lastId = -1;
5
6 // Visibility.js allow you to know, that your web page is in the background
7 // tab and thus not visible to the user. This library is wrap under
8 // Page Visibility API. It fix problems with different vendor prefixes and
9 // add high-level useful functions.
10 var self = {
11
12 // Call callback only when page become to visible for user or
13 // call it now if page is visible now or Page Visibility API
14 // doesn’t supported.
15 //
16 // Return false if API isn’t supported, true if page is already visible
17 // or listener ID (you can use it in `unbind` method) if page isn’t
18 // visible now.
19 //
20 // Visibility.onVisible(function () {
21 // startIntroAnimation();
22 // });
23 onVisible: function (callback) {
24 var support = self.isSupported();
25 if ( !support || !self.hidden() ) {
26 callback();
27 return support;
28 }
29
30 var listener = self.change(function (e, state) {
31 if ( !self.hidden() ) {
32 self.unbind(listener);
33 callback();
34 }
35 });
36 return listener;
37 },
38
39 // Call callback when visibility will be changed. First argument for
40 // callback will be original event object, second will be visibility
41 // state name.
42 //
43 // Return listener ID to unbind listener by `unbind` method.
44 //
45 // If Page Visibility API doesn’t supported method will be return false
46 // and callback never will be called.
47 //
48 // Visibility.change(function(e, state) {
49 // Statistics.visibilityChange(state);
50 // });
51 //
52 // It is just proxy to `visibilitychange` event, but use vendor prefix.
53 change: function (callback) {
54 if ( !self.isSupported() ) {
55 return false;
56 }
57 lastId += 1;
58 var number = lastId;
59 self._callbacks[number] = callback;
60 self._listen();
61 return number;
62 },
63
64 // Remove `change` listener by it ID.
65 //
66 // var id = Visibility.change(function(e, state) {
67 // firstChangeCallback();
68 // Visibility.unbind(id);
69 // });
70 unbind: function (id) {
71 delete self._callbacks[id];
72 },
73
74 // Call `callback` in any state, expect “prerender”. If current state
75 // is “prerender” it will wait until state will be changed.
76 // If Page Visibility API doesn’t supported, it will call `callback`
77 // immediately.
78 //
79 // Return false if API isn’t supported, true if page is already after
80 // prerendering or listener ID (you can use it in `unbind` method)
81 // if page is prerended now.
82 //
83 // Visibility.afterPrerendering(function () {
84 // Statistics.countVisitor();
85 // });
86 afterPrerendering: function (callback) {
87 var support = self.isSupported();
88 var prerender = 'prerender';
89
90 if ( !support || prerender != self.state() ) {
91 callback();
92 return support;
93 }
94
95 var listener = self.change(function (e, state) {
96 if ( prerender != state ) {
97 self.unbind(listener);
98 callback();
99 }
100 });
101 return listener;
102 },
103
104 // Return true if page now isn’t visible to user.
105 //
106 // if ( !Visibility.hidden() ) {
107 // VideoPlayer.play();
108 // }
109 //
110 // It is just proxy to `document.hidden`, but use vendor prefix.
111 hidden: function () {
112 return !!(self._doc.hidden || self._doc.webkitHidden);
113 },
114
115 // Return visibility state: 'visible', 'hidden' or 'prerender'.
116 //
117 // if ( 'prerender' == Visibility.state() ) {
118 // Statistics.pageIsPrerendering();
119 // }
120 //
121 // Don’t use `Visibility.state()` to detect, is page visible, because
122 // visibility states can extend in next API versions.
123 // Use more simpler and general `Visibility.hidden()` for this cases.
124 //
125 // It is just proxy to `document.visibilityState`, but use
126 // vendor prefix.
127 state: function () {
128 return self._doc.visibilityState ||
129 self._doc.webkitVisibilityState ||
130 'visible';
131 },
132
133 // Return true if browser support Page Visibility API.
134 //
135 // if ( Visibility.isSupported() ) {
136 // Statistics.startTrackingVisibility();
137 // Visibility.change(function(e, state)) {
138 // Statistics.trackVisibility(state);
139 // });
140 // }
141 isSupported: function () {
142 return !!(self._doc.visibilityState ||
143 self._doc.webkitVisibilityState);
144 },
145
146 // Link to document object to change it in tests.
147 _doc: document || {},
148
149 // Callbacks from `change` method, that wait visibility changes.
150 _callbacks: { },
151
152 // Listener for `visibilitychange` event.
153 _change: function(event) {
154 var state = self.state();
155
156 for ( var i in self._callbacks ) {
157 self._callbacks[i].call(self._doc, event, state);
158 }
159 },
160
161 // Set listener for `visibilitychange` event.
162 _listen: function () {
163 if ( self._init ) {
164 return;
165 }
166
167 var event = 'visibilitychange';
168 if ( self._doc.webkitVisibilityState ) {
169 event = 'webkit' + event;
170 }
171
172 var listener = function () {
173 self._change.apply(self, arguments);
174 };
175 if ( self._doc.addEventListener ) {
176 self._doc.addEventListener(event, listener);
177 } else {
178 self._doc.attachEvent(event, listener);
179 }
180 self._init = true;
181 }
182
183 };
184
185 if ( typeof(module) != 'undefined' && module.exports ) {
186 module.exports = self;
187 } else {
188 global.Visibility = self;
189 }
190
191 })(this);