sugarcss 1.0.0

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

@@ -0,0 +1,40 @@
+@function __string-replace($string, $target, $replacement: '') {
+    $string: __to-string($string);
+    $target: __to-string($target);
+    $found-index: str-index($string, $target);
+    $result: '';
+
+    @if not $found-index {
+        @return $string;
+    }
+
+    @if __function-exists($replacement) {
+        $replacement: __call($replacement, null, $target);
+    }
+
+    @return $result
+        + str-slice($string, 1, $found-index - 1)
+        + $replacement
+        + __string-replace(
+            str-slice($string, str-length($target) + $found-index),
+            $target,
+            $replacement
+        );
+}
+
+
+/// Replaces all instances of a `$target` substring in a `$string` with
+/// a `$replacement` string.
+/// 
+/// @access public
+/// @group String
+/// @param {String} $string - The source string.
+/// @param {String} $target - The substring to replace.
+/// @param {String} $replacement [''] - The replacement string.
+/// @returns {String} Returns new string with replacements.
+/// @example scss
+/// $foo: _replace('abcde', 'bcd', '---');
+/// // => 'a---e'
+@function _replace($args...) {
+    @return call('__string-replace', $args...);
+}

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

@@ -0,0 +1,26 @@
+@function __rest($list, $args...) {
+    @return __drop($list, 1);
+}
+
+
+/// Gets all but the first element of `$list`.
+///
+///
+/// @access public
+/// @group List
+/// @param {List} $list The list to query.
+/// @returns {List} Returns the slice of `$list`.
+/// @example scss
+/// $foo: _rest((1, 2, 3));
+/// // => (2, 3)
+
+@function _rest($args...) {
+    @return call('__rest', $args...);
+}
+
+
+/// @alias _rest
+
+@function _tail($args...) {
+    @return call('__rest', $args...);
+}

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

@@ -0,0 +1,48 @@
+@function __result($map, $key, $default-value: null) {
+    $value: if($map == null, $__undefined__, __get($map, $key));
+    $result: null;
+
+    @if __is-undefined($value) or __is-null($value) {
+        $value: $default-value;
+    }
+
+    @if __function-exists($value) {
+        $_: __scope($map);
+        $scoped-function: __bind($value);
+        $result: __call($scoped-function, $__current-scope__);
+        $_: __scope(false);
+    } @else {
+        $result: $value;
+    }
+
+    @return $result;
+}
+
+
+/// Resolves the value of property `$key` on `$map`. If the value of `key` is
+/// a function it is invoked with the `_this` binding of `$map` and its result
+/// is returned, else the property value is returned. If the property value is
+/// `undefined` or `null` the `$default-value` is used in its place.
+///
+///
+/// @access public
+/// @group Map
+/// @param {Map} $map The $map to query.
+/// @param {string} $key The key of the property to resolve.
+/// @param {*} $default-value The value returned if the property value
+///  resolves to `undefined` or `null`.
+/// @returns {*} Returns the resolved value.
+/// @example scss
+/// $map: ( 'user': 'fred', 'age': _constant(40) );
+/// $foo: _result($map, 'user');
+/// // => 'fred'
+/// $foo: _result($map, 'age');
+/// // => 40
+/// $foo: _result($map, 'status', 'busy');
+/// // => 'busy'
+/// $foo: _result($map, 'status', _constant('busy'));
+/// // => 'busy'
+
+@function _result($args...) {
+    @return call('__result', $args...);
+}

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

@@ -0,0 +1,64 @@
+@function __list-reverse($list, $args...) {
+    $length: length($list);
+    $result-list: ();
+    $index: $length;
+
+    @while $index > 0 {
+        $result-list: append($result-list, nth($list, $index));
+        $index: $index - 1;
+    }
+
+    @return $result-list;
+}
+
+
+@function __str-reverse($string, $args...) {
+    $string-list: __to-list($string);
+    $result: __list-reverse($string-list);
+
+    @return __join($result, '');
+}
+
+
+@function __reverse($value, $args...) {
+    @if __is-string($value) {
+        @return __str-reverse($value);
+    }
+
+    @return __list-reverse($value);
+}
+
+
+/// Reverses a `$list` or `$string`. The first element/character of the list/string
+/// becomes the last, and vice versa.
+/// 
+/// @access public
+/// @group List
+/// @param {List|String} $value - The value to reverse.
+/// @returns {List|String} Returns reversed `$value`.
+/// @example scss
+/// $foo: _reverse(1 2 3);
+/// // => 3 2 1
+/// 
+/// $foo: _reverse('abc');
+/// // => 'cba'
+
+@function _reverse($args...) {
+    @return call('__reverse', $args...);
+}
+
+
+/// Reverses a `$string`. The first character of the string
+/// becomes the last, and vice versa.
+/// 
+/// @access public
+/// @group List
+/// @param {String} $string - The string to reverse.
+/// @returns {String} Returns reversed `$string`.
+/// @example scss
+/// $foo: _str-reverse('abc');
+/// // => 'cba'
+
+@function _str-reverse($args...) {
+    @return call('__str-reverse', $args...);
+}

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

