alchemy_cms 7.0.4 → 7.0.6

Sign up to get free protection for your applications and to get access to all the features.
Files changed (31) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/test.yml +1 -0
  3. data/CHANGELOG.md +10 -0
  4. data/Gemfile +6 -1
  5. data/alchemy_cms.gemspec +2 -3
  6. data/app/assets/javascripts/alchemy/admin.js +0 -1
  7. data/app/assets/javascripts/alchemy/alchemy.dialog.js.coffee +1 -1
  8. data/app/controllers/alchemy/admin/ingredients_controller.rb +2 -1
  9. data/app/controllers/alchemy/admin/languages_controller.rb +2 -2
  10. data/app/controllers/alchemy/admin/sites_controller.rb +1 -1
  11. data/app/models/alchemy/page/publisher.rb +14 -12
  12. data/app/models/alchemy/page_mutex.rb +31 -0
  13. data/app/models/alchemy/picture/url.rb +9 -1
  14. data/db/migrate/20231113104432_create_page_mutexes.rb +8 -0
  15. data/lib/alchemy/version.rb +1 -1
  16. data/lib/alchemy_cms.rb +0 -1
  17. data/vendor/assets/javascripts/jquery-ui/data.js +45 -0
  18. data/vendor/assets/javascripts/jquery-ui/ie.js +20 -0
  19. data/vendor/assets/javascripts/jquery-ui/keycode.js +51 -0
  20. data/vendor/assets/javascripts/jquery-ui/plugin.js +49 -0
  21. data/vendor/assets/javascripts/jquery-ui/safe-active-element.js +46 -0
  22. data/vendor/assets/javascripts/jquery-ui/safe-blur.js +27 -0
  23. data/vendor/assets/javascripts/jquery-ui/scroll-parent.js +50 -0
  24. data/vendor/assets/javascripts/jquery-ui/unique-id.js +54 -0
  25. data/vendor/assets/javascripts/jquery-ui/version.js +20 -0
  26. data/vendor/assets/javascripts/jquery-ui/widget.js +754 -0
  27. data/vendor/assets/javascripts/jquery-ui/widgets/draggable.js +1268 -0
  28. data/vendor/assets/javascripts/jquery-ui/widgets/mouse.js +241 -0
  29. data/vendor/assets/javascripts/jquery-ui/widgets/sortable.js +1623 -0
  30. data/vendor/assets/javascripts/jquery-ui/widgets/tabs.js +931 -0
  31. metadata +36 -34
