nouislider-rails 6.2.0 → 7.0.1

data/vendor/assets/javascripts/nouislider/optional.pips.js

@@ -0,0 +1,234 @@
+/*jslint browser: true */
+/*jslint white: true */
+
+(function( $ ){
+
+	'use strict';
+
+	// Removes duplicates from an array.
+	function unique(array) {
+		return $.grep(array, function(el, index) {
+			return index === $.inArray(el, array);
+		});
+	}
+
+// Pips
+
+	function getGroup ( $Spectrum, mode, values, stepped ) {
+
+		// Use the range.
+		if ( mode === 'range' || mode === 'steps' ) {
+			return $Spectrum.xVal;
+		}
+
+		if ( mode === 'count' ) {
+
+			// Divide 0 - 100 in 'count' parts.
+			var spread = ( 100 / (values-1) ), v, i = 0;
+			values = [];
+
+			// List these parts and have them handled as 'positions'.
+			while ((v=i++*spread) <= 100 ) {
+				values.push(v);
+			}
+
+			mode = 'positions';
+		}
+
+		if ( mode === 'positions' ) {
+
+			// Map all percentages to on-range values.
+			return $.map(values, function( value ){
+				return $Spectrum.fromStepping( stepped ? $Spectrum.getStep( value ) : value );
+			});
+		}
+
+		if ( mode === 'values' ) {
+
+			// If the value must be stepped, it needs to be converted to a percentage first.
+			if ( stepped ) {
+
+				return $.map(values, function( value ){
+
+					// Convert to percentage, apply step, return to value.
+					return $Spectrum.fromStepping( $Spectrum.getStep( $Spectrum.toStepping( value ) ) );
+				});
+
+			}
+
+			// Otherwise, we can simply use the values.
+			return values;
+		}
+	}
+
+	function generateSpread ( $Spectrum, density, mode, group ) {
+
+		var originalSpectrumDirection = $Spectrum.direction,
+			indexes = {},
+			firstInRange = $Spectrum.xVal[0],
+			lastInRange = $Spectrum.xVal[$Spectrum.xVal.length-1],
+			ignoreFirst = false,
+			ignoreLast = false,
+			prevPct = 0;
+
+		// This function loops the spectrum in an ltr linear fashion,
+		// while the toStepping method is direction aware. Trick it into
+		// believing it is ltr.
+		$Spectrum.direction = 0;
+
+		// Create a copy of the group, sort it and filter away all duplicates.
+		group = unique(group.slice().sort(function(a, b){ return a - b; }));
+
+		// Make sure the range starts with the first element.
+		if ( group[0] !== firstInRange ) {
+			group.unshift(firstInRange);
+			ignoreFirst = true;
+		}
+
+		// Likewise for the last one.
+		if ( group[group.length - 1] !== lastInRange ) {
+			group.push(lastInRange);
+			ignoreLast = true;
+		}
+
+		$.each(group, function ( index ) {
+
+			// Get the current step and the lower + upper positions.
+			var step, i, q,
+				low = group[index],
+				high = group[index+1],
+				newPct, pctDifference, pctPos, type,
+				steps, realSteps, stepsize;
+
+			// When using 'steps' mode, use the provided steps.
+			// Otherwise, we'll step on to the next subrange.
+			if ( mode === 'steps' ) {
+				step = $Spectrum.xNumSteps[ index ];
+			}
+
+			// Default to a 'full' step.
+			if ( !step ) {
+				step = high-low;
+			}
+
+			// Low can be 0, so test for false. If high is undefined,
+			// we are at the last subrange. Index 0 is already handled.
+			if ( low === false || high === undefined ) {
+				return;
+			}
+
+			// Find all steps in the subrange.
+			for ( i = low; i <= high; i += step ) {
+
+				// Get the percentage value for the current step,
+				// calculate the size for the subrange.
+				newPct = $Spectrum.toStepping( i );
+				pctDifference = newPct - prevPct;
+
+				steps = pctDifference / density;
+				realSteps = Math.round(steps);
+
+				// This ratio represents the ammount of percentage-space a point indicates.
+				// For a density 1 the points/percentage = 1. For density 2, that percentage needs to be re-devided.
+				// Round the percentage offset to an even number, then divide by two
+				// to spread the offset on both sides of the range.
+				stepsize = pctDifference/realSteps;
+
+				// Divide all points evenly, adding the correct number to this subrange.
+				// Run up to <= so that 100% gets a point, event if ignoreLast is set.
+				for ( q = 1; q <= realSteps; q += 1 ) {
+
+					// The ratio between the rounded value and the actual size might be ~1% off.
+					// Correct the percentage offset by the number of points
+					// per subrange. density = 1 will result in 100 points on the
+					// full range, 2 for 50, 4 for 25, etc.
+					pctPos = prevPct + ( q * stepsize );
+					indexes[pctPos.toFixed(5)] = ['x', 0];
+				}
+
+				// Determine the point type.
+				type = ($.inArray(i, group) > -1) ? 1 : ( mode === 'steps' ? 2 : 0 );
+
+				// Enforce the 'ignoreFirst' option by overwriting the type for 0.
+				if ( !index && ignoreFirst && !low ) {
+					type = 0;
+				}
+
+				if ( !(i === high && ignoreLast)) {
+					// Mark the 'type' of this point. 0 = plain, 1 = real value, 2 = step value.
+					indexes[newPct.toFixed(5)] = [i, type];
+				}
+
+				// Update the percentage count.
+				prevPct = newPct;
+			}
+		});
+
+		// Reset the spectrum.
+		$Spectrum.direction = originalSpectrumDirection;
+
+		return indexes;
+	}
+
+	function addMarking ( CSSstyle, orientation, direction, spread, filterFunc ) {
+
+		var style = ['horizontal', 'vertical'][orientation],
+			element = $('<div/>');
+
+		element.addClass('noUi-pips noUi-pips-'+style);
+
+		function getSize( type, value ){
+			return [ '-normal', '-large', '-sub' ][(type&&filterFunc) ? filterFunc(value, type) : type];
+		}
+		function getTags( offset, source, values ) {
+			return 'class="' + source + ' ' +
+				source + '-' + style + ' ' +
+				source + getSize(values[1], values[0]) +
+				'" style="' + CSSstyle + ': ' + offset + '%"';
+		}
+		function addSpread ( offset, values ){
+
+			if ( direction ) {
+				offset = 100 - offset;
+			}
+
+			// Add a marker for every point
+			element.append('<div '+getTags(offset, 'noUi-marker', values)+'></div>');
+
+			// Values are only appended for points marked '1' or '2'.
+			if ( values[1] ) {
+				element.append('<div '+getTags(offset, 'noUi-value', values)+'>' + Math.round(values[0]) + '</div>');
+			}
+		}
+
+		// Append all points.
+		$.each(spread, addSpread);
+
+		return element;
+	}
+
+	$.fn.noUiSlider_pips = function ( grid ) {
+
+	var mode = grid.mode,
+		density = grid.density || 1,
+		filter = grid.filter || false,
+		values = grid.values || false,
+		stepped = grid.stepped || false;
+
+		return this.each(function(){
+
+		var info = this.getInfo(),
+			group = getGroup( info[0], mode, values, stepped ),
+			spread = generateSpread( info[0], density, mode, group );
+
+			return $(this).append(addMarking(
+				info[1],
+				info[2],
+				info[0].direction,
+				spread,
+				filter
+			));
+		});
+	};
+
+}( window.jQuery || window.Zepto ));

