oo-loop 1.0.3 → 1.1.0

package/scss/mixins/_props.scss

@@ -1,21 +1,24 @@
+@use 'sass:map';
+@use 'sass:string';
+@use '../fn';
 
 /// Generate Properties
 /// @param $propertiesMap 
 
 @mixin generateProperties($propertiesMap) {
-  @if isMap($propertiesMap) {
+  @if fn.isMap($propertiesMap) {
     @each $propertyName, $propertyValue in $propertiesMap {
-      $propertyName: toKebabCase($propertyName);
+      $propertyName: fn.toKebabCase($propertyName);
 
-      @if isString($propertyName) and str-slice($propertyName,1,1) == ':' {
+      @if fn.isString($propertyName) and string.slice($propertyName,1,1) == ':' {
         &#{$propertyName} {
           @include generateProperties($propertyValue);
         }
-      } @else if isMap($propertyValue) and areKeysBreakpoints($propertyValue) {
+      } @else if fn.isMap($propertyValue) and areKeysBreakpoints($propertyValue) {
         @include generatePropertyBreakpoints($propertyName, $propertyValue);
-      } @else if isMap($propertyValue) and $propertyName == '>' {
+      } @else if fn.isMap($propertyValue) and $propertyName == '>' {
         @each $childSelector, $childProps in $propertyValue {
-          $childSelector: toKebabCase($childSelector);
+          $childSelector: fn.toKebabCase($childSelector);
           #{$childSelector} {
             @include generateProperties($childProps);
           }
@@ -35,11 +38,11 @@
   }
 }
 @mixin breakpointProperty($propertiesMap) {
-  @if isNotMap($propertiesMap) {
+  @if fn.isNotMap($propertiesMap) {
     @error 'Pass a property Map with `breakpointProperty()`';
   }
   @each $propertyName, $propertyValue in $propertiesMap {
-    $propertyName: toKebabCase($propertyName);
+    $propertyName: fn.toKebabCase($propertyName);
     @if not areKeysBreakpoints($propertyValue) {
       @error 'Use a breakpoint map as a property value with `breakpointProperty()`';
     }
@@ -48,7 +51,7 @@
 }
 
 @mixin generateStatesProperties($statesPropertiesMap) {
-  @if isMap($statesPropertiesMap) {
+  @if fn.isMap($statesPropertiesMap) {
     @each $state, $props in $statesPropertiesMap {
       &:#{$state} {
         @include generateProperties($props);
@@ -58,12 +61,12 @@
 }
 
 @mixin generateStyles($element) {
-  @if isMap($element) {
-    @if map-has-key($element, 'props') {
-      @include generateProperties(map-get($element, 'props')); 
+  @if fn.isMap($element) {
+    @if map.has-key($element, 'props') {
+      @include generateProperties(map.get($element, 'props')); 
     }
-    @if map-has-key($element, 'states') {
-      @include generateStatesProperties(map-get($element, 'states')); 
+    @if map.has-key($element, 'states') {
+      @include generateStatesProperties(map.get($element, 'states')); 
     }
   }
 }

package/scss/mixins/_utilities.scss

@@ -1,23 +1,26 @@
-@import 'loop';
+@use 'sass:list';
+@use 'sass:map';
+@use 'sass:string';
+@use '../fn';
 
 /// Generate Utilities
 /// @param $utilitiesMap 
 
  @mixin generateUtilities($utilitiesMap) {
-  @if map-has-key($utilitiesMap, 'values')
-    and map-has-key($utilitiesMap, 'name') {
-    $utilitiesMap: (map-get($utilitiesMap, 'name'): $utilitiesMap);
+  @if map.has-key($utilitiesMap, 'values')
+    and map.has-key($utilitiesMap, 'name') {
+    $utilitiesMap: (map.get($utilitiesMap, 'name'): $utilitiesMap);
   }
 
   @each $name, $options in $utilitiesMap {
-    @if isMap($options) {
-      $props: if(map-has-key($options, 'values'), oo('values', $options), ());
-      $propertyName: if(map-has-key($options, 'property'), oo('property', $options), toKebabCase($name));
-      $prefix: if(map-has-key($options, 'prefix'), oo('prefix', $options), nth(split('-', toKebabCase($name)), 1));
-      $isImportant: if(map-has-key($options, 'important'), oo('important', $options), true);
-      $screens: if(map-has-key($options, 'screens'), oo('screens', $options), ());
+    @if fn.isMap($options) {
+      $props: if(map.has-key($options, 'values'), oo('values', $options), ());
+      $propertyName: if(map.has-key($options, 'property'), oo('property', $options), fn.toKebabCase($name));
+      $prefix: if(map.has-key($options, 'prefix'), oo('prefix', $options), list.nth(fn.splitDeep('-', fn.toKebabCase($name)), 1));
+      $isImportant: if(map.has-key($options, 'important'), oo('important', $options), true);
+      $screens: if(map.has-key($options, 'screens'), oo('screens', $options), ());
       
-      @if not (str-slice(prefix, 1, 1) == '.') {
+      @if not (string.slice(prefix, 1, 1) == '.') {
         $prefix: '.' + $prefix;
       }
 
@@ -28,7 +31,7 @@
         $isImportant
       );
 
-      @if isMap($screens) {
+      @if fn.isMap($screens) {
         @each $class, $propsName in $screens {
           @if $propsName == '*' {
             @include loopBreakpoints(
@@ -38,19 +41,19 @@
               $prefix,
               $isImportant
             )
-          } @else if isNotEmpty($propsName) {
-            $propsName: toList($propsName);
+          } @else if fn.isNotEmpty($propsName) {
+            $propsName: fn.toList($propsName);
             $propsTarget: ();
             @each $name in $propsName {
               $prop-value: '';
-              @if isList($props) {
-                $index: index($props, $name);
-                $prop-value: nth($props, $index);
+              @if fn.isList($props) {
+                $index: list.index($props, $name);
+                $prop-value: list.nth($props, $index);
               } @else {
                 $prop-value: oo(#{$name}, $props);
               }
               @if $prop-value {
-                $propsTarget: map-merge($propsTarget, (#{$name}: $prop-value));
+                $propsTarget: map.merge($propsTarget, (#{$name}: $prop-value));
               }
             }
             @include loopBreakpoints(

package/scss/oo/_all.scss

@@ -0,0 +1,11 @@
+@import
+  'oo',
+  'ooRef',
+  'ooMerge',
+  'ooSet',
+  'ooAdd',
+  'ooPipe',
+  'ooUse',
+  'ooAlias',
+  'ooParse'
+;

package/scss/oo/_oo.scss

@@ -0,0 +1,42 @@
+@use 'sass:list';
+@use 'sass:string';
+@use '../fn';
+
+/// oo
+/// Get value from a map with the ooFormat (default $ooLoop)
+/// @param string  $key  ooFormat key
+/// @param map|null $map the map to update (default $ooLoop)
+/// @return mixed
+
+@function oo($key, $map:null) {
+  $map: if($map == null, $ooLoop, $map);
+
+  // double check if quotes exist (issue with some sass version and PostCSS Parser)
+  @if string.slice($key, 1, 1) == '"' and string.slice($key, string.length($key), - 1) == '"' {
+    $key: string.slice($key, 2, string.length($key) - 1);
+  }
+
+  @if string.index($key, '.') == null {
+    @return fn.getMapValue($map, $key);
+  }
+
+  $list: fn.splitDeep('.', $key);
+
+  @for $i from 1 through list.length($list) {
+    $value: fn.getMapValue($map, list.nth($list, $i));
+    @if $i == list.length($list) and fn.isEmpty($value) {
+      $value: fn.getMapValue($map, fn.toKebabCase(list.nth($list, $i)));
+    }
+    $map: $value;
+  }
+ 
+  @return $map;
+}
+
+/// ooPrefix
+/// get loop prefix
+/// @return string
+
+@function ooPrefix() {
+  @return if(oo(dataAttr) == true, 'data-oo', 'oo');
+}

package/scss/{functions → oo}/_ooAdd.scss

@@ -1,3 +1,6 @@
+@use 'sass:list';
+@use '../fn';
+
 /// ooAdd
 /// Push new map value to an another set of map with the ooFormat (default $ooLoop)
 /// @param string $key ooFormat key
@@ -8,7 +11,7 @@
 @function ooAdd($key, $mapValue, $map:null) {
   $currentValue: oo($key, $map);
 
-  @if isEmpty($currentValue) {
+  @if fn.isEmpty($currentValue) {
     $newValue: ooSetSoft($key, $mapValue, $map);
     @return $newValue;
   }
@@ -17,15 +20,15 @@
     $currentValue: getRefValue($currentValue, $map);
   }
 
-  @if isString($currentValue) {
-    $currentValue: toList($currentValue);
+  @if fn.isString($currentValue) {
+    $currentValue: fn.toList($currentValue);
   }
 
-  @if isList($currentValue) {
-    $newValue: ooSetSoft($key, append($currentValue, $mapValue), $map);
+  @if fn.isList($currentValue) {
+    $newValue: ooSetSoft($key, list.append($currentValue, $mapValue), $map);
     @return $newValue;
   }
     
-  $newValue: ooSetSoft($key, mapMergeDeep($currentValue, $mapValue, $map), $map);
+  $newValue: ooSetSoft($key, ooMergeDeep($currentValue, $mapValue, $map), $map);
   @return $newValue;
 }

package/scss/oo/_ooAlias.scss

@@ -0,0 +1,146 @@
+@use 'sass:color';
+@use 'sass:list';
+@use 'sass:map';
+@use 'sass:meta';
+@use "sass:string";
+@use "../fn";
+
+$ooAlias: (
+  (
+    name: 'ooDarken',
+    function: 'adjust-color',
+    keywordsArg: ('lightness': -1),
+    paramType: ('color', 'number'),
+  ),
+  (
+    name: 'ooLighten',
+    function: 'adjust-color',
+    keywordsArg: ('lightness': 1),
+    paramType: ('color', 'number'),
+  ),
+);
+
+
+// Aliases function used before init
+
+@function ooDarken($value, $percentage) {
+  @if fn.isNotColor($value) {
+    @return $value;
+  }
+  @return color.adjust($value, $lightness: -$percentage);
+}
+@function ooLighten($value, $percentage) {
+  @if fn.isNotColor($value) {
+    @return $value;
+  }
+  @return color.adjust($value, $lightness: $percentage);
+}
+
+/// isAlias
+/// check if a string is a sass alias function
+/// @param string $string the string to check
+/// @return bool
+
+@function isAlias($string) {
+  @if fn.isNotString($string) {
+    @return false;
+  }
+
+  $isAlias: false;
+  @each $alias in $ooAlias {
+    $aliasName: fn.getMapValue($alias, 'name');
+    $aliasLength: string.length($aliasName);
+    @if string.slice(#{$string}, 1, $aliasLength + 1) == '#{$aliasName}(' and string.slice(#{$string}, string.length(#{$string})) == ')' {
+      $isAlias: true;
+    }
+  }
+  @return $isAlias;
+}
+
+/// getAliasInfo
+/// retrieve the alias information
+/// @param string $aliasFunction The complete alias function
+/// @return map|null
+
+@function getAliasInfo($aliasFunction) {
+  @each $alias in $ooAlias {
+    $aliasName: fn.getMapValue($alias, 'name');
+    $aliasLength: string.length($aliasName);
+    $aliasFunctionName: fn.stripSpaces(string.slice($aliasFunction, 1, $aliasLength));
+
+    @if $aliasFunctionName == $aliasName {
+      $currentAlias: $alias;
+      $functionName: fn.getMapValue($alias, 'function');
+
+      @return (
+        name: $aliasName,
+        nameLength: $aliasLength,
+        function: if(meta.function-exists('get-function'), meta.get-function($functionName), $functionName),
+        functionName: $functionName,
+        keywordsArg: fn.getMapValue($alias, 'keywordsArg'),
+        paramType: fn.getMapValue($alias, 'paramType'),
+      );
+    }
+  }
+
+  @return null;
+}
+
+/// getAliasValue
+/// retrieve the value of an alias function
+/// @param string $aliasFunction The complete alias function
+/// @param string $value Value of the 1st parameter
+/// @return bool
+
+@function getAliasValue($aliasFunction, $value:null) {
+  $name: null;
+  $paramType: null;
+  $keywordsArg: null;
+  $function: null;
+  $params: fn.splitDeep(',', meta.inspect($aliasFunction));
+  $param1: list.nth($params, 1);
+
+  $aliasInfo: getAliasInfo($aliasFunction);
+
+  @if $aliasInfo != null {
+    $name: fn.getMapValue($aliasInfo, 'name');
+    $function: fn.getMapValue($aliasInfo, 'function');
+    $keywordsArg: fn.getMapValue($aliasInfo, 'keywordsArg');
+    $paramType: fn.getMapValue($aliasInfo, 'paramType');
+    $param1: fn.stripSpaces(string.slice($param1, fn.getMapValue($aliasInfo, 'nameLength') + 2, string.length($param1)));
+  }
+
+  $param1: if($value==null, $param1, $value);
+
+  @if list.length($params) > 1 {
+    $param2: fn.stripSpaces(string.slice(#{list.nth($params, 2)}, 1, -2));
+
+    $param1Type: null;
+    $param2Type: null;
+
+    @if $paramType != null {
+      $param1Type: list.nth($paramType, 1);
+      $param2Type: list.nth($paramType, 2);
+    }
+
+    $param1: fn.toType($param1Type, $param1);
+    $param2: fn.toType($param2Type, $param2);
+ 
+    @if meta.type-of($param1) != $param1Type or meta.type-of($param2) != $param2Type {
+      @warn('The alias `#{$aliasFunction}` is targetting `#{$value}` and therefore cannot be used with the sass function `#{getMapValue($aliasInfo, 'functionName')}`');
+      @return $value;
+    }
+
+    @if fn.isMap($keywordsArg) {
+      $argKey: list.nth(map.keys($keywordsArg), 1);
+      $param2: map.get($keywordsArg, $argKey) * $param2;
+      @if ($argKey == 'lightness') {
+        @return meta.call($function, $param1, $lightness: $param2);
+      }
+    }
+
+    @return meta.call($function, $param1, $param2);
+  }
+
+  @return meta.call($function, $param1);
+}

package/scss/oo/_ooMerge.scss

@@ -0,0 +1,41 @@
+@use 'sass:map';
+@use 'sass:meta';
+@use '../fn';
+
+/// ooMergeDeep
+/// Non destructive map merge in the ooLoop. 
+/// @credit-to  https://gist.github.com/pentzzsolt
+/// @param map $parentMap Map of data to be merged into
+/// @param map $childMap The set of data
+/// @param map $refMap The base map to refer too, usually equivalent to the $ooLoop before going into nested merge
+/// @param bool $forceKebab force the use of kebab-case property
+/// @return map
+
+@function ooMergeDeep($parentMap, $childMap, $refMap: null, $forceKebab: false) {
+  $map: $parentMap;
+
+  @if not fn.isMap($map) {
+    @return $map;
+  }
+
+  $refMap: if($refMap ==null, $ooLoop, $refMap);
+
+  @each $key, $value in $childMap {
+    $key: if($forceKebab, fn.toKebabCase($key), $key);
+
+    @if isRef(map.get($map, $key)) {
+      $mapValue: getRefValue(map.get($map, $key), $refMap);
+      $map: map.merge($map, ($key: $mapValue));
+    }
+
+    @if (not map.has-key($map, $key)) or (meta.type-of(map.get($map, $key)) != meta.type-of($value)) or (not (fn.isMap(map.get($map, $key)) and fn.isMap($value))) {
+      $map: map.merge($map, ($key: $value));
+    }
+
+    @else {
+      $map: map.merge($map, ($key: ooMergeDeep(map.get($map, $key), $value, $refMap, fn.inList($key, ('props', 'states')))));
+    }
+  }
+
+  @return $map;
+}

package/scss/{functions → oo}/_ooParse.scss

@@ -1,3 +1,7 @@
+@use 'sass:list';
+@use 'sass:string';
+@use '../fn';
+
 /// ooParse
 /// Parse a map of data making sure all references is being replaced
 /// @param map $map
@@ -24,13 +28,13 @@
   $parentMap: if($backup == null, $map, $backup);
   
   @each $key, $value in $map {
-    @if isMap($value) {
+    @if fn.isMap($value) {
       // set path to remember where we came from in a nested environment
-      $path: if(isEmpty($path), '#{$key}', '#{$path}.#{$key}');
+      $path: if(fn.isEmpty($path), '#{$key}', '#{$path}.#{$key}');
       $newValue: parser($value, $parentMap, $path);
-      $map: setMapValue($map, $key, $newValue);
+      $map: fn.setMapValue($map, $key, $newValue);
       // clear latest child in path to go backup in the nested environment 
-      $path: if(length(split('.', $path)) > 1, replace('.#{$key}', '', $path), replace('#{$key}', '', $path));
+      $path: if(list.length(fn.splitDeep('.', $path)) > 1, fn.replace('.#{$key}', '', $path), fn.replace('#{$key}', '', $path));
     } @else if hasRef($value) {
       $ooRef: extractRef($value);
       $newValue: getRefValue($ooRef, $parentMap);
@@ -39,28 +43,28 @@
         $newValue: getSpreadMap($value, $parentMap);
       }
       
-      @if isList($value) and isNotMap($newValue) {
-        $refIndex: index($value, $ooRef);
+      @if fn.isList($value) and fn.isNotMap($newValue) {
+        $refIndex: list.index($value, $ooRef);
         $newListValue: ();
-        @for $i from 1 through length($value) {
-          @if (isAlias(nth($value, $i))) {
+        @for $i from 1 through list.length($value) {
+          @if (isAlias(list.nth($value, $i))) {
             @if hasRef($newValue) {
-              $newListValue: append($newListValue, replace($ooRef, $newValue, nth($value, $i)));
+              $newListValue: list.append($newListValue, fn.replace($ooRef, $newValue, list.nth($value, $i)));
             } @else {
-              $newListValue: append($newListValue, getAliasValue(nth($value, $i), $newValue));
+              $newListValue: list.append($newListValue, getAliasValue(list.nth($value, $i), $newValue));
             }
           } @else if ($i == $refIndex) {
-            $newListValue: append($newListValue, $newValue)
+            $newListValue: list.append($newListValue, $newValue)
           } @else {
-            $newListValue: append($newListValue, nth($value, $i))
+            $newListValue: list.append($newListValue, list.nth($value, $i))
           }
         }
         $newValue: $newListValue;
       }
 
-      @if isAlias($value) and isNotList($value) {
+      @if isAlias($value) and fn.isNotList($value) {
         @if hasRef($newValue) {
-          $newValue: replace($ooRef, $newValue, $value);
+          $newValue: string.replace($ooRef, $newValue, $value);
         } @else {
           $newValue: getAliasValue($value, $newValue);
         }
@@ -69,8 +73,8 @@
       $map: ooSetSoft($key, $newValue, $map);
 
       //update backup
-      @if isEmpty($path) {
-        $parentMap: mapMergeDeep($parentMap, $map);
+      @if fn.isEmpty($path) {
+        $parentMap: ooMergeDeep($parentMap, $map);
       } @else {
         $parentMap: ooSetSoft($path, $map, $parentMap);
       }

package/scss/{functions → oo}/_ooPipe.scss

@@ -1,3 +1,5 @@
+@use '../fn';
+
 /// ooPipe
 /// Pipe list of ooSet Rules
 /// @param list $rules List of rules
@@ -6,10 +8,10 @@
 @function ooPipe($rules...) {
   $map: $ooLoop;
   @each $rule in $rules {
-    @if getMapValue($rule, 'action') == 'add' {
-      $map: ooAdd(getMapValue($rule, 'path'), getMapValue($rule, 'value'), $map);
+    @if fn.getMapValue($rule, 'action') == 'add' {
+      $map: ooAdd(fn.getMapValue($rule, 'path'), fn.getMapValue($rule, 'value'), $map);
     } @else {
-      $map: ooSetHard(getMapValue($rule, 'path'), getMapValue($rule, 'value'), $map);
+      $map: ooSetHard(fn.getMapValue($rule, 'path'), fn.getMapValue($rule, 'value'), $map);
     }
   }
   @return $map;

package/scss/{functions → oo}/_ooRef.scss

@@ -1,13 +1,19 @@
+@use "sass:list";
+@use "sass:map";
+@use "sass:meta";
+@use 'sass:string';
+@use '../fn';
+
 /// hasRef
 /// Check if a map has a ooFormat
 /// @param mixed
 /// @return bool
 
 @function hasRef($search) {
-  @if isNotString($search) {
-    $search: inspect($search);
+  @if fn.isNotString($search) {
+    $search: meta.inspect($search);
   }
-  @return if(str-index($search, 'this(') == null, false, true);
+  @return if(string.index($search, 'this(') == null, false, true);
 }
 
 
@@ -17,10 +23,10 @@
 /// @return bool
 
 @function isRef($string) {
-  @if isNotString($string) {
-    $string: inspect($string);
+  @if fn.isNotString($string) {
+    $string: meta.inspect($string);
   }
-  @return str-slice($string, 1, 5) == 'this(' and str-slice($string, str-length($string)) == ')';
+  @return string.slice($string, 1, 5) == 'this(' and string.slice($string, string.length($string)) == ')';
 }
 
 /// hasSpreadOperator
@@ -29,10 +35,10 @@
 /// @return bool
 
 @function hasSpreadOperator($ref) {
-  @if isNotString($ref) {
-    $ref: inspect($ref);
+  @if fn.isNotString($ref) {
+    $ref: meta.inspect($ref);
   }
-  @return if(str-index($ref, '_this(') == null, false, true);
+  @return if(string.index($ref, '_this(') == null, false, true);
 }
 
 /// getRefPath
@@ -41,10 +47,10 @@
 /// @return String
 
 @function getRefPath($string) {
-  @if isNotString($string) {
-    $string: inspect($string);
+  @if fn.isNotString($string) {
+    $string: meta.inspect($string);
   }
-  @return str-slice($string, 6, -2);
+  @return string.slice($string, 6, -2);
 }
 
 /// getRefValue
@@ -68,27 +74,27 @@
 /// @return map
 
 @function getSpreadMap($list, $map) {
-  @if isNotList($list) {
+  @if fn.isNotList($list) {
     @error 'spread operator must be used within a list';
   }
   $newMapValue: ();
-  @for $i from 1 through length($list) {
-    @if hasSpreadOperator(nth($list, $i)) {
-      $ref: extractRef(nth($list, $i));
+  @for $i from 1 through list.length($list) {
+    @if hasSpreadOperator(list.nth($list, $i)) {
+      $ref: extractRef(list.nth($list, $i));
       $refValue: getRefValue($ref, $map);
       @if hasSpreadOperator($refValue) {
         $refValue: getSpreadMap($refValue, $map);
       }
-      @if isNotMap($refValue) {
+      @if fn.isNotMap($refValue) {
         //the use of replace is for some sass version
-        $refPathList: split('.', replace('"', '', getRefPath($ref)));
-        $refValue: (nth($refPathList, length($refPathList)): $refValue);
+        $refPathList: fn.splitDeep('.', fn.replace('"', '', getRefPath($ref)));
+        $refValue: (list.nth($refPathList, list.length($refPathList)): $refValue);
       }
-      $newMapValue: map-merge($newMapValue, $refValue);
-    } @else if isNotMap(nth($list, $i)) {
+      $newMapValue: map.merge($newMapValue, $refValue);
+    } @else if fn.isNotMap(list.nth($list, $i)) {
       @error 'spread operator only works along map';
     } @else {
-      $newMapValue: map-merge($newMapValue, nth($list, $i));
+      $newMapValue: map.merge($newMapValue, list.nth($list, $i));
     }
   }
   @return $newMapValue;
@@ -100,12 +106,12 @@
 /// @return string
 
 @function extractRef($string) {
-  @if isNotString($string) {
-    $string: inspect($string)
+  @if fn.isNotString($string) {
+    $string: meta.inspect($string)
   }
   @if not hasRef($string) {
     @return $string;
   }
-  $extractString: extract('this(', ')', $string);
+  $extractString: fn.extract('this(', ')', $string);
   @return $extractString;
 }