@@ -0,0 +1,55 @@
+
+
+@mixin __rules($rules: ()) {
+    @if not __is-map($rules)
+    or not __every($rules, '__is-map') {
+        @error 'Rules for _rules mixin must be key-value pairs, where value is a declaration map.';
+    } @else {
+        @each $selector, $declarations in $rules {
+            #{$selector} {
+                @include __declare($declarations);
+            }
+        }
+    }
+
+    @content;
+}
+
+
+///
+/// Includes a ruleset for each selector-declarations pair in the map.
+/// 
+/// 
+/// @access public
+/// @group Map
+/// @param {Map} $rules [()] The rules map.
+/// @output The rulesets for each selector key.
+/// @example scss
+/// $test-rules: (
+///     '.foo': (
+///         'height': 50px,
+///         'padding': 1rem 5rem
+///     ),
+///     '.bar .baz': (
+///         'width': 50px,
+///         'margin': 2rem 6rem
+///     )
+/// );
+/// 
+/// @include _rules($test-rules);
+/// 
+/// // Output CSS:
+/// .foo {
+///     height: 50px;
+///     padding: 1rem 5rem;
+/// }
+/// 
+/// .bar .baz {
+///     width: 50px;
+///     margin: 2rem 6rem;
+/// }
+
+@mixin _rules($args...) {
+    @include __rules($args...);
+}
+

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

@@ -0,0 +1,33 @@
+@function __sample($collection, $n: null, $guard: null) {
+    @if (if($guard, __is-iteratee-call($collection, $n, $guard), ($n == null))) {
+        $length: length($collection);
+
+        @return if($length > 0, nth($collection, __base-rand(1, $length)), null);
+    }
+
+    $n: if(type-of($n) == 'number', $n, if(__is-truthy($n), 1, 0));
+    $result: __shuffle($collection);
+    $result: __take($result, min(if($n < 0, 0, $n), length($result)));
+
+    @return $result;
+}
+
+
+/// Gets a random element or `$n` random elements from a collection.
+///
+///
+/// @access public
+/// @group Collection
+/// @param {List|Map|string} $collection The collection to sample.
+/// @param {number} $n [1] The number of elements to sample.
+/// @returns {*} Returns the random sample(s).
+/// @example scss
+/// $foo: _sample((1, 2, 3, 4));
+/// // => 2
+/// 
+/// $foo: _sample((1, 2, 3, 4), 2);
+/// // => (3, 1)
+
+@function _sample($args...) {
+    @return call('__sample', $args...);
+}

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

@@ -0,0 +1,37 @@
+@function __shuffle($collection) {
+    $collection: __to-iterable($collection);
+    $index: 1;
+    $length: length($collection);
+    $result: ();
+
+    @while ($index <= $length) {
+        $rand: __base-rand(1, $index);
+
+        @if ($index != $rand) {
+            $result: __set($result, $index, __get($result, $rand));
+        }
+
+        $result: __set($result, $rand, __get($collection, $index));
+        $index: $index + 1;
+    }
+
+    @return __to-list($result);
+}
+
+
+/// Creates a list of shuffled values, using a version of the Fisher-Yates
+/// shuffle. See [Wikipedia](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle)
+/// for more details.
+///
+///
+/// @access public
+/// @group Collection
+/// @param {List|Map|string} $collection The collection to shuffle.
+/// @returns {List} Returns the new shuffled list.
+/// @example scss
+/// $foo: _shuffle((1, 2, 3, 4));
+/// // => (4, 1, 3, 2)
+
+@function _shuffle($args...) {
+    @return call('__shuffle', $args...);
+}

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

@@ -0,0 +1,37 @@
+@function __get-length($list, $args...) {
+    @return length($list);
+}
+
+
+@function __size($collection: null, $args...) {
+    @if __is-string($collection) {
+        $collection: __to-list($collection);
+    }
+
+    $length: if(__is-map-like($collection), length($collection), 0);
+
+    @return if(__is-length($length), $length, length(__keys($collection)));
+}
+
+
+/// Gets the size of `$collection` by returning `length($collection) for
+/// lists or maps, or `str-length($collection)` for strings.
+///
+///
+/// @access public
+/// @group Collection
+/// @param {List|Map|string} $collection The collection to inspect.
+/// @returns {number} Returns the size of `$collection`.
+/// @example scss
+/// $foo: _size((1, 2, 3));
+/// // => 3
+/// 
+/// $foo: _size(( 'a': 1, 'b': 2 ));
+/// // => 2
+/// 
+/// $foo: _size('pebbles');
+/// // => 7
+
+@function _size($args...) {
+    @return call('__size', $args...);
+}

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

