susy 1.0.9 → 2.2.14

data/sass/susy/language/susy/_padding.scss

@@ -0,0 +1,74 @@
+// Padding Syntax
+// ==============
+
+// Prefix
+// ------
+// Add spanning-padding before an element.
+// - $span  : <span>
+@mixin prefix(
+  $span
+) {
+  $inspect  : $span;
+  $span     : map-merge((spread: wide), parse-span($span));
+  $flow     : susy-get(flow, $span);
+  $width    : span($span);
+
+  @if is-inside($span) {
+    $gutter: gutter($span);
+    $width: if($gutter and comparable($width, $gutter), $width + $gutter, $width);
+  }
+
+  @include susy-inspect(prefix, $inspect);
+  @include padding-output($width, null, $flow);
+}
+
+// Suffix
+// ------
+// Add spanning-padding after an element.
+// - $span  : <span>
+@mixin suffix(
+  $span
+) {
+  $inspect  : $span;
+  $span     : map-merge((spread: wide), parse-span($span));
+  $flow     : susy-get(flow, $span);
+  $width    : span($span);
+
+  @if is-inside($span) {
+    $gutter: gutter($span);
+    $width: if($gutter and comparable($width, $gutter), $width + $gutter, $width);
+  }
+
+  @include susy-inspect(suffix, $inspect);
+  @include padding-output(null, $width, $flow);
+}
+
+// Pad
+// ---
+// Add spanning-padding before and after an element.
+// - $pre     : <span>
+// - [$post]  : <span>
+@mixin pad(
+  $pre,
+  $post: false
+) {
+  $inspect  : ($pre, $post);
+  $pre      : map-merge((spread: wide), parse-span($pre));
+
+  @if $post {
+    $post: map-merge((spread: wide), parse-span($post));
+  } @else {
+    $span: susy-get(span, $pre);
+    @if length($span) > 1 {
+      $pre: map-merge($pre, (span: nth($span, 1)));
+      $post: map-merge($pre, (span: nth($span, 2)));
+    } @else {
+      $post: $pre;
+    }
+  }
+
+  @include susy-inspect(pad, $inspect);
+  @include prefix($pre);
+  @include suffix($post);
+
+}

data/sass/susy/language/susy/_rows.scss

@@ -0,0 +1,138 @@
+// Row Start & End
+// ===============
+
+// Break
+// -----
+// Apply to any element that should force a line break.
+@mixin break {
+  @include output((clear: both));
+}
+
+
+// NoBreak
+// -------
+// Cancel the break() effect, e.g. when using media queries.
+@mixin nobreak {
+  @include output((clear: none));
+}
+
+
+// Full
+// ----
+// - [$context]: <layout shorthand>
+@mixin full(
+  $context: $susy
+) {
+  $inspect : $context;
+  @include susy-inspect(full, $inspect);
+  @include span(full of parse-grid($context) break);
+}
+
+
+// First
+// -----
+// - [$context]: <settings>
+@mixin first(
+  $context: $susy
+) {
+  $inspect  : $context;
+  $context  : parse-grid($context);
+  $flow     : susy-get(flow, $context);
+
+  @include susy-inspect(first, $inspect);
+  @if not(is-split($context)) {
+    @include float-first($flow);
+  }
+}
+
+@mixin alpha(
+  $context: $susy
+) {
+  @include first($context);
+}
+
+
+// Last
+// ----
+// - [$context]: <settings>
+@mixin last(
+  $context: $susy
+) {
+  $inspect  : $context;
+  $context  : parse-grid($context);
+
+  @include susy-inspect(last, $inspect);
+
+  $output: (
+    flow: susy-get(flow, $context),
+    last-flow: susy-get(last-flow, $context),
+    margin: if(is-split($context), null, 0),
+  );
+
+  @include float-last($output...);
+}
+
+@mixin omega(
+  $context: $susy
+) {
+  @include last($context);
+}
+
+
+// Get Edge
+// --------
+// Calculate edge value based on location, if possible
+@function get-edge(
+  $span
+) {
+  $span       : parse-span($span);
+  $edge       : susy-get(edge, $span);
+
+  @if not($edge) {
+    $count: susy-count(susy-get(columns, $span));
+    $location: susy-get(location, $span);
+    $n: susy-get(span, $span);
+
+    $number: if(type-of($location) == number, true, false);
+    $index: if($number and unitless($location), true, false);
+
+    @if $n == $count {
+      $edge: full;
+    } @else if $location and $n and $index {
+      @if $location == 1 {
+        $edge: if($n == $count, full, first);
+      } @else if $location + $n - 1 == $count {
+        $edge: last;
+      }
+    }
+  }
+
+  @if $edge == alpha or $edge == omega {
+    $edge: if($edge == alpha, first, last);
+  }
+
+  @return $edge;
+}
+
+
+// Get Location
+// ------------
+// Calculate location value based on edge, if possible
+@function get-location(
+  $span
+) {
+  $span       : parse-span($span);
+  $location   : susy-get(location, $span);
+  $edge       : get-edge($span);
+  $n          : susy-get(span, $span);
+
+  @if $edge and not($location) and type-of($n) == number and unitless($n) {
+    @if $edge == first {
+      $location: 1;
+    } @else if $edge == last {
+      $location: susy-count(susy-get(columns, $span)) - $n + 1;
+    }
+  }
+
+  @return $location
+}