data/vendor/assets/javascripts/wnumb/wNumb.js

@@ -0,0 +1,335 @@
+(function(){
+
+    'use strict';
+
+    var
+        /** @const */ FormatOptions = [
+            'decimals',
+            'thousand',
+            'mark',
+            'prefix',
+            'postfix',
+            'encoder',
+            'decoder',
+            'negativeBefore',
+            'negative',
+            'edit',
+            'undo'
+        ];
+
+// General
+
+    // Reverse a string
+    function strReverse ( a ) {
+        return a.split('').reverse().join('');
+    }
+
+    // Check if a string starts with a specified prefix.
+    function strStartsWith ( input, match ) {
+        return input.substring(0, match.length) === match;
+    }
+
+    // Check is a string ends in a specified postfix.
+    function strEndsWith ( input, match ) {
+        return input.slice(-1 * match.length) === match;
+    }
+
+    // Throw an error if formatting options are incompatible.
+    function throwEqualError( F, a, b ) {
+        if ( (F[a] || F[b]) && (F[a] === F[b]) ) {
+            throw new Error(a);
+        }
+    }
+
+    // Check if a number is finite and not NaN
+    function isValidNumber ( input ) {
+        return typeof input === 'number' && isFinite( input );
+    }
+
+    // Provide rounding-accurate toFixed method.
+    function toFixed ( value, decimals ) {
+        var scale = Math.pow(10, decimals);
+        return ( Math.round(value * scale) / scale).toFixed( decimals );
+    }
+
+
+// Formatting
+
+    // Accept a number as input, output formatted string.
+    function formatTo ( decimals, thousand, mark, prefix, postfix, encoder, decoder, negativeBefore, negative, edit, undo, input ) {
+
+        var originalInput = input, inputIsNegative, inputPieces, inputBase, inputDecimals = '', output = '';
+
+        // Apply user encoder to the input.
+        // Expected outcome: number.
+        if ( encoder ) {
+            input = encoder(input);
+        }
+
+        // Stop if no valid number was provided, the number is infinite or NaN.
+        if ( !isValidNumber(input) ) {
+            return false;
+        }
+
+        // Rounding away decimals might cause a value of -0
+        // when using very small ranges. Remove those cases.
+        if ( decimals && parseFloat(input.toFixed(decimals)) === 0 ) {
+            input = 0;
+        }
+
+        // Formatting is done on absolute numbers,
+        // decorated by an optional negative symbol.
+        if ( input < 0 ) {
+            inputIsNegative = true;
+            input = Math.abs(input);
+        }
+
+        // Reduce the number of decimals to the specified option.
+        if ( decimals !== false ) {
+            input = toFixed( input, decimals );
+        }
+
+        // Transform the number into a string, so it can be split.
+        input = input.toString();
+
+        // Break the number on the decimal separator.
+        if ( input.indexOf('.') !== -1 ) {
+            inputPieces = input.split('.');
+
+            inputBase = inputPieces[0];
+
+            if ( mark ) {
+                inputDecimals = mark + inputPieces[1];
+            }
+
+        } else {
+
+            // If it isn't split, the entire number will do.
+            inputBase = input;
+        }
+
+        // Group numbers in sets of three.
+        if ( thousand ) {
+            inputBase = strReverse(inputBase).match(/.{1,3}/g);
+            inputBase = strReverse(inputBase.join( strReverse( thousand ) ));
+        }
+
+        // If the number is negative, prefix with negation symbol.
+        if ( inputIsNegative && negativeBefore ) {
+            output += negativeBefore;
+        }
+
+        // Prefix the number
+        if ( prefix ) {
+            output += prefix;
+        }
+
+        // Normal negative option comes after the prefix. Defaults to '-'.
+        if ( inputIsNegative && negative ) {
+            output += negative;
+        }
+
+        // Append the actual number.
+        output += inputBase;
+        output += inputDecimals;
+
+        // Apply the postfix.
+        if ( postfix ) {
+            output += postfix;
+        }
+
+        // Run the output through a user-specified post-formatter.
+        if ( edit ) {
+            output = edit ( output, originalInput );
+        }
+
+        // All done.
+        return output;
+    }
+
+    // Accept a sting as input, output decoded number.
+    function formatFrom ( decimals, thousand, mark, prefix, postfix, encoder, decoder, negativeBefore, negative, edit, undo, input ) {
+
+        var originalInput = input, inputIsNegative, output = '';
+
+        // User defined pre-decoder. Result must be a non empty string.
+        if ( undo ) {
+            input = undo(input);
+        }
+
+        // Test the input. Can't be empty.
+        if ( !input || typeof input !== 'string' ) {
+            return false;
+        }
+
+        // If the string starts with the negativeBefore value: remove it.
+        // Remember is was there, the number is negative.
+        if ( negativeBefore && strStartsWith(input, negativeBefore) ) {
+            input = input.replace(negativeBefore, '');
+            inputIsNegative = true;
+        }
+
+        // Repeat the same procedure for the prefix.
+        if ( prefix && strStartsWith(input, prefix) ) {
+            input = input.replace(prefix, '');
+        }
+
+        // And again for negative.
+        if ( negative && strStartsWith(input, negative) ) {
+            input = input.replace(negative, '');
+            inputIsNegative = true;
+        }
+
+        // Remove the postfix.
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice
+        if ( postfix && strEndsWith(input, postfix) ) {
+            input = input.slice(0, -1 * postfix.length);
+        }
+
+        // Remove the thousand grouping.
+        if ( thousand ) {
+            input = input.split(thousand).join('');
+        }
+
+        // Set the decimal separator back to period.
+        if ( mark ) {
+            input = input.replace(mark, '.');
+        }
+
+        // Prepend the negative symbol.
+        if ( inputIsNegative ) {
+            output += '-';
+        }
+
+        // Add the number
+        output += input;
+
+        // Trim all non-numeric characters (allow '.' and '-');
+        output = output.replace(/[^0-9\.\-.]/g, '');
+
+        // The value contains no parse-able number.
+        if ( output === '' ) {
+            return false;
+        }
+
+        // Covert to number.
+        output = Number(output);
+
+        // Run the user-specified post-decoder.
+        if ( decoder ) {
+            output = decoder(output);
+        }
+
+        // Check is the output is valid, otherwise: return false.
+        if ( !isValidNumber(output) ) {
+            return false;
+        }
+
+        return output;
+    }
+
+
+// Framework
+
+    // Validate formatting options
+    function validate ( inputOptions ) {
+
+        var i, optionName, optionValue,
+            filteredOptions = {};
+
+        for ( i = 0; i < FormatOptions.length; i+=1 ) {
+
+            optionName = FormatOptions[i];
+            optionValue = inputOptions[optionName];
+
+            if ( optionValue === undefined ) {
+
+                // Only default if negativeBefore isn't set.
+                if ( optionName === 'negative' && !filteredOptions['negativeBefore'] ) {
+                    filteredOptions[optionName] = '-';
+                    // Don't set a default for mark when 'thousand' is set.
+                } else if ( optionName === 'mark' && filteredOptions['thousand'] !== '.' ) {
+                    filteredOptions[optionName] = '.';
+                } else {
+                    filteredOptions[optionName] = false;
+                }
+
+                // Floating points in JS are stable up to 7 decimals.
+            } else if ( optionName === 'decimals' ) {
+                if ( optionValue >= 0 && optionValue < 8 ) {
+                    filteredOptions[optionName] = optionValue;
+                } else {
+                    throw new Error(optionName);
+                }
+
+                // These options, when provided, must be functions.
+            } else if ( optionName === 'encoder' || optionName === 'decoder' || optionName === 'edit' || optionName === 'undo' ) {
+                if ( typeof optionValue === 'function' ) {
+                    filteredOptions[optionName] = optionValue;
+                } else {
+                    throw new Error(optionName);
+                }
+
+                // Other options are strings.
+            } else {
+
+                if ( typeof optionValue === 'string' ) {
+                    filteredOptions[optionName] = optionValue;
+                } else {
+                    throw new Error(optionName);
+                }
+            }
+        }
+
+        // Some values can't be extracted from a
+        // string if certain combinations are present.
+        throwEqualError(filteredOptions, 'mark', 'thousand');
+        throwEqualError(filteredOptions, 'prefix', 'negative');
+        throwEqualError(filteredOptions, 'prefix', 'negativeBefore');
+
+        return filteredOptions;
+    }
+
+    // Pass all options as function arguments
+    function passAll ( options, method, input ) {
+        var i, args = [];
+
+        // Add all options in order of FormatOptions
+        for ( i = 0; i < FormatOptions.length; i+=1 ) {
+            args.push(options[FormatOptions[i]]);
+        }
+
+        // Append the input, then call the method, presenting all
+        // options as arguments.
+        args.push(input);
+        return method.apply('', args);
+    }
+
+    /** @constructor */
+    function wNumb ( options ) {
+
+        if ( !(this instanceof wNumb) ) {
+            return new wNumb ( options );
+        }
+
+        if ( typeof options !== "object" ) {
+            return;
+        }
+
+        options = validate(options);
+
+        // Call 'formatTo' with proper arguments.
+        this['to'] = function ( input ) {
+            return passAll(options, formatTo, input);
+        };
+
+        // Call 'formatFrom' with proper arguments.
+        this['from'] = function ( input ) {
+            return passAll(options, formatFrom, input);
+        };
+    }
+
+    /** @export */
+    window['wNumb'] = wNumb;
+
+}());