@@ -0,0 +1,931 @@
1
+ //= require jquery-ui/keycode
2
+ //= require jquery-ui/safe-active-element
3
+ //= require jquery-ui/unique-id
4
+ //= require jquery-ui/version
5
+ //= require jquery-ui/widget
6
+
7
+ /*!
8
+ * jQuery UI Tabs 1.13.0
9
+ * http://jqueryui.com
10
+ *
11
+ * Copyright jQuery Foundation and other contributors
12
+ * Released under the MIT license.
13
+ * http://jquery.org/license
14
+ */
15
+
16
+ //>>label: Tabs
17
+ //>>group: Widgets
18
+ //>>description: Transforms a set of container elements into a tab structure.
19
+ //>>docs: http://api.jqueryui.com/tabs/
20
+ //>>demos: http://jqueryui.com/tabs/
21
+ //>>css.structure: ../../themes/base/core.css
22
+ //>>css.structure: ../../themes/base/tabs.css
23
+ //>>css.theme: ../../themes/base/theme.css
24
+
25
+ ( function( factory ) {
26
+ "use strict";
27
+
28
+ if ( typeof define === "function" && define.amd ) {
29
+
30
+ // AMD. Register as an anonymous module.
31
+ define( [
32
+ "jquery",
33
+ "../keycode",
34
+ "../safe-active-element",
35
+ "../unique-id",
36
+ "../version",
37
+ "../widget"
38
+ ], factory );
39
+ } else {
40
+
41
+ // Browser globals
42
+ factory( jQuery );
43
+ }
44
+ } )( function( $ ) {
45
+ "use strict";
46
+
47
+ $.widget( "ui.tabs", {
48
+ version: "1.13.0",
49
+ delay: 300,
50
+ options: {
51
+ active: null,
52
+ classes: {
53
+ "ui-tabs": "ui-corner-all",
54
+ "ui-tabs-nav": "ui-corner-all",
55
+ "ui-tabs-panel": "ui-corner-bottom",
56
+ "ui-tabs-tab": "ui-corner-top"
57
+ },
58
+ collapsible: false,
59
+ event: "click",
60
+ heightStyle: "content",
61
+ hide: null,
62
+ show: null,
63
+
64
+ // Callbacks
65
+ activate: null,
66
+ beforeActivate: null,
67
+ beforeLoad: null,
68
+ load: null
69
+ },
70
+
71
+ _isLocal: ( function() {
72
+ var rhash = /#.*$/;
73
+
74
+ return function( anchor ) {
75
+ var anchorUrl, locationUrl;
76
+
77
+ anchorUrl = anchor.href.replace( rhash, "" );
78
+ locationUrl = location.href.replace( rhash, "" );
79
+
80
+ // Decoding may throw an error if the URL isn't UTF-8 (#9518)
81
+ try {
82
+ anchorUrl = decodeURIComponent( anchorUrl );
83
+ } catch ( error ) {}
84
+ try {
85
+ locationUrl = decodeURIComponent( locationUrl );
86
+ } catch ( error ) {}
87
+
88
+ return anchor.hash.length > 1 && anchorUrl === locationUrl;
89
+ };
90
+ } )(),
91
+
92
+ _create: function() {
93
+ var that = this,
94
+ options = this.options;
95
+
96
+ this.running = false;
97
+
98
+ this._addClass( "ui-tabs", "ui-widget ui-widget-content" );
99
+ this._toggleClass( "ui-tabs-collapsible", null, options.collapsible );
100
+
101
+ this._processTabs();
102
+ options.active = this._initialActive();
103
+
104
+ // Take disabling tabs via class attribute from HTML
105
+ // into account and update option properly.
106
+ if ( Array.isArray( options.disabled ) ) {
107
+ options.disabled = $.uniqueSort( options.disabled.concat(
108
+ $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
109
+ return that.tabs.index( li );
110
+ } )
111
+ ) ).sort();
112
+ }
113
+
114
+ // Check for length avoids error when initializing empty list
115
+ if ( this.options.active !== false && this.anchors.length ) {
116
+ this.active = this._findActive( options.active );
117
+ } else {
118
+ this.active = $();
119
+ }
120
+
121
+ this._refresh();
122
+
123
+ if ( this.active.length ) {
124
+ this.load( options.active );
125
+ }
126
+ },
127
+
128
+ _initialActive: function() {
129
+ var active = this.options.active,
130
+ collapsible = this.options.collapsible,
131
+ locationHash = location.hash.substring( 1 );
132
+
133
+ if ( active === null ) {
134
+
135
+ // check the fragment identifier in the URL
136
+ if ( locationHash ) {
137
+ this.tabs.each( function( i, tab ) {
138
+ if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
139
+ active = i;
140
+ return false;
141
+ }
142
+ } );
143
+ }
144
+
145
+ // Check for a tab marked active via a class
146
+ if ( active === null ) {
147
+ active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
148
+ }
149
+
150
+ // No active tab, set to false
151
+ if ( active === null || active === -1 ) {
152
+ active = this.tabs.length ? 0 : false;
153
+ }
154
+ }
155
+
156
+ // Handle numbers: negative, out of range
157
+ if ( active !== false ) {
158
+ active = this.tabs.index( this.tabs.eq( active ) );
159
+ if ( active === -1 ) {
160
+ active = collapsible ? false : 0;
161
+ }
162
+ }
163
+
164
+ // Don't allow collapsible: false and active: false
165
+ if ( !collapsible && active === false && this.anchors.length ) {
166
+ active = 0;
167
+ }
168
+
169
+ return active;
170
+ },
171
+
172
+ _getCreateEventData: function() {
173
+ return {
174
+ tab: this.active,
175
+ panel: !this.active.length ? $() : this._getPanelForTab( this.active )
176
+ };
177
+ },
178
+
179
+ _tabKeydown: function( event ) {
180
+ var focusedTab = $( $.ui.safeActiveElement( this.document[ 0 ] ) ).closest( "li" ),
181
+ selectedIndex = this.tabs.index( focusedTab ),
182
+ goingForward = true;
183
+
184
+ if ( this._handlePageNav( event ) ) {
185
+ return;
186
+ }
187
+
188
+ switch ( event.keyCode ) {
189
+ case $.ui.keyCode.RIGHT:
190
+ case $.ui.keyCode.DOWN:
191
+ selectedIndex++;
192
+ break;
193
+ case $.ui.keyCode.UP:
194
+ case $.ui.keyCode.LEFT:
195
+ goingForward = false;
196
+ selectedIndex--;
197
+ break;
198
+ case $.ui.keyCode.END:
199
+ selectedIndex = this.anchors.length - 1;
200
+ break;
201
+ case $.ui.keyCode.HOME:
202
+ selectedIndex = 0;
203
+ break;
204
+ case $.ui.keyCode.SPACE:
205
+
206
+ // Activate only, no collapsing
207
+ event.preventDefault();
208
+ clearTimeout( this.activating );
209
+ this._activate( selectedIndex );
210
+ return;
211
+ case $.ui.keyCode.ENTER:
212
+
213
+ // Toggle (cancel delayed activation, allow collapsing)
214
+ event.preventDefault();
215
+ clearTimeout( this.activating );
216
+
217
+ // Determine if we should collapse or activate
218
+ this._activate( selectedIndex === this.options.active ? false : selectedIndex );
219
+ return;
220
+ default:
221
+ return;
222
+ }
223
+
224
+ // Focus the appropriate tab, based on which key was pressed
225
+ event.preventDefault();
226
+ clearTimeout( this.activating );
227
+ selectedIndex = this._focusNextTab( selectedIndex, goingForward );
228
+
229
+ // Navigating with control/command key will prevent automatic activation
230
+ if ( !event.ctrlKey && !event.metaKey ) {
231
+
232
+ // Update aria-selected immediately so that AT think the tab is already selected.
233
+ // Otherwise AT may confuse the user by stating that they need to activate the tab,
234
+ // but the tab will already be activated by the time the announcement finishes.
235
+ focusedTab.attr( "aria-selected", "false" );
236
+ this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
237
+
238
+ this.activating = this._delay( function() {
239
+ this.option( "active", selectedIndex );
240
+ }, this.delay );
241
+ }
242
+ },
243
+
244
+ _panelKeydown: function( event ) {
245
+ if ( this._handlePageNav( event ) ) {
246
+ return;
247
+ }
248
+
249
+ // Ctrl+up moves focus to the current tab
250
+ if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
251
+ event.preventDefault();
252
+ this.active.trigger( "focus" );
253
+ }
254
+ },
255
+
256
+ // Alt+page up/down moves focus to the previous/next tab (and activates)
257
+ _handlePageNav: function( event ) {
258
+ if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
259
+ this._activate( this._focusNextTab( this.options.active - 1, false ) );
260
+ return true;
261
+ }
262
+ if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
263
+ this._activate( this._focusNextTab( this.options.active + 1, true ) );
264
+ return true;
265
+ }
266
+ },
267
+
268
+ _findNextTab: function( index, goingForward ) {
269
+ var lastTabIndex = this.tabs.length - 1;
270
+
271
+ function constrain() {
272
+ if ( index > lastTabIndex ) {
273
+ index = 0;
274
+ }
275
+ if ( index < 0 ) {
276
+ index = lastTabIndex;
277
+ }
278
+ return index;
279
+ }
280
+
281
+ while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
282
+ index = goingForward ? index + 1 : index - 1;
283
+ }
284
+
285
+ return index;
286
+ },
287
+
288
+ _focusNextTab: function( index, goingForward ) {
289
+ index = this._findNextTab( index, goingForward );
290
+ this.tabs.eq( index ).trigger( "focus" );
291
+ return index;
292
+ },
293
+
294
+ _setOption: function( key, value ) {
295
+ if ( key === "active" ) {
296
+
297
+ // _activate() will handle invalid values and update this.options
298
+ this._activate( value );
299
+ return;
300
+ }
301
+
302
+ this._super( key, value );
303
+
304
+ if ( key === "collapsible" ) {
305
+ this._toggleClass( "ui-tabs-collapsible", null, value );
306
+
307
+ // Setting collapsible: false while collapsed; open first panel
308
+ if ( !value && this.options.active === false ) {
309
+ this._activate( 0 );
310
+ }
311
+ }
312
+
313
+ if ( key === "event" ) {
314
+ this._setupEvents( value );
315
+ }
316
+
317
+ if ( key === "heightStyle" ) {
318
+ this._setupHeightStyle( value );
319
+ }
320
+ },
321
+
322
+ _sanitizeSelector: function( hash ) {
323
+ return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
324
+ },
325
+
326
+ refresh: function() {
327
+ var options = this.options,
328
+ lis = this.tablist.children( ":has(a[href])" );
329
+
330
+ // Get disabled tabs from class attribute from HTML
331
+ // this will get converted to a boolean if needed in _refresh()
332
+ options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
333
+ return lis.index( tab );
334
+ } );
335
+
336
+ this._processTabs();
337
+
338
+ // Was collapsed or no tabs
339
+ if ( options.active === false || !this.anchors.length ) {
340
+ options.active = false;
341
+ this.active = $();
342
+
343
+ // was active, but active tab is gone
344
+ } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
345
+
346
+ // all remaining tabs are disabled
347
+ if ( this.tabs.length === options.disabled.length ) {
348
+ options.active = false;
349
+ this.active = $();
350
+
351
+ // activate previous tab
352
+ } else {
353
+ this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
354
+ }
355
+
356
+ // was active, active tab still exists
357
+ } else {
358
+
359
+ // make sure active index is correct
360
+ options.active = this.tabs.index( this.active );
361
+ }
362
+
363
+ this._refresh();
364
+ },
365
+
366
+ _refresh: function() {
367
+ this._setOptionDisabled( this.options.disabled );
368
+ this._setupEvents( this.options.event );
369
+ this._setupHeightStyle( this.options.heightStyle );
370
+
371
+ this.tabs.not( this.active ).attr( {
372
+ "aria-selected": "false",
373
+ "aria-expanded": "false",
374
+ tabIndex: -1
375
+ } );
376
+ this.panels.not( this._getPanelForTab( this.active ) )
377
+ .hide()
378
+ .attr( {
379
+ "aria-hidden": "true"
380
+ } );
381
+
382
+ // Make sure one tab is in the tab order
383
+ if ( !this.active.length ) {
384
+ this.tabs.eq( 0 ).attr( "tabIndex", 0 );
385
+ } else {
386
+ this.active
387
+ .attr( {
388
+ "aria-selected": "true",
389
+ "aria-expanded": "true",
390
+ tabIndex: 0
391
+ } );
392
+ this._addClass( this.active, "ui-tabs-active", "ui-state-active" );
393
+ this._getPanelForTab( this.active )
394
+ .show()
395
+ .attr( {
396
+ "aria-hidden": "false"
397
+ } );
398
+ }
399
+ },
400
+
401
+ _processTabs: function() {
402
+ var that = this,
403
+ prevTabs = this.tabs,
404
+ prevAnchors = this.anchors,
405
+ prevPanels = this.panels;
406
+
407
+ this.tablist = this._getList().attr( "role", "tablist" );
408
+ this._addClass( this.tablist, "ui-tabs-nav",
409
+ "ui-helper-reset ui-helper-clearfix ui-widget-header" );
410
+
411
+ // Prevent users from focusing disabled tabs via click
412
+ this.tablist
413
+ .on( "mousedown" + this.eventNamespace, "> li", function( event ) {
414
+ if ( $( this ).is( ".ui-state-disabled" ) ) {
415
+ event.preventDefault();
416
+ }
417
+ } )
418
+
419
+ // Support: IE <9
420
+ // Preventing the default action in mousedown doesn't prevent IE
421
+ // from focusing the element, so if the anchor gets focused, blur.
422
+ // We don't have to worry about focusing the previously focused
423
+ // element since clicking on a non-focusable element should focus
424
+ // the body anyway.
425
+ .on( "focus" + this.eventNamespace, ".ui-tabs-anchor", function() {
426
+ if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
427
+ this.blur();
428
+ }
429
+ } );
430
+
431
+ this.tabs = this.tablist.find( "> li:has(a[href])" )
432
+ .attr( {
433
+ role: "tab",
434
+ tabIndex: -1
435
+ } );
436
+ this._addClass( this.tabs, "ui-tabs-tab", "ui-state-default" );
437
+
438
+ this.anchors = this.tabs.map( function() {
439
+ return $( "a", this )[ 0 ];
440
+ } )
441
+ .attr( {
442
+ tabIndex: -1
443
+ } );
444
+ this._addClass( this.anchors, "ui-tabs-anchor" );
445
+
446
+ this.panels = $();
447
+
448
+ this.anchors.each( function( i, anchor ) {
449
+ var selector, panel, panelId,
450
+ anchorId = $( anchor ).uniqueId().attr( "id" ),
451
+ tab = $( anchor ).closest( "li" ),
452
+ originalAriaControls = tab.attr( "aria-controls" );
453
+
454
+ // Inline tab
455
+ if ( that._isLocal( anchor ) ) {
456
+ selector = anchor.hash;
457
+ panelId = selector.substring( 1 );
458
+ panel = that.element.find( that._sanitizeSelector( selector ) );
459
+
460
+ // remote tab
461
+ } else {
462
+
463
+ // If the tab doesn't already have aria-controls,
464
+ // generate an id by using a throw-away element
465
+ panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id;
466
+ selector = "#" + panelId;
467
+ panel = that.element.find( selector );
468
+ if ( !panel.length ) {
469
+ panel = that._createPanel( panelId );
470
+ panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
471
+ }
472
+ panel.attr( "aria-live", "polite" );
473
+ }
474
+
475
+ if ( panel.length ) {
476
+ that.panels = that.panels.add( panel );
477
+ }
478
+ if ( originalAriaControls ) {
479
+ tab.data( "ui-tabs-aria-controls", originalAriaControls );
480
+ }
481
+ tab.attr( {
482
+ "aria-controls": panelId,
483
+ "aria-labelledby": anchorId
484
+ } );
485
+ panel.attr( "aria-labelledby", anchorId );
486
+ } );
487
+
488
+ this.panels.attr( "role", "tabpanel" );
489
+ this._addClass( this.panels, "ui-tabs-panel", "ui-widget-content" );
490
+
491
+ // Avoid memory leaks (#10056)
492
+ if ( prevTabs ) {
493
+ this._off( prevTabs.not( this.tabs ) );
494
+ this._off( prevAnchors.not( this.anchors ) );
495
+ this._off( prevPanels.not( this.panels ) );
496
+ }
497
+ },
498
+
499
+ // Allow overriding how to find the list for rare usage scenarios (#7715)
500
+ _getList: function() {
501
+ return this.tablist || this.element.find( "ol, ul" ).eq( 0 );
502
+ },
503
+
504
+ _createPanel: function( id ) {
505
+ return $( "<div>" )
506
+ .attr( "id", id )
507
+ .data( "ui-tabs-destroy", true );
508
+ },
509
+
510
+ _setOptionDisabled: function( disabled ) {
511
+ var currentItem, li, i;
512
+
513
+ if ( Array.isArray( disabled ) ) {
514
+ if ( !disabled.length ) {
515
+ disabled = false;
516
+ } else if ( disabled.length === this.anchors.length ) {
517
+ disabled = true;
518
+ }
519
+ }
520
+
521
+ // Disable tabs
522
+ for ( i = 0; ( li = this.tabs[ i ] ); i++ ) {
523
+ currentItem = $( li );
524
+ if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
525
+ currentItem.attr( "aria-disabled", "true" );
526
+ this._addClass( currentItem, null, "ui-state-disabled" );
527
+ } else {
528
+ currentItem.removeAttr( "aria-disabled" );
529
+ this._removeClass( currentItem, null, "ui-state-disabled" );
530
+ }
531
+ }
532
+
533
+ this.options.disabled = disabled;
534
+
535
+ this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null,
536
+ disabled === true );
537
+ },
538
+
539
+ _setupEvents: function( event ) {
540
+ var events = {};
541
+ if ( event ) {
542
+ $.each( event.split( " " ), function( index, eventName ) {
543
+ events[ eventName ] = "_eventHandler";
544
+ } );
545
+ }
546
+
547
+ this._off( this.anchors.add( this.tabs ).add( this.panels ) );
548
+
549
+ // Always prevent the default action, even when disabled
550
+ this._on( true, this.anchors, {
551
+ click: function( event ) {
552
+ event.preventDefault();
553
+ }
554
+ } );
555
+ this._on( this.anchors, events );
556
+ this._on( this.tabs, { keydown: "_tabKeydown" } );
557
+ this._on( this.panels, { keydown: "_panelKeydown" } );
558
+
559
+ this._focusable( this.tabs );
560
+ this._hoverable( this.tabs );
561
+ },
562
+
563
+ _setupHeightStyle: function( heightStyle ) {
564
+ var maxHeight,
565
+ parent = this.element.parent();
566
+
567
+ if ( heightStyle === "fill" ) {
568
+ maxHeight = parent.height();
569
+ maxHeight -= this.element.outerHeight() - this.element.height();
570
+
571
+ this.element.siblings( ":visible" ).each( function() {
572
+ var elem = $( this ),
573
+ position = elem.css( "position" );
574
+
575
+ if ( position === "absolute" || position === "fixed" ) {
576
+ return;
577
+ }
578
+ maxHeight -= elem.outerHeight( true );
579
+ } );
580
+
581
+ this.element.children().not( this.panels ).each( function() {
582
+ maxHeight -= $( this ).outerHeight( true );
583
+ } );
584
+
585
+ this.panels.each( function() {
586
+ $( this ).height( Math.max( 0, maxHeight -
587
+ $( this ).innerHeight() + $( this ).height() ) );
588
+ } )
589
+ .css( "overflow", "auto" );
590
+ } else if ( heightStyle === "auto" ) {
591
+ maxHeight = 0;
592
+ this.panels.each( function() {
593
+ maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
594
+ } ).height( maxHeight );
595
+ }
596
+ },
597
+
598
+ _eventHandler: function( event ) {
599
+ var options = this.options,
600
+ active = this.active,
601
+ anchor = $( event.currentTarget ),
602
+ tab = anchor.closest( "li" ),
603
+ clickedIsActive = tab[ 0 ] === active[ 0 ],
604
+ collapsing = clickedIsActive && options.collapsible,
605
+ toShow = collapsing ? $() : this._getPanelForTab( tab ),
606
+ toHide = !active.length ? $() : this._getPanelForTab( active ),
607
+ eventData = {
608
+ oldTab: active,
609
+ oldPanel: toHide,
610
+ newTab: collapsing ? $() : tab,
611
+ newPanel: toShow
612
+ };
613
+
614
+ event.preventDefault();
615
+
616
+ if ( tab.hasClass( "ui-state-disabled" ) ||
617
+
618
+ // tab is already loading
619
+ tab.hasClass( "ui-tabs-loading" ) ||
620
+
621
+ // can't switch durning an animation
622
+ this.running ||
623
+
624
+ // click on active header, but not collapsible
625
+ ( clickedIsActive && !options.collapsible ) ||
626
+
627
+ // allow canceling activation
628
+ ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
629
+ return;
630
+ }
631
+
632
+ options.active = collapsing ? false : this.tabs.index( tab );
633
+
634
+ this.active = clickedIsActive ? $() : tab;
635
+ if ( this.xhr ) {
636
+ this.xhr.abort();
637
+ }
638
+
639
+ if ( !toHide.length && !toShow.length ) {
640
+ $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
641
+ }
642
+
643
+ if ( toShow.length ) {
644
+ this.load( this.tabs.index( tab ), event );
645
+ }
646
+ this._toggle( event, eventData );
647
+ },
648
+
649
+ // Handles show/hide for selecting tabs
650
+ _toggle: function( event, eventData ) {
651
+ var that = this,
652
+ toShow = eventData.newPanel,
653
+ toHide = eventData.oldPanel;
654
+
655
+ this.running = true;
656
+
657
+ function complete() {
658
+ that.running = false;
659
+ that._trigger( "activate", event, eventData );
660
+ }
661
+
662
+ function show() {
663
+ that._addClass( eventData.newTab.closest( "li" ), "ui-tabs-active", "ui-state-active" );
664
+
665
+ if ( toShow.length && that.options.show ) {
666
+ that._show( toShow, that.options.show, complete );
667
+ } else {
668
+ toShow.show();
669
+ complete();
670
+ }
671
+ }
672
+
673
+ // Start out by hiding, then showing, then completing
674
+ if ( toHide.length && this.options.hide ) {
675
+ this._hide( toHide, this.options.hide, function() {
676
+ that._removeClass( eventData.oldTab.closest( "li" ),
677
+ "ui-tabs-active", "ui-state-active" );
678
+ show();
679
+ } );
680
+ } else {
681
+ this._removeClass( eventData.oldTab.closest( "li" ),
682
+ "ui-tabs-active", "ui-state-active" );
683
+ toHide.hide();
684
+ show();
685
+ }
686
+
687
+ toHide.attr( "aria-hidden", "true" );
688
+ eventData.oldTab.attr( {
689
+ "aria-selected": "false",
690
+ "aria-expanded": "false"
691
+ } );
692
+
693
+ // If we're switching tabs, remove the old tab from the tab order.
694
+ // If we're opening from collapsed state, remove the previous tab from the tab order.
695
+ // If we're collapsing, then keep the collapsing tab in the tab order.
696
+ if ( toShow.length && toHide.length ) {
697
+ eventData.oldTab.attr( "tabIndex", -1 );
698
+ } else if ( toShow.length ) {
699
+ this.tabs.filter( function() {
700
+ return $( this ).attr( "tabIndex" ) === 0;
701
+ } )
702
+ .attr( "tabIndex", -1 );
703
+ }
704
+
705
+ toShow.attr( "aria-hidden", "false" );
706
+ eventData.newTab.attr( {
707
+ "aria-selected": "true",
708
+ "aria-expanded": "true",
709
+ tabIndex: 0
710
+ } );
711
+ },
712
+
713
+ _activate: function( index ) {
714
+ var anchor,
715
+ active = this._findActive( index );
716
+
717
+ // Trying to activate the already active panel
718
+ if ( active[ 0 ] === this.active[ 0 ] ) {
719
+ return;
720
+ }
721
+
722
+ // Trying to collapse, simulate a click on the current active header
723
+ if ( !active.length ) {
724
+ active = this.active;
725
+ }
726
+
727
+ anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
728
+ this._eventHandler( {
729
+ target: anchor,
730
+ currentTarget: anchor,
731
+ preventDefault: $.noop
732
+ } );
733
+ },
734
+
735
+ _findActive: function( index ) {
736
+ return index === false ? $() : this.tabs.eq( index );
737
+ },
738
+
739
+ _getIndex: function( index ) {
740
+
741
+ // meta-function to give users option to provide a href string instead of a numerical index.
742
+ if ( typeof index === "string" ) {
743
+ index = this.anchors.index( this.anchors.filter( "[href$='" +
744
+ $.escapeSelector( index ) + "']" ) );
745
+ }
746
+
747
+ return index;
748
+ },
749
+
750
+ _destroy: function() {
751
+ if ( this.xhr ) {
752
+ this.xhr.abort();
753
+ }
754
+
755
+ this.tablist
756
+ .removeAttr( "role" )
757
+ .off( this.eventNamespace );
758
+
759
+ this.anchors
760
+ .removeAttr( "role tabIndex" )
761
+ .removeUniqueId();
762
+
763
+ this.tabs.add( this.panels ).each( function() {
764
+ if ( $.data( this, "ui-tabs-destroy" ) ) {
765
+ $( this ).remove();
766
+ } else {
767
+ $( this ).removeAttr( "role tabIndex " +
768
+ "aria-live aria-busy aria-selected aria-labelledby aria-hidden aria-expanded" );
769
+ }
770
+ } );
771
+
772
+ this.tabs.each( function() {
773
+ var li = $( this ),
774
+ prev = li.data( "ui-tabs-aria-controls" );
775
+ if ( prev ) {
776
+ li
777
+ .attr( "aria-controls", prev )
778
+ .removeData( "ui-tabs-aria-controls" );
779
+ } else {
780
+ li.removeAttr( "aria-controls" );
781
+ }
782
+ } );
783
+
784
+ this.panels.show();
785
+
786
+ if ( this.options.heightStyle !== "content" ) {
787
+ this.panels.css( "height", "" );
788
+ }
789
+ },
790
+
791
+ enable: function( index ) {
792
+ var disabled = this.options.disabled;
793
+ if ( disabled === false ) {
794
+ return;
795
+ }
796
+
797
+ if ( index === undefined ) {
798
+ disabled = false;
799
+ } else {
800
+ index = this._getIndex( index );
801
+ if ( Array.isArray( disabled ) ) {
802
+ disabled = $.map( disabled, function( num ) {
803
+ return num !== index ? num : null;
804
+ } );
805
+ } else {
806
+ disabled = $.map( this.tabs, function( li, num ) {
807
+ return num !== index ? num : null;
808
+ } );
809
+ }
810
+ }
811
+ this._setOptionDisabled( disabled );
812
+ },
813
+
814
+ disable: function( index ) {
815
+ var disabled = this.options.disabled;
816
+ if ( disabled === true ) {
817
+ return;
818
+ }
819
+
820
+ if ( index === undefined ) {
821
+ disabled = true;
822
+ } else {
823
+ index = this._getIndex( index );
824
+ if ( $.inArray( index, disabled ) !== -1 ) {
825
+ return;
826
+ }
827
+ if ( Array.isArray( disabled ) ) {
828
+ disabled = $.merge( [ index ], disabled ).sort();
829
+ } else {
830
+ disabled = [ index ];
831
+ }
832
+ }
833
+ this._setOptionDisabled( disabled );
834
+ },
835
+
836
+ load: function( index, event ) {
837
+ index = this._getIndex( index );
838
+ var that = this,
839
+ tab = this.tabs.eq( index ),
840
+ anchor = tab.find( ".ui-tabs-anchor" ),
841
+ panel = this._getPanelForTab( tab ),
842
+ eventData = {
843
+ tab: tab,
844
+ panel: panel
845
+ },
846
+ complete = function( jqXHR, status ) {
847
+ if ( status === "abort" ) {
848
+ that.panels.stop( false, true );
849
+ }
850
+
851
+ that._removeClass( tab, "ui-tabs-loading" );
852
+ panel.removeAttr( "aria-busy" );
853
+
854
+ if ( jqXHR === that.xhr ) {
855
+ delete that.xhr;
856
+ }
857
+ };
858
+
859
+ // Not remote
860
+ if ( this._isLocal( anchor[ 0 ] ) ) {
861
+ return;
862
+ }
863
+
864
+ this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
865
+
866
+ // Support: jQuery <1.8
867
+ // jQuery <1.8 returns false if the request is canceled in beforeSend,
868
+ // but as of 1.8, $.ajax() always returns a jqXHR object.
869
+ if ( this.xhr && this.xhr.statusText !== "canceled" ) {
870
+ this._addClass( tab, "ui-tabs-loading" );
871
+ panel.attr( "aria-busy", "true" );
872
+
873
+ this.xhr
874
+ .done( function( response, status, jqXHR ) {
875
+
876
+ // support: jQuery <1.8
877
+ // http://bugs.jquery.com/ticket/11778
878
+ setTimeout( function() {
879
+ panel.html( response );
880
+ that._trigger( "load", event, eventData );
881
+
882
+ complete( jqXHR, status );
883
+ }, 1 );
884
+ } )
885
+ .fail( function( jqXHR, status ) {
886
+
887
+ // support: jQuery <1.8
888
+ // http://bugs.jquery.com/ticket/11778
889
+ setTimeout( function() {
890
+ complete( jqXHR, status );
891
+ }, 1 );
892
+ } );
893
+ }
894
+ },
895
+
896
+ _ajaxSettings: function( anchor, event, eventData ) {
897
+ var that = this;
898
+ return {
899
+
900
+ // Support: IE <11 only
901
+ // Strip any hash that exists to prevent errors with the Ajax request
902
+ url: anchor.attr( "href" ).replace( /#.*$/, "" ),
903
+ beforeSend: function( jqXHR, settings ) {
904
+ return that._trigger( "beforeLoad", event,
905
+ $.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) );
906
+ }
907
+ };
908
+ },
909
+
910
+ _getPanelForTab: function( tab ) {
911
+ var id = $( tab ).attr( "aria-controls" );
912
+ return this.element.find( this._sanitizeSelector( "#" + id ) );
913
+ }
914
+ } );
915
+
916
+ // DEPRECATED
917
+ // TODO: Switch return back to widget declaration at top of file when this is removed
918
+ if ( $.uiBackCompat !== false ) {
919
+
920
+ // Backcompat for ui-tab class (now ui-tabs-tab)
921
+ $.widget( "ui.tabs", $.ui.tabs, {
922
+ _processTabs: function() {
923
+ this._superApply( arguments );
924
+ this._addClass( this.tabs, "ui-tab" );
925
+ }
926
+ } );
927
+ }
928
+
929
+ return $.ui.tabs;
930
+
931
+ } );