data/sass/susy/language/susy/_settings.scss

@@ -0,0 +1,216 @@
+// Susy Settings
+// =============
+
+// Susy Language Defaults
+// ----------------------
+// - PRIVATE
+@include susy-defaults((
+  container: auto,
+  math: fluid,
+  output: float,
+  container-position: center,
+  gutter-position: after,
+  global-box-sizing: content-box,
+  debug: (
+    image: hide,
+    color: rgba(#66f, .25),
+    output: background,
+    toggle: top right,
+  ),
+));
+
+
+// Valid Keyword Values
+// --------------------
+// - PRIVATE: DONT'T TOUCH
+$susy-keywords: (
+  container: auto,
+  math: static fluid,
+  output: isolate float,
+  container-position: left center right,
+  flow: ltr rtl,
+  gutter-position: before after split inside inside-static,
+  box-sizing: border-box content-box,
+  span: full,
+  edge: first alpha last omega full,
+  spread: narrow wide wider,
+  gutter-override: no-gutters no-gutter,
+  role: nest,
+  clear: break nobreak,
+  debug image: show hide show-columns show-baseline,
+  debug output: background overlay,
+);
+
+
+// Parse Susy Keywords and Maps
+// ----------------------------
+@function parse-settings(
+  $short: $susy
+) {
+  $_return: ();
+
+  @if type-of($short) == map {
+    $_return: $short;
+  } @else {
+    @each $item in $short {
+      // strings
+      @if type-of($item) == string {
+        @each $key, $value in $susy-keywords {
+          @if index($value, $item) {
+            $_key-value: append($key, $item);
+            $_return: _susy-deep-set($_return, $_key-value...);
+          }
+        }
+      // maps
+      } @else if type-of($item) == map {
+        $_return: map-merge($_return, $item);
+      }
+    }
+  }
+
+  @return $_return;
+}
+
+
+// Parse Columns & Gutters
+// -----------------------
+@function parse-layout(
+  $short
+) {
+  $_return: ();
+  $_columns: ();
+  $_gutters: null;
+
+  @if not(unitless(nth(nth($short, 1), 1))) {
+    $_gutters: nth($short, 1);
+  } @else {
+    $_columns: (columns: nth($short, 1));
+    $_gutters: if(length($short) > 1, nth($short, 2), $_gutters);
+  }
+
+  @if type-of($_gutters) == list and length($_gutters) > 0 {
+    $_gutters: (
+      gutters: nth($_gutters, 2) / nth($_gutters, 1),
+      column-width: nth($_gutters, 1),
+    );
+  } @else {
+    $_gutters: if($_gutters, (gutters: $_gutters), ());
+  }
+
+  $_return: map-merge($_return, $_columns);
+  $_return: map-merge($_return, $_gutters);
+
+  @return $_return;
+}
+
+
+// Parse Grid/Context
+// ------------------
+@function parse-grid(
+  $short: $susy
+) {
+  $_return: parse-settings($short);
+  $_layout: ();
+
+  @if type-of($short) == map {
+    $_return: $short;
+  } @else {
+    @each $item in $short {
+      // number or list
+      @if type-of($item) == number or type-of($item) == list {
+        @if type-of($item) == list or unitless($item) {
+          $_layout: append($_layout, $item);
+        } @else {
+          $_return: map-merge($_return, (container: $item));
+        }
+      }
+    }
+
+    $_layout: if(length($_layout) > 0, parse-layout($_layout), $_layout);
+  }
+
+  @return map-merge($_return, $_layout);
+}
+
+
+// Parse Span
+// ----------
+@function parse-span(
+  $short,
+  $key: span
+) {
+  $_return: ();
+
+  @if type-of($short) == map {
+    $_return: $short;
+  } @else {
+    $_at: index($short, at);
+
+    @if $_at {
+      $_loci: $_at + 1;
+      $_location: nth($short, $_loci);
+      $_return: map-merge($_return, (location: $_location));
+      $short: set-nth($short, $_at, null);
+      $short: set-nth($short, $_loci, null);
+    }
+
+    $_i: 1;
+    $_span: ();
+
+    @while $_i <= length($short) {
+      $_this: nth($short, $_i);
+
+      @if type-of($_this) == number {
+        $_span: append($_span, $_this);
+        $short: set-nth($short, $_i, null);
+      } @else if $_this == of {
+        $short: set-nth($short, $_i, null);
+        $_i: length($short) + 1;
+      }
+
+      $_i: $_i + 1;
+    }
+
+    @if length($_span) > 0 {
+      $_span: if(length($_span) == 1, nth($_span, 1), $_span);
+      $_return: map-merge($_return, ($key: $_span));
+    }
+
+    $_return: map-merge($_return, parse-grid($short));
+  }
+
+  @return $_return;
+}
+
+
+// Parse Gutters
+// -------------
+@function parse-gutters(
+  $short: $susy
+) {
+  $_gutters: parse-span($short, gutter-override);
+  $_span: susy-get(gutter-override, $_gutters);
+
+  @if $_span and not(map-get($_gutters, columns)) {
+    $_context: ();
+    $_new: ();
+
+    @each $item in $_span {
+      @if type-of($item) == number and unitless($item) {
+        $_context: append($_context, $item);
+      } @else {
+        $_new: append($_new, $item);
+      }
+    }
+
+    $_context: parse-grid($_context);
+    $_new: if(length($_new) == 0, null, $_new);
+    $_new: if(length($_new) == 1, nth($_new, 1), $_new);
+    $_new: (gutter-override: if($_new != $_span, $_new, $_span));
+
+    $_gutters: map-merge($_gutters, $_new);
+    $_gutters: map-merge($_gutters, $_context);
+  }
+
+  @return $_gutters;
+}

data/sass/susy/language/susy/_span.scss

@@ -0,0 +1,163 @@
+// Span Syntax
+// ===========
+
+// Span [mixin]
+// ------------
+// Set a spanning element using shorthand syntax.
+// - $span  : <span>
+@mixin span(
+  $span
+) {
+  $inspect: $span;
+  $span: parse-span($span);
+  $output: span-math($span);
+  $nesting: susy-get(span, $span);
+  $clear: susy-get(clear, $span);
+
+  $box: susy-get(box-sizing, $span);
+  $content-box: if(susy-get(global-box-sizing) != 'border-box', true, false);
+  $box: $box or if(is-inside($span) and $content-box, border-box, null);
+
+  @if $clear == break {
+    @include break;
+  } @else if $clear == nobreak {
+    @include nobreak;
+  }
+
+  @include susy-inspect(span, $inspect);
+  @include output((box-sizing: $box));
+  @include float-span-output($output...);
+
+  @if valid-columns($nesting, silent) {
+    @include nested($span) { @content; }
+  } @else {
+    @content;
+  }
+}
+
+// Span [function]
+// ---------------
+// Return the width of a span.
+// - $span  : <span>
+@function span(
+  $span
+) {
+  @return get-span-width($span);
+}
+
+// Span Math
+// ---------
+// Get all the span results.
+// - $span: <map>
+@function span-math(
+  $span
+) {
+  $nest             : if(susy-get(role, $span) == nest, true, false);
+  $split-nest       : if(is-split($span) and $nest, true, false);
+  $edge             : get-edge($span);
+  $location         : get-location($span);
+
+  $float            : from;
+  $padding-before   : null;
+  $padding-after    : null;
+  $margin-before    : null;
+  $margin-after     : null;
+
+  // calculate widths
+  $spread: index(map-values($span), spread);
+  $span: if($split-nest and not($spread), map-merge($span, (spread: wide)), $span);
+  $width: get-span-width($span);
+  $gutters: get-gutters($span);
+
+  // apply gutters
+  @if is-inside($span) {
+    @if not(susy-get(role, $span)) {
+      $padding-before: map-get($gutters, before);
+      $padding-after: map-get($gutters, after);
+    }
+  } @else {
+    @if not($split-nest) {
+      $margin-before: map-get($gutters, before);
+      $margin-after: map-get($gutters, after);
+    }
+  }
+
+  // special margin handling
+  @if susy-get(output, $span) == isolate and $location {
+    $margin-before: get-isolation($span);
+    $margin-after: -100%;
+  } @else if $edge {
+    $is-split: is-split($span);
+    $pos: susy-get(gutter-position, $span);
+
+    @if $edge == last {
+      $float: susy-get(last-flow, $span);
+    }
+
+    @if not($is-split) {
+      @if $edge == full or ($edge == first and $pos == before) {
+        $margin-before: 0;
+      }
+      @if $edge == full or ($edge == last and $pos == after) {
+        $margin-after: 0;
+      }
+    }
+
+  }
+
+  @return (
+    width           : $width,
+    float           : $float,
+    margin-before   : $margin-before,
+    margin-after    : $margin-after,
+    padding-before  : $padding-before,
+    padding-after   : $padding-after,
+    flow            : susy-get(flow, $span),
+  );
+}
+
+// Get Span Width
+// --------------
+// Return span width.
+// - $span: <map>
+@function get-span-width(
+  $span
+) {
+  $span     : parse-span($span);
+
+  $n        : susy-get(span, $span);
+  $location : get-location($span);
+  $columns  : susy-get(columns, $span);
+  $gutters  : susy-get(gutters, $span);
+  $spread   : susy-get(spread, $span);
+
+  $context  : null;
+  $span-sum : null;
+  $width    : null;
+
+  @if $n == 'full' {
+    $pos: susy-get(gutter-position, $span);
+    $role: susy-get(role, $span);
+    $n: if($pos == split and $role != nest, susy-count($columns), 100%);
+  }
+
+  @if type-of($n) != number {
+    @warn "(#{type-of($n)}) #{$n} is not a valid span.";
+  } @else if unitless($n) {
+    $context: susy-sum($columns, $gutters, if(is-split($span), wide, narrow));
+    $spread: if(is-inside($span), $spread or wide, $spread);
+    $span-sum: susy($n, $location, $columns, $gutters, $spread);
+
+    $_math: susy-get(math, $span);
+    $_column-width: susy-get(column-width, $span);
+    @if $_math == static {
+      $width: $span-sum * valid-column-math($_math, $_column-width);
+    } @else {
+      $width: percentage($span-sum / $context);
+    }
+  } @else {
+    $width: $n;
+  }
+
+  @return $width;
+}