pickadate-rails 1.3.2 → 1.4.0

data/vendor/assets/javascripts/pickadate/picker.time.js

@@ -1,22 +1,13 @@
 
 /*!
- * Time picker for pickadate.js v3.3.2
+ * Time picker for pickadate.js v3.4.0
  * http://amsul.github.io/pickadate.js/time.htm
  */
 
-/*jshint
-   debug: true,
-   devel: true,
-   browser: true,
-   asi: true,
-   unused: true,
-   boss: true
- */
-
 (function ( factory ) {
 
     // Register as an anonymous module.
-    if ( typeof define === 'function' && define.amd )
+    if ( typeof define == 'function' && define.amd )
         define( ['picker','jquery'], factory )
 
     // Or using browser globals.
@@ -31,7 +22,8 @@
 var HOURS_IN_DAY = 24,
     MINUTES_IN_HOUR = 60,
     HOURS_TO_NOON = 12,
-    MINUTES_IN_DAY = HOURS_IN_DAY * MINUTES_IN_HOUR
+    MINUTES_IN_DAY = HOURS_IN_DAY * MINUTES_IN_HOUR,
+    _ = Picker._
 
 
 
@@ -41,9 +33,13 @@ var HOURS_IN_DAY = 24,
 function TimePicker( picker, settings ) {
 
     var clock = this,
-        elementDataValue = picker.$node.data( 'value' )
+        elementValue = picker.$node[ 0 ].value,
+        elementDataValue = picker.$node.data( 'value' ),
+        valueString = elementDataValue || elementValue,
+        formatString = elementDataValue ? settings.formatSubmit : settings.format
 
     clock.settings = settings
+    clock.$node = picker.$node
 
     // The queue of methods that will be used to build item objects.
     clock.queue = {
@@ -52,10 +48,10 @@ function TimePicker( picker, settings ) {
         max: 'measure create',
         now: 'now create',
         select: 'parse create validate',
-        highlight: 'create validate',
-        view: 'create validate',
-        disable: 'flipItem',
-        enable: 'flipItem'
+        highlight: 'parse create validate',
+        view: 'parse create validate',
+        disable: 'deactivate',
+        enable: 'activate'
     }
 
     // The component's item object.
@@ -70,18 +66,23 @@ function TimePicker( picker, settings ) {
     clock.
         set( 'min', settings.min ).
         set( 'max', settings.max ).
-        set( 'now' ).
-
-        // Setting the `select` also sets the `highlight` and `view`.
-        set( 'select',
-
-            // If there's a `value` or `data-value`, use that with formatting.
-            // Otherwise default to the minimum selectable time.
-            elementDataValue || picker.$node[ 0 ].value || clock.item.min,
+        set( 'now' )
+
+    // When there’s a value, set the `select`, which in turn
+    // also sets the `highlight` and `view`.
+    if ( valueString ) {
+        clock.set( 'select', valueString, {
+            format: formatString,
+            fromValue: !!elementValue
+        })
+    }
 
-            // Use the relevant format.
-            { format: elementDataValue ? settings.formatSubmit : settings.format }
-        )
+    // If there’s no value, default to highlighting “today”.
+    else {
+        clock.
+            set( 'select', null ).
+            set( 'highlight', clock.item.now )
+    }
 
     // The keycode to movement mapping.
     clock.key = {
@@ -90,7 +91,11 @@ function TimePicker( picker, settings ) {
         39: 1, // Right
         37: -1, // Left
         go: function( timeChange ) {
-            clock.set( 'highlight', clock.item.highlight.pick + timeChange * clock.item.interval, { interval: timeChange * clock.item.interval } )
+            clock.set(
+                'highlight',
+                clock.item.highlight.pick + timeChange * clock.item.interval,
+                { interval: timeChange * clock.item.interval }
+            )
             this.render()
         }
     }
@@ -120,35 +125,46 @@ function TimePicker( picker, settings ) {
  */
 TimePicker.prototype.set = function( type, value, options ) {
 
-    var clock = this
+    var clock = this,
+        clockItem = clock.item
+
+    // If the value is `null` just set it immediately.
+    if ( value === null ) {
+        clockItem[ type ] = value
+        return clock
+    }
 
-    // Go through the queue of methods, and invoke the function. Update this
-    // as the time unit, and set the final resultant as this item type.
+    // Otherwise go through the queue of methods, and invoke the functions.
+    // Update this as the time unit, and set the final value as this item.
     // * In the case of `enable`, keep the queue but set `disable` instead.
     //   And in the case of `flip`, keep the queue but set `enable` instead.
-    clock.item[ ( type == 'enable' ? 'disable' : type == 'flip' ? 'enable' : type ) ] = clock.queue[ type ].split( ' ' ).map( function( method ) {
-        return value = clock[ method ]( type, value, options )
+    clockItem[ ( type == 'enable' ? 'disable' : type == 'flip' ? 'enable' : type ) ] = clock.queue[ type ].split( ' ' ).map( function( method ) {
+        value = clock[ method ]( type, value, options )
+        return value
     }).pop()
 
     // Check if we need to cascade through more updates.
     if ( type == 'select' ) {
-        clock.set( 'highlight', clock.item.select, options )
+        clock.set( 'highlight', clockItem.select, options )
     }
     else if ( type == 'highlight' ) {
-        clock.set( 'view', clock.item.highlight, options )
+        clock.set( 'view', clockItem.highlight, options )
     }
     else if ( type == 'interval' ) {
         clock.
-            set( 'min', clock.item.min, options ).
-            set( 'max', clock.item.max, options )
+            set( 'min', clockItem.min, options ).
+            set( 'max', clockItem.max, options )
     }
-    else if ( ( type == 'flip' || type == 'min' || type == 'max' || type == 'disable' || type == 'enable' ) && clock.item.select && clock.item.highlight ) {
+    else if ( type.match( /^(flip|min|max|disable|enable)$/ ) ) {
         if ( type == 'min' ) {
-            clock.set( 'max', clock.item.max, options )
+            clock.set( 'max', clockItem.max, options )
+        }
+        if ( clockItem.select && clock.disabled( clockItem.select ) ) {
+            clock.set( 'select', clockItem.select, options )
+        }
+        if ( clockItem.highlight && clock.disabled( clockItem.highlight ) ) {
+            clock.set( 'highlight', clockItem.highlight, options )
         }
-        clock.
-            set( 'select', clock.item.select, options ).
-            set( 'highlight', clock.item.highlight, options )
     }
 
     return clock
@@ -174,12 +190,12 @@ TimePicker.prototype.create = function( type, value, options ) {
     value = value === undefined ? type : value
 
     // If it’s a date object, convert it into an array.
-    if ( Picker._.isDate( value ) ) {
+    if ( _.isDate( value ) ) {
         value = [ value.getHours(), value.getMinutes() ]
     }
 
     // If it’s an object, use the “pick” value.
-    if ( $.isPlainObject( value ) && Picker._.isInteger( value.pick ) ) {
+    if ( $.isPlainObject( value ) && _.isInteger( value.pick ) ) {
         value = value.pick
     }
 
@@ -189,7 +205,7 @@ TimePicker.prototype.create = function( type, value, options ) {
     }
 
     // If no valid value is passed, set it to “now”.
-    else if ( !Picker._.isInteger( value ) ) {
+    else if ( !_.isInteger( value ) ) {
         value = clock.now( type, value, options )
     }
 
@@ -225,31 +241,99 @@ TimePicker.prototype.create = function( type, value, options ) {
 } //TimePicker.prototype.create
 
 
+/**
+ * Create a range limit object using an array, date object,
+ * literal “true”, or integer relative to another time.
+ */
+TimePicker.prototype.createRange = function( from, to ) {
+
+    var clock = this,
+        createTime = function( time ) {
+            if ( time === true || $.isArray( time ) || _.isDate( time ) ) {
+                return clock.create( time )
+            }
+            return time
+        }
+
+    // Create objects if possible.
+    if ( !_.isInteger( from ) ) {
+        from = createTime( from )
+    }
+    if ( !_.isInteger( to ) ) {
+        to = createTime( to )
+    }
+
+    // Create relative times.
+    if ( _.isInteger( from ) && $.isPlainObject( to ) ) {
+        from = [ to.hour, to.mins + ( from * clock.settings.interval ) ];
+    }
+    else if ( _.isInteger( to ) && $.isPlainObject( from ) ) {
+        to = [ from.hour, from.mins + ( to * clock.settings.interval ) ];
+    }
+
+    return {
+        from: createTime( from ),
+        to: createTime( to )
+    }
+} //TimePicker.prototype.createRange
+
+
+/**
+ * Check if a time unit falls within a time range object.
+ */
+TimePicker.prototype.withinRange = function( range, timeUnit ) {
+    range = this.createRange(range.from, range.to)
+    return timeUnit.pick >= range.from.pick && timeUnit.pick <= range.to.pick
+}
+
+
+/**
+ * Check if two time range objects overlap.
+ */
+TimePicker.prototype.overlapRanges = function( one, two ) {
+
+    var clock = this
+
+    // Convert the ranges into comparable times.
+    one = clock.createRange( one.from, one.to )
+    two = clock.createRange( two.from, two.to )
+
+    return clock.withinRange( one, two.from ) || clock.withinRange( one, two.to ) ||
+        clock.withinRange( two, one.from ) || clock.withinRange( two, one.to )
+}
+
+
 /**
  * Get the time relative to now.
  */
 TimePicker.prototype.now = function( type, value/*, options*/ ) {
 
-    var date = new Date(),
-        dateMinutes = date.getHours() * MINUTES_IN_HOUR + date.getMinutes()
+    var interval = this.item.interval,
+        date = new Date(),
+        nowMinutes = date.getHours() * MINUTES_IN_HOUR + date.getMinutes(),
+        isValueInteger = _.isInteger( value ),
+        isBelowInterval
 
     // Make sure “now” falls within the interval range.
-    dateMinutes -= dateMinutes % this.item.interval
+    nowMinutes -= nowMinutes % interval
 
-    // If the value is a number, adjust by that many intervals because
-    // the time has passed. In the case of “midnight” and a negative `min`,
-    // increase the value by 2. Otherwise increase it by 1.
-    if ( Picker._.isInteger( value ) ) {
-        value += type == 'min' && value < 0 && dateMinutes === 0 ? 2 : 1
-    }
+    // Check if the difference is less than the interval itself.
+    isBelowInterval = value < 0 && interval * value + nowMinutes <= -interval
 
-    // If the value isn’t a number, default to 1 passed interval.
-    else {
-        value = 1
+    // Add an interval because the time has “passed”.
+    nowMinutes += type == 'min' && isBelowInterval ? 0 : interval
+
+    // If the value is a number, adjust by that many intervals.
+    if ( isValueInteger ) {
+        nowMinutes += interval * (
+            isBelowInterval && type != 'max' ?
+                value + 1 :
+                value
+            )
     }
 
-    // Calculate the final relative time.
-    return value * this.item.interval + dateMinutes
+    // Return the final calculation.
+    return nowMinutes
 } //TimePicker.prototype.now
 
 
@@ -259,14 +343,15 @@ TimePicker.prototype.now = function( type, value/*, options*/ ) {
 TimePicker.prototype.normalize = function( type, value/*, options*/ ) {
 
     var interval = this.item.interval,
+        minTime = this.item.min && this.item.min.pick || 0
 
-        // If setting min time, don’t shift anything.
-        // Otherwise get the value and min difference and then
-        // normalize the difference with the interval.
-        difference = type == 'min' ? 0 : ( value - this.item.min.pick ) % interval
+    // If setting min time, don’t shift anything.
+    // Otherwise get the value and min difference and then
+    // normalize the difference with the interval.
+    value -= type == 'min' ? 0 : ( value - minTime ) % interval
 
-    // If it’s a negative value, add one interval to keep it as “passed”.
-    return value - ( difference + ( value < 0 ? interval : 0 ) )
+    // Return the adjusted value.
+    return value
 } //TimePicker.prototype.normalize
 
 
@@ -283,12 +368,12 @@ TimePicker.prototype.measure = function( type, value, options ) {
     }
 
     // If it’s a literal true, or an integer, make it relative to now.
-    else if ( value === true || Picker._.isInteger( value ) ) {
+    else if ( value === true || _.isInteger( value ) ) {
         value = clock.now( type, value, options )
     }
 
     // If it’s an object already, just normalize it.
-    else if ( $.isPlainObject( value ) && Picker._.isInteger( value.pick ) ) {
+    else if ( $.isPlainObject( value ) && _.isInteger( value.pick ) ) {
         value = clock.normalize( type, value.pick, options )
     }
 
@@ -328,34 +413,39 @@ TimePicker.prototype.validate = function( type, timeObject, options ) {
 /**
  * Check if an object is disabled.
  */
-TimePicker.prototype.disabled = function( timeObject ) {
+TimePicker.prototype.disabled = function( timeToVerify ) {
 
-    var
-        clock = this,
+    var clock = this,
 
         // Filter through the disabled times to check if this is one.
         isDisabledMatch = clock.item.disable.filter( function( timeToDisable ) {
 
             // If the time is a number, match the hours.
-            if ( Picker._.isInteger( timeToDisable ) ) {
-                return timeObject.hour == timeToDisable
+            if ( _.isInteger( timeToDisable ) ) {
+                return timeToVerify.hour == timeToDisable
             }
 
             // If it’s an array, create the object and match the times.
-            if ( $.isArray( timeToDisable ) || Picker._.isDate( timeToDisable ) ) {
-                return timeObject.pick == clock.create( timeToDisable ).pick
+            if ( $.isArray( timeToDisable ) || _.isDate( timeToDisable ) ) {
+                return timeToVerify.pick == clock.create( timeToDisable ).pick
+            }
+
+            // If it’s an object, match a time within the “from” and “to” range.
+            if ( $.isPlainObject( timeToDisable ) ) {
+                return clock.withinRange( timeToDisable, timeToVerify )
             }
         })
 
     // If this time matches a disabled time, confirm it’s not inverted.
     isDisabledMatch = isDisabledMatch.length && !isDisabledMatch.filter(function( timeToDisable ) {
-        return $.isArray( timeToDisable ) && timeToDisable[2] == 'inverted'
+        return $.isArray( timeToDisable ) && timeToDisable[2] == 'inverted' ||
+            $.isPlainObject( timeToDisable ) && timeToDisable.inverted
     }).length
 
     // If the clock is "enabled" flag is flipped, flip the condition.
     return clock.item.enable === -1 ? !isDisabledMatch : isDisabledMatch ||
-        timeObject.pick < clock.item.min.pick ||
-        timeObject.pick > clock.item.max.pick
+        timeToVerify.pick < clock.item.min.pick ||
+        timeToVerify.pick > clock.item.max.pick
 } //TimePicker.prototype.disabled
 
 
@@ -366,12 +456,18 @@ TimePicker.prototype.shift = function( timeObject, interval ) {
 
     var clock = this,
         minLimit = clock.item.min.pick,
-        maxLimit = clock.item.max.pick
+        maxLimit = clock.item.max.pick/*,
+        safety = 1000*/
 
     interval = interval || clock.item.interval
 
     // Keep looping as long as the time is disabled.
-    while ( clock.disabled( timeObject ) ) {
+    while ( /*safety &&*/ clock.disabled( timeObject ) ) {
+
+        /*safety -= 1
+        if ( !safety ) {
+            throw 'Fell into an infinite loop while shifting to ' + timeObject.hour + ':' + timeObject.mins + '.'
+        }*/
 
         // Increase/decrease the time by the interval and keep looping.
         timeObject = clock.create( timeObject.pick += interval )
@@ -402,45 +498,67 @@ TimePicker.prototype.scope = function( timeObject ) {
  */
 TimePicker.prototype.parse = function( type, value, options ) {
 
-    var clock = this,
+    var hour, minutes, isPM, item, parseValue,
+        clock = this,
         parsingObject = {}
 
-    if ( !value || Picker._.isInteger( value ) || $.isArray( value ) || Picker._.isDate( value ) || $.isPlainObject( value ) && Picker._.isInteger( value.pick ) ) {
+    if ( !value || _.isInteger( value ) || $.isArray( value ) || _.isDate( value ) || $.isPlainObject( value ) && _.isInteger( value.pick ) ) {
         return value
     }
 
-    // We need a `.format` to parse the value.
+    // We need a `.format` to parse the value with.
     if ( !( options && options.format ) ) {
-        throw "Need a formatting option to parse this.."
+        options = options || {}
+        options.format = clock.settings.format
     }
 
     // Convert the format into an array and then map through it.
     clock.formats.toArray( options.format ).map( function( label ) {
 
         var
+            substring,
+
             // Grab the formatting label.
             formattingLabel = clock.formats[ label ],
 
             // The format length is from the formatting label function or the
             // label length without the escaping exclamation (!) mark.
-            formatLength = formattingLabel ? Picker._.trigger( formattingLabel, clock, [ value, parsingObject ] ) : label.replace( /^!/, '' ).length
+            formatLength = formattingLabel ?
+                _.trigger( formattingLabel, clock, [ value, parsingObject ] ) :
+                label.replace( /^!/, '' ).length
 
         // If there's a format label, split the value up to the format length.
         // Then add it to the parsing object with appropriate label.
         if ( formattingLabel ) {
-            parsingObject[ label ] = value.substr( 0, formatLength )
+            substring = value.substr( 0, formatLength )
+            parsingObject[ label ] = substring.match(/^\d+$/) ? +substring : substring
         }
 
         // Update the time value as the substring from format length to end.
         value = value.substr( formatLength )
     })
 
-    return +parsingObject.i + MINUTES_IN_HOUR * (
-
-        +( parsingObject.H || parsingObject.HH ) ||
+    // Grab the hour and minutes from the parsing object.
+    for ( item in parsingObject ) {
+        parseValue = parsingObject[item]
+        if ( _.isInteger(parseValue) ) {
+            if ( item.match(/^(h|hh)$/i) ) {
+                hour = parseValue
+                if ( item == 'h' || item == 'hh' ) {
+                    hour %= 12
+                }
+            }
+            else if ( item == 'i' ) {
+                minutes = parseValue
+            }
+        }
+        else if ( item.match(/^a$/i) && parseValue.match(/^p/i) && ('h' in parsingObject || 'hh' in parsingObject) ) {
+            isPM = true
+        }
+    }
 
-        ( +( parsingObject.h || parsingObject.hh ) % 12 + ( /^p/i.test( parsingObject.A || parsingObject.a ) ? 12 : 0 ) )
-    )
+    // Calculate it in minutes and return.
+    return (isPM ? hour + 12 : hour) * MINUTES_IN_HOUR + minutes
 } //TimePicker.prototype.parse
 
 
@@ -453,31 +571,31 @@ TimePicker.prototype.formats = {
 
         // If there's string, then get the digits length.
         // Otherwise return the selected hour in "standard" format.
-        return string ? Picker._.digits( string ) : timeObject.hour % HOURS_TO_NOON || HOURS_TO_NOON
+        return string ? _.digits( string ) : timeObject.hour % HOURS_TO_NOON || HOURS_TO_NOON
     },
     hh: function( string, timeObject ) {
 
         // If there's a string, then the length is always 2.
         // Otherwise return the selected hour in "standard" format with a leading zero.
-        return string ? 2 : Picker._.lead( timeObject.hour % HOURS_TO_NOON || HOURS_TO_NOON )
+        return string ? 2 : _.lead( timeObject.hour % HOURS_TO_NOON || HOURS_TO_NOON )
     },
     H: function( string, timeObject ) {
 
         // If there's string, then get the digits length.
         // Otherwise return the selected hour in "military" format as a string.
-        return string ? Picker._.digits( string ) : '' + ( timeObject.hour % 24 )
+        return string ? _.digits( string ) : '' + ( timeObject.hour % 24 )
     },
     HH: function( string, timeObject ) {
 
         // If there's string, then get the digits length.
         // Otherwise return the selected hour in "military" format with a leading zero.
-        return string ? Picker._.digits( string ) : Picker._.lead( timeObject.hour % 24 )
+        return string ? _.digits( string ) : _.lead( timeObject.hour % 24 )
     },
     i: function( string, timeObject ) {
 
         // If there's a string, then the length is always 2.
         // Otherwise return the selected minutes.
-        return string ? 2 : Picker._.lead( timeObject.mins )
+        return string ? 2 : _.lead( timeObject.mins )
     },
     a: function( string, timeObject ) {
 
@@ -499,156 +617,235 @@ TimePicker.prototype.formats = {
     toString: function ( formatString, itemObject ) {
         var clock = this
         return clock.formats.toArray( formatString ).map( function( label ) {
-            return Picker._.trigger( clock.formats[ label ], clock, [ 0, itemObject ] ) || label.replace( /^!/, '' )
+            return _.trigger( clock.formats[ label ], clock, [ 0, itemObject ] ) || label.replace( /^!/, '' )
         }).join( '' )
     }
 } //TimePicker.prototype.formats
 
 
+
+
 /**
- * Flip an item as enabled or disabled.
+ * Check if two time units are the exact.
  */
-TimePicker.prototype.flipItem = function( type, value/*, options*/ ) {
+TimePicker.prototype.isTimeExact = function( one, two ) {
 
-    var clock = this,
-        collection = clock.item.disable,
-        isFlippedBase = clock.item.enable === -1
+    var clock = this
 
-    // Flip the enabled and disabled times.
-    if ( value == 'flip' ) {
-        clock.item.enable = isFlippedBase ? 1 : -1
+    // When we’re working with minutes, do a direct comparison.
+    if (
+        ( _.isInteger( one ) && _.isInteger( two ) ) ||
+        ( typeof one == 'boolean' && typeof two == 'boolean' )
+     ) {
+        return one === two
     }
 
-    // Reset the collection and enable the base state.
-    else if ( ( type == 'enable' && value === true ) || ( type == 'disable' && value === false ) ) {
-        clock.item.enable = 1
-        collection = []
+    // When we’re working with time representations, compare the “pick” value.
+    if (
+        ( _.isDate( one ) || $.isArray( one ) ) &&
+        ( _.isDate( two ) || $.isArray( two ) )
+    ) {
+        return clock.create( one ).pick === clock.create( two ).pick
     }
 
-    // Reset the collection and disable the base state.
-    else if ( ( type == 'enable' && value === false ) || ( type == 'disable' && value === true ) ) {
-        clock.item.enable = -1
-        collection = []
+    // When we’re working with range objects, compare the “from” and “to”.
+    if ( $.isPlainObject( one ) && $.isPlainObject( two ) ) {
+        return clock.isTimeExact( one.from, two.from ) && clock.isTimeExact( one.to, two.to )
     }
 
-    // Make sure a collection of things was passed to add/remove.
-    else if ( $.isArray( value ) ) {
+    return false
+}
 
-        // Check if we have to add/remove from collection.
-        if ( isFlippedBase && type == 'enable' || !isFlippedBase && type == 'disable' ) {
-            collection = clock.addDisabled( collection, value )
-        }
-        else if ( !isFlippedBase && type == 'enable' ) {
-            collection = clock.addEnabled( collection, value )
-        }
-        else if ( isFlippedBase && type == 'disable' ) {
-            collection = clock.removeDisabled( collection, value )
-        }
+
+/**
+ * Check if two time units overlap.
+ */
+TimePicker.prototype.isTimeOverlap = function( one, two ) {
+
+    var clock = this
+
+    // When we’re working with an integer, compare the hours.
+    if ( _.isInteger( one ) && ( _.isDate( two ) || $.isArray( two ) ) ) {
+        return one === clock.create( two ).hour
+    }
+    if ( _.isInteger( two ) && ( _.isDate( one ) || $.isArray( one ) ) ) {
+        return two === clock.create( one ).hour
     }
 
-    return collection
-} //TimePicker.prototype.flipItem
+    // When we’re working with range objects, check if the ranges overlap.
+    if ( $.isPlainObject( one ) && $.isPlainObject( two ) ) {
+        return clock.overlapRanges( one, two )
+    }
+
+    return false
+}
 
 
 /**
- * Add an enabled (inverted) item to the disabled collection.
+ * Flip the “enabled” state.
  */
-TimePicker.prototype.addEnabled = function( collection, item ) {
+TimePicker.prototype.flipEnable = function(val) {
+    var itemObject = this.item
+    itemObject.enable = val || (itemObject.enable == -1 ? 1 : -1)
+}
 
-    var clock = this
 
-    // Go through each item to enable.
-    item.map( function( timeUnit ) {
-
-        // Check if the time unit is already within the collection.
-        if ( clock.filterDisabled( collection, timeUnit, 1 ).length ) {
-
-            // Remove the unit directly from the collection.
-            collection = clock.removeDisabled( collection, [timeUnit] )
-
-            // If the unit is an array and it falls within a
-            // disabled weekday, invert it and then insert it.
-            if (
-                $.isArray( timeUnit ) &&
-                collection.filter( function( disabledHour ) {
-                    return Picker._.isInteger( disabledHour ) && clock.create( timeUnit ).hour === disabledHour
-                }).length
-            ) {
-                timeUnit = timeUnit.slice(0)
-                timeUnit.push( 'inverted' )
-                collection.push( timeUnit )
+/**
+ * Mark a collection of times as “disabled”.
+ */
+TimePicker.prototype.deactivate = function( type, timesToDisable ) {
+
+    var clock = this,
+        disabledItems = clock.item.disable.slice(0)
+
+
+    // If we’re flipping, that’s all we need to do.
+    if ( timesToDisable == 'flip' ) {
+        clock.flipEnable()
+    }
+
+    else if ( timesToDisable === false ) {
+        clock.flipEnable(1)
+        disabledItems = []
+    }
+
+    else if ( timesToDisable === true ) {
+        clock.flipEnable(-1)
+        disabledItems = []
+    }
+
+    // Otherwise go through the times to disable.
+    else {
+
+        timesToDisable.map(function( unitToDisable ) {
+
+            var matchFound
+
+            // When we have disabled items, check for matches.
+            // If something is matched, immediately break out.
+            for ( var index = 0; index < disabledItems.length; index += 1 ) {
+                if ( clock.isTimeExact( unitToDisable, disabledItems[index] ) ) {
+                    matchFound = true
+                    break
+                }
             }
-        }
-    })
 
-    // Return the final collection.
-    return collection
-} //TimePicker.prototype.addEnabled
+            // If nothing was found, add the validated unit to the collection.
+            if ( !matchFound ) {
+                if (
+                    _.isInteger( unitToDisable ) ||
+                    _.isDate( unitToDisable ) ||
+                    $.isArray( unitToDisable ) ||
+                    ( $.isPlainObject( unitToDisable ) && unitToDisable.from && unitToDisable.to )
+                ) {
+                    disabledItems.push( unitToDisable )
+                }
+            }
+        })
+    }
+
+    // Return the updated collection.
+    return disabledItems
+} //TimePicker.prototype.deactivate
 
 
 /**
- * Add an item to the disabled collection.
+ * Mark a collection of times as “enabled”.
  */
-TimePicker.prototype.addDisabled = function( collection, item ) {
+TimePicker.prototype.activate = function( type, timesToEnable ) {
 
-    var clock = this
+    var clock = this,
+        disabledItems = clock.item.disable,
+        disabledItemsCount = disabledItems.length
 
-    // Go through each item to disable.
-    item.map( function( timeUnit ) {
+    // If we’re flipping, that’s all we need to do.
+    if ( timesToEnable == 'flip' ) {
+        clock.flipEnable()
+    }
 
-        // Add the time unit if it isn’t already within the collection.
-        if ( !clock.filterDisabled( collection, timeUnit ).length ) {
-            collection.push( timeUnit )
-        }
+    else if ( timesToEnable === true ) {
+        clock.flipEnable(1)
+        disabledItems = []
+    }
 
-        // If the time unit is an array and falls within the range, just remove it.
-        else if ( $.isArray( timeUnit ) && clock.filterDisabled( collection, timeUnit, 1 ).length ) {
-            collection = clock.removeDisabled( collection, [timeUnit] )
-        }
-    })
+    else if ( timesToEnable === false ) {
+        clock.flipEnable(-1)
+        disabledItems = []
+    }
 
-    // Return the final collection.
-    return collection
-} //TimePicker.prototype.addDisabled
+    // Otherwise go through the disabled times.
+    else {
 
+        timesToEnable.map(function( unitToEnable ) {
 
-/**
- * Remove an item from the disabled collection.
- */
-TimePicker.prototype.removeDisabled = function( collection, item ) {
+            var matchFound,
+                disabledUnit,
+                index,
+                isRangeMatched
 
-    var clock = this
+            // Go through the disabled items and try to find a match.
+            for ( index = 0; index < disabledItemsCount; index += 1 ) {
 
-    // Go through each item to enable.
-    item.map( function( timeUnit ) {
+                disabledUnit = disabledItems[index]
 
-        // Filter each item out of the collection.
-        collection = clock.filterDisabled( collection, timeUnit, 1 )
-    })
+                // When an exact match is found, remove it from the collection.
+                if ( clock.isTimeExact( disabledUnit, unitToEnable ) ) {
+                    matchFound = disabledItems[index] = null
+                    isRangeMatched = true
+                    break
+                }
 
-    // Return the final colleciton.
-    return collection
-} //TimePicker.prototype.removeDisabled
+                // When an overlapped match is found, add the “inverted” state to it.
+                else if ( clock.isTimeOverlap( disabledUnit, unitToEnable ) ) {
+                    if ( $.isPlainObject( unitToEnable ) ) {
+                        unitToEnable.inverted = true
+                        matchFound = unitToEnable
+                    }
+                    else if ( $.isArray( unitToEnable ) ) {
+                        matchFound = unitToEnable
+                        if ( !matchFound[2] ) matchFound.push( 'inverted' )
+                    }
+                    else if ( _.isDate( unitToEnable ) ) {
+                        matchFound = [ unitToEnable.getFullYear(), unitToEnable.getMonth(), unitToEnable.getDate(), 'inverted' ]
+                    }
+                    break
+                }
+            }
 
+            // If a match was found, remove a previous duplicate entry.
+            if ( matchFound ) for ( index = 0; index < disabledItemsCount; index += 1 ) {
+                if ( clock.isTimeExact( disabledItems[index], unitToEnable ) ) {
+                    disabledItems[index] = null
+                    break
+                }
+            }
 
-/**
- * Filter through the disabled collection to find a time unit.
- */
-TimePicker.prototype.filterDisabled = function( collection, timeUnit, isRemoving ) {
-    var timeIsArray = $.isArray( timeUnit )
-    return collection.filter( function( disabledTimeUnit ) {
-        var isMatch = !timeIsArray && timeUnit === disabledTimeUnit ||
-            timeIsArray && $.isArray( disabledTimeUnit ) && timeUnit.toString() === disabledTimeUnit.toString()
-        return isRemoving ? !isMatch : isMatch
-    })
-} //TimePicker.prototype.filterDisabled
+            // In the event that we’re dealing with an overlap of range times,
+            // make sure there are no “inverted” times because of it.
+            if ( isRangeMatched ) for ( index = 0; index < disabledItemsCount; index += 1 ) {
+                if ( clock.isTimeOverlap( disabledItems[index], unitToEnable ) ) {
+                    disabledItems[index] = null
+                    break
+                }
+            }
+
+            // If something is still matched, add it into the collection.
+            if ( matchFound ) {
+                disabledItems.push( matchFound )
+            }
+        })
+    }
+
+    // Return the updated collection.
+    return disabledItems.filter(function( val ) { return val != null })
+} //TimePicker.prototype.activate
 
 
 /**
  * The division to use for the range intervals.
  */
 TimePicker.prototype.i = function( type, value/*, options*/ ) {
-    return Picker._.isInteger( value ) && value > 0 ? value : this.item.interval
+    return _.isInteger( value ) && value > 0 ? value : this.item.interval
 }
 
 
@@ -665,42 +862,68 @@ TimePicker.prototype.nodes = function( isOpen ) {
         viewsetObject = clock.item.view,
         disabledCollection = clock.item.disable
 
-    return Picker._.node( 'ul', Picker._.group({
-        min: clock.item.min.pick,
-        max: clock.item.max.pick,
-        i: clock.item.interval,
-        node: 'li',
-        item: function( loopedTime ) {
-            loopedTime = clock.create( loopedTime )
-            return [
-                Picker._.trigger( clock.formats.toString, clock, [ Picker._.trigger( settings.formatLabel, clock, [ loopedTime ] ) || settings.format, loopedTime ] ),
-                (function( klasses, timeMinutes ) {
-
-                    if ( selectedObject && selectedObject.pick == timeMinutes ) {
-                        klasses.push( settings.klass.selected )
-                    }
-
-                    if ( highlightedObject && highlightedObject.pick == timeMinutes ) {
-                        klasses.push( settings.klass.highlighted )
-                    }
-
-                    if ( viewsetObject && viewsetObject.pick == timeMinutes ) {
-                        klasses.push( settings.klass.viewset )
-                    }
-
-                    if ( disabledCollection && clock.disabled( loopedTime ) ) {
-                        klasses.push( settings.klass.disabled )
-                    }
-
-                    return klasses.join( ' ' )
-                })( [ settings.klass.listItem ], loopedTime.pick ),
-                'data-pick=' + loopedTime.pick
-            ]
-        }
-    }) +
-
-    // * For Firefox forms to submit, make sure to set the button’s `type` attribute as “button”.
-    Picker._.node( 'li', Picker._.node( 'button', settings.clear, settings.klass.buttonClear, 'type=button data-clear=1' + ( isOpen ? '' : ' disable' ) ) ), settings.klass.list )
+    return _.node(
+        'ul',
+        _.group({
+            min: clock.item.min.pick,
+            max: clock.item.max.pick,
+            i: clock.item.interval,
+            node: 'li',
+            item: function( loopedTime ) {
+                loopedTime = clock.create( loopedTime )
+                var timeMinutes = loopedTime.pick,
+                    isSelected = selectedObject && selectedObject.pick == timeMinutes,
+                    isHighlighted = highlightedObject && highlightedObject.pick == timeMinutes,
+                    isDisabled = disabledCollection && clock.disabled( loopedTime )
+                return [
+                    _.trigger( clock.formats.toString, clock, [ _.trigger( settings.formatLabel, clock, [ loopedTime ] ) || settings.format, loopedTime ] ),
+                    (function( klasses ) {
+
+                        if ( isSelected ) {
+                            klasses.push( settings.klass.selected )
+                        }
+
+                        if ( isHighlighted ) {
+                            klasses.push( settings.klass.highlighted )
+                        }
+
+                        if ( viewsetObject && viewsetObject.pick == timeMinutes ) {
+                            klasses.push( settings.klass.viewset )
+                        }
+
+                        if ( isDisabled ) {
+                            klasses.push( settings.klass.disabled )
+                        }
+
+                        return klasses.join( ' ' )
+                    })( [ settings.klass.listItem ] ),
+                    'data-pick=' + loopedTime.pick + ' ' + _.ariaAttr({
+                        role: 'button',
+                        controls: clock.$node[0].id,
+                        checked: isSelected && clock.$node.val() === _.trigger(
+                                clock.formats.toString,
+                                clock,
+                                [ settings.format, loopedTime ]
+                            ) ? true : null,
+                        activedescendant: isHighlighted ? true : null,
+                        disabled: isDisabled ? true : null
+                    })
+                ]
+            }
+        }) +
+
+        // * For Firefox forms to submit, make sure to set the button’s `type` attribute as “button”.
+        _.node(
+            'li',
+            _.node(
+                'button',
+                settings.clear,
+                settings.klass.buttonClear,
+                'type=button data-clear=1' + ( isOpen ? '' : ' disable' )
+            )
+        ),
+        settings.klass.list
+    )
 } //TimePicker.prototype.nodes
 
 
@@ -751,7 +974,7 @@ TimePicker.defaults = (function( prefix ) {
 
 
 /**
- * Extend the picker to add the date picker.
+ * Extend the picker to add the time picker.
  */
 Picker.extend( 'pickatime', TimePicker )