@@ -0,0 +1,60 @@
+@function __base-slice($list, $start: 0, $end: length($list)) {
+    $index: 1;
+    $length: length($list);
+    $start: __parse-int($start);
+    $start: if(__is-number($start), floor($start), if(__is-truthy($start), 1, 0));
+
+    @if ($start < 0) {
+        $start: if(-$start > $length, 0, ($length + $start));
+    }
+
+    $end: if(__is-number($end), floor($end), if(__is-truthy($end), 1, 0));
+    $end: if($end > $length, $length, if($end, $end, 0));
+
+    @if ($end < 0) {
+        $end: $end + $length;
+    }
+
+    $length: if($start > $end, 0, ($end - $start));
+    $result: ();
+
+    @while ($index <= $length) {
+        $result: append($result, nth($list, ($index + $start)));
+        $index: $index + 1;
+    }
+
+    @return $result;
+}
+
+
+@function __slice($list, $start: 0, $end: length($list)) {
+    $length: if(__is-list-like($list), length($list), 0);
+
+    @if __is-falsey($length) {
+        @return ();
+    }
+
+    @if ($end and not __is-number($end) and __is-iteratee-call($list, $start, $end)) {
+        $start: 0;
+        $end: $length;
+    }
+
+    @return __base-slice($list, $start, $end);
+}
+
+
+/// Creates a slice of `$list` from `$start` up to, but not including, `$end`.
+///
+///
+/// @access public
+/// @group List
+/// @param {List} $list - The list to slice.
+/// @param {number} $start [0] - The start position.
+/// @param {number} $end [length($list)] - The end position.
+/// @returns {List} Returns the slice of `$list`.
+/// @example scss
+/// // todo
+
+@function _slice($args...) {
+    @return call('__slice', $args...);
+}

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

@@ -0,0 +1,110 @@
+@function __list-some($list, $predicate) {
+    $index: 1;
+    $length: length($list);
+
+    @while ($index <= $length) {
+        $value: nth($list, $index);
+        $iteration: __exec($predicate, $value, $index, $list);
+
+        @if (__is-truthy($iteration)) {
+            @return true;
+        }
+
+        $index: $index + 1;
+    }
+
+    @return false;
+}
+
+
+@function __base-some-iteratee($value, $index, $collection) {
+    $predicate: __this('predicate');
+    $result: __this('result');
+    $result: __exec($predicate, $value, $index, $collection);
+    $_: __this('result', $result);
+
+    @return if($result, false, true);
+}
+
+
+@function __base-some($collection, $predicate) {
+    $result: false;
+    $_: __scope((
+        'predicate': $predicate,
+        'result': $result
+    ));
+    $_: __base-each($collection, '__base-some-iteratee');
+    $result: __this('result');
+    $_: __scope(false);
+
+    @return if($result, true, false);
+}
+
+
+@function __some($collection, $predicate: '__identity', $this-arg: $__undefined__) {
+    $function: if(__is-list($collection), '__list-some', '__base-some');
+
+    @if (not __function-exists($predicate)) or (not __is-undefined($this-arg)) {
+        $predicate: __get-callback($predicate, $this-arg, 3);
+    }
+
+    @return __exec($function, $collection, $predicate);
+}
+
+
+/// Checks if `$predicate` returns truthy for **any** element of `$collection`.
+/// The function returns as soon as it finds a passing value and does not iterate
+/// over the entire collection. The predicate 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 {Function|Map|string} $predicate [_identity] - The function invoked
+///  per iteration.
+/// @param {*} $this-arg [null] - The `_this` binding of `$predicate`.
+/// @returns {boolean} Returns `true` if any element passes the predicate check,
+///  else `false`.
+/// @example scss
+/// $foo: _some((null, 0, 'yes', false), _is-boolean);
+/// // => true
+/// 
+/// $users: (
+///   ( 'user': 'barney', 'active': true ),
+///   ( 'user': 'fred',   'active': false )
+/// );
+/// // using the `_matches` callback shorthand
+/// 
+/// $foo: _some($users, ( 'user': 'barney', 'active': false ));
+/// // => false
+/// 
+/// // using the `_matches-property` callback shorthand
+/// $foo: _some($users, 'active', false);
+/// // => true
+/// 
+/// // using the `_property` callback shorthand
+/// $foo: _some($users, 'active');
+/// // => true
+
+@function _some($args...) {
+    @return call('__some', $args...);
+}
+
+
+/// @alias _some
+
+@function _any($args...) {
+    @return call('__some', $args...);
+}