sugarcss 1.0.0

data/stylesheets/sugar/vendors/sassdash/api/_sort.scss

@@ -0,0 +1,335 @@
+@function __base-sort-by($list, $comparer) {
+    $length: length($list);
+    $list: __sort($list, $comparer);
+    $list: __to-map($list);
+
+    @while ($length > 0) {
+        $list: __set($list, $length, __get(__get($list, $length), 'value'));
+        $length: $length - 1;
+    }
+
+    @return __to-list($list);
+}
+
+
+@function __base-compare-ascending($value, $other) {
+    @if __is-string($value) or __is-string($other)
+        or __is-color($value) or __is-color($other) {
+        @return __string-compare-ascending($value, $other);
+    }
+
+    $value: if(__is-falsey($value), 0, $value);
+    $other: if(__is-falsey($other), 0, $other);
+
+    @if $value > $other {
+        @return 1;
+    }
+
+    @if $value < $other {
+        @return -1;
+    }
+
+    @return 0;
+}
+
+
+@function __string-compare-ascending($value, $other) {
+    @return __sort-predicate-string($value, $other, 'asc');
+}
+
+
+@function __compare-ascending($map, $other) {
+    @return __either(__base-compare-ascending(__get($map, 'criteria'), __get($other, 'criteria')), (__get($map, 'index') - __get($other, 'index')));
+}
+
+
+@function __compare-multiple-ascending($map, $other) {
+    $index: 1;
+    $map-criteria: __get($map, 'criteria');
+    $other-criteria: __get($other, 'criteria');
+    $length: length($map-criteria);
+
+    @while ($index <= $length) {
+        $result: __base-compare-ascending(nth($map-criteria, $index), nth($other-criteria, $index));
+
+        @if ($result) {
+            @return $result;
+        }
+
+        $index: $index + 1;
+    }
+
+    @return (__get($map, 'index') - __get($other, 'index'));
+}
+
+
+@function __sort-predicate-asc($first, $second) {
+    @if __is-string($first) or __is-string($second)
+        or __is-color($first) or __is-color($second) {
+        @return __sort-predicate-string($first, $second, 'asc');
+    }
+
+    @return if($first > $second, 1, if($first < $second, -1, 0));
+}
+
+
+@function __sort-predicate-desc($first, $second) {
+    @if __is-string($first) or __is-string($second)
+        or __is-color($first) or __is-color($second) {
+        @return __sort-predicate-string($first, $second, 'desc');
+    }
+
+    @return if($first < $second, 1, if($first > $second, -1, 0));
+}
+
+
+@function __sort-predicate-string($first, $second, $direction: 'asc') {
+    $index: 1;
+    $result: 0;
+
+    $first-length: str-length($first);
+    $second-length: str-length($second);
+
+    @while $result == 0
+    and $index <= $first-length
+    and $index <= $second-length {
+        $first-char-code: __char-code-at($first, 1);
+        $second-char-code: __char-code-at($second, 1);
+
+        $result: if($first-char-code > $second-char-code, 1, if($first-char-code < $second-char-code, -1, 0));
+
+        $index: $index + 1;
+    }
+
+    @if $result == 0 and $first-length != $second-length {
+        $result: if($first-length > $second-length, 1, if($first-length < $second-length, -1, 0))
+    }
+
+    @if $direction == 'desc' {
+        $result: $result * -1;
+    }
+
+    @return $result;
+}
+
+
+@function __sort-iteratee($value, $index, $collection, $predicate, $args...) {
+  @return __sort($value, $predicate);
+}
+
+
+@function __sort($list, $predicate: 'asc') {
+    $predicate-map: (
+        'asc': '__sort-predicate-asc',
+        'desc': '__sort-predicate-desc'
+    );
+
+    $comparison-function: __either(__get($predicate-map, $predicate), $predicate);
+    $less:  ();
+    $equal: ();
+    $large: ();
+
+    @if length($list) > 1 {
+
+        $seed: nth($list, ceil(length($list) / 2));
+
+        @each $item in $list {
+            $comparison: __exec($comparison-function, $item, $seed);
+
+            @if $comparison == 0 {
+                $equal: append($equal, $item);
+            } @else if $comparison < 0 {
+                $less: append($less, $item);
+            } @else if $comparison > 0 {
+                $large: append($large, $item);
+            }
+        }
+
+        @return join(join(__sort($less, $predicate), $equal), __sort($large, $predicate));
+    }
+
+    @return $list;
+}
+
+
+@function __sort-by-iteratee($value, $key, $collection) {
+    $result: __this('result');
+    $iteratee: __this('iteratee');
+    $index: __this('index');
+    $result: append($result, (
+        'criteria': __exec($iteratee, $value, $key, $collection),
+        'index': $index,
+        'value': $value
+    ));
+    $_: __this('result', $result);
+    $_: __this('index', $index + 1);
+
+    @return true;
+}
+
+
+@function __sort-by($collection, $iteratee: '__identity', $this-arg: $__undefined__) {
+    $index: 1;
+    $length: if(__is-map-like($collection), length($collection), 0);
+    $result: ();
+
+    @if $length == 0 {
+        @return $result;
+    }
+
+    @if (__is-truthy($this-arg) and __is-iteratee-call($collection, $iteratee, $this-arg)) {
+        $iteratee: null;
+    }
+
+    $iteratee: __get-callback($iteratee, $this-arg, 3);
+    $_: __scope((
+        'result': $result,
+        'iteratee': $iteratee,
+        'index': $index
+    ));
+    $sort-by-iteratee: __bind('__sort-by-iteratee');
+    $_: __base-each($collection, $sort-by-iteratee);
+    $result: __this('result');
+    $_: __scope(false);
+
+    @return __base-sort-by($result, '__compare-ascending');
+}
+
+
+@function __sort-by-all-iteratee($value, $key, $collection) {
+    $props: __this('props');
+    $result: __this('result');
+    $index: __this('index');
+    $length: length($props);
+    $criteria: ();
+
+    @while ($length > 0) {
+        $criteria: __set($criteria, $length, if($value == null, $__undefined__, __get($value, __get($props, $length))));
+        $length: $length - 1;
+    }
+
+    $criteria: __to-list($criteria);
+    $result: append($result, (
+        'criteria': $criteria,
+        'index': $index,
+        'value': $value
+    ));
+    $_: __this('result', $result);
+    $_: __this('index', $index + 1);
+
+    @return true;
+}
+
+
+@function __sort-by-all($arguments...) {
+    $collection: nth($arguments, 1);
+    $args: $arguments;
+
+    @if (length($args) > 3 and __is-iteratee-call(nth($args, 2), nth($args, 3), nth($args, 4))) {
+        $args: ($collection, nth($args, 2));
+    }
+
+    $index: 1;
+    $length: if($collection, length($collection), 0);
+    $props: __base-flatten($args, false, false, 1);
+    $result: ();
+
+    $_: __scope((
+        'props': $props,
+        'result': $result,
+        'index': $index
+    ));
+    $iteratee: __bind('__sort-by-all-iteratee');
+    $_: __base-each($collection, $iteratee);
+    $result: __this('result');
+    $_: __scope(false);
+
+    @return __base-sort-by($result, '__compare-multiple-ascending');
+}
+
+
+/// Sorts elements of a list by `$predicate` 
+/// and returns a new list with the sorted elements.
+/// 
+/// @access public
+/// @group List
+/// @param {List} $list The list to sort.
+/// @param {Function|String} $predicate ['asc'] The predicate used for comparison.
+/// @returns {List} Returns sorted list.
+/// @example scss
+/// $foo: _sort(3 1 4 2 6 5 8 7 9);
+/// // => 1 2 3 4 5 6 7 8 9
+/// 
+/// $foo: _sort(3 1 4 2 6 5 8 7 9, 'desc');
+/// // => 9 8 7 6 5 4 3 2 1
+
+@function _sort($args...) {
+    @return call('__sort', $args...);
+}
+
+
+/// Creates a list of elements, sorted in ascending order by the results of
+/// running each element in a collection through `$iteratee`. This method performs
+/// a stable sort, that is, it preserves the original sort order of equal elements.
+/// 
+/// The `$iteratee` is bound to `$this-arg` and invoked with three arguments;
+/// (value, index|key, collection).
+/// 
+/// If a property name is provided for `$predicate` the created `_property`
+/// style callback returns the property value of the given element.
+/// 
+/// If a value is also provided for `$this-arg` the created `_matches-property`
+/// style callback returns `true` for elements that have a matching property
+/// value, else `false`.
+/// 
+/// If a map is provided for `$predicate` the created `_matches` style
+/// callback returns `true` for elements that have the properties of the given
+/// object, else `false`.
+///
+///
+/// @access public
+/// @group Collection
+/// @param {List|Map|string} $collection The collection to iterate over.
+/// @param {List|Function|Map|string} $iteratee [_identity] - The function
+///  invoked per iteration. If a property name or a map is provided it is
+///  used to create a `_property` or `_matches` style callback respectively.
+/// @param {*} $this-arg [null] - The `_this` binding of `$iteratee`.
+/// @returns {List} Returns the new sorted list.
+/// @example scss
+/// $users: (
+///   ( 'user': 'fred' ),
+///   ( 'user': 'pebbles' ),
+///   ( 'user': 'barney' )
+/// );
+/// // using the `_property` callback shorthand
+/// $foo: _pluck(_sort-by($users, 'user'), 'user');
+/// // => ('barney', 'fred', 'pebbles')
+
+@function _sort-by($args...) {
+    @return call('__sort-by', $args...);
+}
+
+
+/// This method is like `_sort-by` except that it sorts by property names
+/// instead of an iteratee function.
+///
+///
+/// @access public
+/// @group Collection
+/// @param {List|Map|string} $collection The collection to iterate over.
+/// @param {String...|List(String)} $props The property names to sort by,
+///  specified as individual property names or lists of property names.
+/// @returns {List} Returns the new sorted list.
+/// @example scss
+/// $users: (
+///   ( 'user': 'barney', 'age': 36 ),
+///   ( 'user': 'fred',   'age': 40 ),
+///   ( 'user': 'barney', 'age': 26 ),
+///   ( 'user': 'fred',   'age': 30 )
+/// );
+/// $foo: _map(_sort-by-all($users, ('user', 'age')), _values);
+/// // => (('barney', 26), ('barney', 36), ('fred', 30), ('fred', 40))
+
+@function _sort-by-all($args...) {
+    @return call('__sort-by-all', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_sorted-index.scss

@@ -0,0 +1,135 @@
+@function __sorted-index($list, $value, $iteratee: '__identity', $this-arg: null) {
+    $function: __get-callback($iteratee);
+
+    @return if($function == __base-callback and $iteratee == null,
+        __binary-index($list, $value),
+        __binary-index-by($list, $value, __exec($function, $iteratee, $this-arg, 1)));
+}
+
+
+@function __sorted-last-index($list, $value, $iteratee: '__identity', $this-arg: null) {
+    $function: __get-callback($iteratee);
+
+    @return if($function == __base-callback and $iteratee == null,
+        __binary-index($list, $value),
+        __binary-index-by($list, $value, __exec($function, $iteratee, $this-arg, 1), true));
+}
+
+
+@function __binary-index($list, $value, $ret-highest: false, $args...) {
+    $low: 0;
+    $high: if($list, length($list), $low);
+
+    @if __is-number($value) {
+        @while ($low < $high) {
+            $mid: floor(($low + $high) / 2);
+            $computed: nth($list, $mid);
+
+            @if (if($ret-highest, ($computed <= $value), ($computed < $value))) {
+                $low: $mid + 1;
+            } @else {
+                $high: $mid;
+            }
+        }
+
+        @return $high;
+    }
+
+    @return __binary-index-by($list, $value, '__identity', $ret-highest);
+}
+
+
+@function __binary-index-by($list, $value, $iteratee, $ret-highest: false) {
+    $value: __exec($iteratee, $value);
+
+    $low: 0;
+    $high: if($list, length($list), 0);
+    $val-is-undefined: ($value == null);
+
+    @while ($low < $high) {
+        $mid: floor(($low + $high) / 2);
+        $computed: __exec($iteratee, nth($list, $mid));
+
+        @if ($val-is-undefined) {
+            $set-low: ($ret-highest > 0 or not ($computed == null));
+        } @else {
+            $set-low: if($ret-highest > 0, ($computed <= $value), ($computed < $value));
+        }
+
+        @if ($set-low) {
+            $low: $mid + 1;
+        } @else {
+            $high: $mid;
+        }
+    }
+
+    @return min($high, __const('MAX_LIST_INDEX'));
+}
+
+
+/// Uses a binary search to determine the lowest index at which `$value` should
+/// be inserted into `$list` in order to maintain its sort order. If an iteratee
+/// function is provided it is invoked for `$value` and each element of `$list`
+/// to compute their sort ranking. The iteratee is bound to `$this-arg` and
+/// invoked with one argument; (value).
+/// 
+/// If a property name is provided for `$predicate` the created `_property`
+/// style callback returns the property value of the given element.
+/// 
+/// If a value is also provided for `$this-arg` the created `_matches-property`
+/// style callback returns `true` for elements that have a matching property
+/// value, else `false`.
+/// 
+/// If a map is provided for `$predicate` the created `_matches` style
+/// callback returns `true` for elements that have the properties of the given
+/// object, else `false`.
+///
+///
+/// @access public
+/// @group List
+/// @param {List} $list The sorted list to inspect.
+/// @param {*} $value The value to evaluate.
+/// @param {Function|Map|string} $iteratee [_identity] - The function invoked
+///  per iteration.
+/// @param {*} $this-arg [NULL] - The `_this` binding of `$iteratee`.
+/// @returns {number} Returns the index at which `$value` should be inserted
+///  into `$list`.
+/// @example scss
+/// $foo: _sorted-index((30, 50), 40);
+/// // => 2
+/// 
+/// $foo: _sorted-index((4, 4, 5, 5), 5);
+/// // => 3
+/// 
+/// $dict: { 'data': { 'thirty': 30, 'forty': 40, 'fifty': 50 } };
+///
+/// // using the `_property` callback shorthand
+/// $foo: _sorted-index((( 'x': 30 ), ( 'x': 50 )), ( 'x': 40 ), 'x');
+/// // => 2
+
+@function _sorted-index($args...) {
+    @return call('__sorted-index', $args...);
+}
+
+
+/// This method is like `_sorted-index` except that it returns the highest
+/// index at which `$value` should be inserted into `$list` in order to
+/// maintain its sort order.
+///
+///
+/// @access public
+/// @group List
+/// @param {List} $list The sorted list to inspect.
+/// @param {*} $value The value to evaluate.
+/// @param {Function|Map|string} $iteratee [_identity] - The function invoked
+///  per iteration.
+/// @param {*} $this-arg [null] - The `_this` binding of `$iteratee`.
+/// @returns {number} Returns the index at which `$value` should be inserted
+///  into `$list`.
+/// @example scss
+/// $foo: _sorted-last-index((4, 4, 5, 5), 5);
+/// // => 5
+
+@function _sorted-last-index($args...) {
+    @return call('__sorted-last-index', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_splice.scss

@@ -0,0 +1,45 @@
+@function __splice($list, $start, $delete-count: 1, $items...) {
+    $length: length($list);
+    $result: ();
+    $index: 1;
+
+    // @return false;
+
+    @while $index < $start {
+        $result: append($result, nth($list, $index));
+        $index: $index + 1;
+    }
+
+    @each $item in $items {
+        $result: append($result, $item);
+    }
+
+    $index: $start + $delete-count;
+
+    @while $index <= $length {
+        $result: append($result, nth($list, $index));
+        $index: $index + 1;
+    }
+
+    @return $result;
+}
+
+
+/// Removes items from a `$list` and adds new items in their place.
+/// Similar to the native JavaScript [splice() function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice).
+/// 
+/// @access public
+/// @group List
+/// @param {List} $list - List to splice.
+/// @param {Number} $start - Index to start changing the list.
+/// @param {Number} $delete-count [1] - Number of list items to remove.
+/// @param {Any...} $items... - Items to add to the lsit.
+/// @example scss
+/// $margin: 10px 3px 5px 20px;
+/// 
+/// $margin: _splice($margin, 2, 2, 15px);
+/// // => 10px 15px 20px
+
+@function _splice($args...) {
+    @return call('__splice', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_split.scss

@@ -0,0 +1,43 @@
+@function __string-split($string, $delimiter: '', $guard: null, $args...) {
+    @if $guard and __is-iteratee-call($string, $delimiter, $guard) {
+        $delimiter: '';
+    }
+
+    $string: __to-string($string);
+
+    @if not $delimiter
+    or str-length($delimiter) == 0
+    or $delimiter == '' {
+        @return __to-list($string);
+    }
+
+    $delimiter-index: str-index($string, $delimiter);
+
+    @if not $delimiter-index {
+        @return append((), $string);
+    }
+
+    @return join(
+        str-slice($string, 1, $delimiter-index - 1),
+        __string-split(
+            str-slice($string, $delimiter-index + str-length($delimiter)),
+            $delimiter
+        )
+    );
+}
+
+
+/// Splits a string from indexes of `$delimiter` to a list.
+/// 
+/// @access public
+/// @group String
+/// @param {String} $string - String to split.
+/// @param {String} $delimiter [null] - Characters to use for separating the `$string`.
+/// @returns {List} Returns list of substrings from split `$string`.
+/// @example scss
+/// $foo: _split('a--b--c--d--e', '--');
+/// // => 'a' 'b' 'c' 'd' 'e'
+
+@function _split($args...) {
+    @return call('__string-split', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_starts-with.scss

@@ -0,0 +1,78 @@
+@function __starts-with($string, $target, $position: 1) {
+    @if __is-list-like($target) {
+        $result: false;
+
+        @each $target-string in $target {
+            $result: __either($result, __starts-with($string, $target-string, $position));
+        }
+
+        @return $result;
+    }
+
+    $string: __base-to-string($string);
+    $target: __base-to-string($target);
+    $position: if(__is-falsey($position), 0, $position);
+    $position: min(if($position <= 0, 1, $position), str-length($string));
+
+    @return if($target == '',
+        true,
+        __string-last-index-of($string, $target, $position) == $position);
+}
+
+@function __starts-with-any($string, $targets: (), $position: 1) {
+    $result: false;
+    $index: 1;
+
+    @while $index <= length($targets) and not $result {
+        $target-string: nth($targets, $index);
+        $result: __starts-with($string, $target-string, $position);
+
+        $index: $index + 1;
+    }
+
+    @return $result;
+}
+
+/// Checks if `$string` starts with the given target string.
+///
+///
+/// @access public
+/// @group String
+/// @param {string} $string [''] - The string to search.
+/// @param {string} $target - The string to search for.
+/// @param {number} $position [1] - The position to search from.
+/// @returns {boolean} Returns `true` if `$string` starts with `$target`, else `false`.
+/// @example scss
+/// $foo: _starts-with('abc', 'a');
+/// // => true
+/// 
+/// $foo: _starts-with('abc', 'b');
+/// // => false
+/// 
+/// $foo: _starts-with('abc', 'b', 1);
+/// // => true
+
+@function _starts-with($args...) {
+    @return call('__starts-with', $args...);
+}
+
+/// Checks if `$string` starts with any of the strings in `$targets` list.
+///
+///
+/// @access public
+/// @group String
+/// @param {string} $string [''] - The string to search.
+/// @param {string} $targets [()] - The list of strings to search for.
+/// @param {number} $position [1] - The position to search from.
+/// @returns {boolean} Returns `true` if `$string` starts with any of the strings in `$targets`, else `false`.
+/// @example scss
+/// $foo: _starts-with-any('abc', 'a' 'b');
+/// // => true
+/// $foo: _starts-with-any('abc', 'b' 'c');
+/// // => false
+/// $foo: _starts-with-any('abc', 'b' 'c', 1);
+/// // => true
+
+@function _starts-with-any($args...) {
+    @return call('__starts-with-any', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_sum.scss

@@ -0,0 +1,44 @@
+
+@function __sum($collection, $iteratee: '__identity', $this-arg: null, $args...) {
+    @if $this-arg and __is-iteratee-call($collection, $iteratee, $this-arg) {
+        $iteratee: '__identity';
+        $this-arg: null;
+    }
+
+    $collection: __to-list($collection);
+
+    $iteratee: __get-callback($iteratee, $this-arg, 3);
+    $length: length($collection);
+    $result: 0;
+
+    @while $length > 0 {
+        $value: __parse-float(__exec($iteratee, nth($collection, $length)));
+
+        $value: __either($value, 0);
+
+        $result: $result + $value;
+
+        $length: $length - 1;
+    }
+
+    @return $result;
+}
+
+
+///
+/// Gets the sum of the values in `$collection`.
+///
+/// @access public
+/// @group Math
+/// @param {Array|Object|string} $collection The collection to iterate over.
+/// @returns {number} Returns the sum.
+/// @example scss
+/// $foo: _sum(4 6 2);
+/// // => 12
+/// 
+/// $foo: _sum(('a': 4, 'b': 6, 'c': 2));
+/// // => 12
+
+@function _sum($args...) {
+    @return call('__sum', $args...);
+}