@jorilindell/hds-core 4.10.1

package/lib/utils/multi-sass/_helpers.scss

@@ -0,0 +1,144 @@
+/* stylelint-disable scss/function-no-unknown */
+@use "sass:meta";
+@use "sass:map";
+@use "sass:list";
+@use "sass:string";
+
+/*
+* Generic helper functions
+*/
+
+// Clone of array.pop()
+@function pop-list($target) {
+  $len: list.length($target);
+  $copy: [];
+
+  @if $len > 1 {
+    @for $i from 1 through $len - 1 {
+      $copy: list.append($copy, list.nth($target, $i));
+    }
+  }
+
+  @return $copy;
+}
+
+// Returns the key of the first item in map that has a non-null value
+@function get-map-key-with-value($target) {
+  @if not $target {
+    @return null;
+  } @else {
+    @each $name, $value in $target {
+      /* stylelint-disable-next-line scss/at-if-no-null */
+      @if meta.type-of($value) != 'null' {
+        @return $name;
+      }
+    }
+  }
+
+  @return null;
+}
+
+// Returns the (key,value) map of the first item in map that has a non-null value
+@function get-map-data-with-value($target) {
+  $keyWithValue: get-map-key-with-value($target);
+
+  @if not $keyWithValue {
+    @return null;
+  }
+
+  $value: map.get($target, $keyWithValue);
+
+  @return ('key': $keyWithValue, 'value': $value);
+}
+
+@function is-value-boolean($value) {
+  @return meta.type-of($value) == 'bool';
+}
+
+@function is-value-string($value) {
+  @return meta.type-of($value) == 'string';
+}
+
+@function is-value-null($value) {
+  @return meta.type-of($value) == 'null';
+}
+
+@function is-value-map($value) {
+  @return meta.type-of($value) == 'map';
+}
+
+@function is-value-list($value) {
+  @return meta.type-of($value) == 'list';
+}
+
+@function is-value-false($value) {
+  @return is-value-boolean($value) and $value == false;
+}
+
+@function is-value-true($value) {
+  @return is-value-boolean($value) and $value == true;
+}
+
+/// this is intentionally named like this so it is not confused with is-value-false
+@function can-value-be-falsy($value) {
+  @return not $value or $value == '' or $value == 0;
+}
+
+/// this is intentionally named like this so it is not confused with is-value-true
+@function can-value-be-truthy($value) {
+  @return can-value-be-falsy($value) != true;
+}
+
+/// helper to create an empty map.
+/// Calling just $empty:() do not create a map with type-of "map", it is a list.
+@function create-empty-map() {
+  @return map.merge((), ());
+}
+
+/// converts a argument list to a map
+@function arg-list-to-map($args...) {
+  @return meta.keywords($args);
+}
+
+// returns argument named ARGS_MAP or all arguments as map
+// the "ARGS_MAP" is used in cases where a params passed to a function are be picked with "$args..."
+// or may already be picked earlier as a map and are passed as a map in an parameter named as  "ARGS_MAP"
+@function get-arg-map-or-arg-list-as-map($ARGS_MAP: null, $args...) {
+  @return $ARGS_MAP or meta.keywords($args);
+}
+
+@function get-last-list-item($list) {
+  $len: if($list, list.length($list), 0);
+
+  @return if($len > 0, list.nth($list, -1), null);
+}
+
+@function replace-list-item($list, $replacee, $index) {
+  @return list.set-nth($list, $index, $replacee);
+}
+
+@function replace-string($string, $search, $replace: '') {
+  @if can-value-be-falsy($search) or can-value-be-falsy($replace) {
+    @return $string;
+  }
+
+  $index: string.index($string, $search);
+
+  /* stylelint-disable-next-line scss/at-if-no-null */
+  @if $index != null {
+    /* stylelint-disable-next-line scss/operator-no-newline-after */
+    @return string.slice($string, 1, $index - 1) + $replace +
+      replace-string(string.slice($string, $index + string.length($search)), $search, $replace);
+  }
+
+  @return $string;
+}
+
+// returns value of given key from a map, if map is found in arguments.
+@function get-map-value-if-map($assumedMap, $name) {
+  @if not $assumedMap or not is-value-map($assumedMap) {
+    @return null;
+  }
+
+  @return map.get($assumedMap, $name);
+}

package/lib/utils/multi-sass/_levels.scss

@@ -0,0 +1,377 @@
+/* stylelint-disable scss/dollar-variable-pattern */
+/* stylelint-disable scss/function-no-unknown */
+@use "sass:map";
+@use "sass:meta";
+@use './globals.scss' as globals;
+@use './helpers.scss' as helpers;
+@use './rules.scss' as rules;
+@use './selectors.scss' as selectors;
+
+/*
+* Functions to create and update levels and handle their nesting.
+*/
+
+$EMIT_TARGET_NESTED: 'EMIT_TARGET_NESTED';
+$EMIT_TARGET_ROOT: 'EMIT_TARGET_ROOT';
+
+@function init-levels() {
+  $levels: [];
+
+  @return $levels;
+}
+
+@function create-level-data($parent, $args...) {
+  $parentDepth: if($parent, map.get($parent, 'depth'), -1);
+  $parentIsContentOnly: if($parent, map.get($parent, 'contentOnly'), false);
+  $depth: if($parentIsContentOnly, $parentDepth, $parentDepth + 1);
+  $levelProps: helpers.get-map-data-with-value(helpers.get-arg-map-or-arg-list-as-map($args...));
+
+  @if not $levelProps {
+    @return ('depth': -1, 'type': null, 'name': null, 'parent': null);
+  }
+
+  $type: map.get($levelProps, 'key');
+  $name: map.get($levelProps, 'value');
+
+  @return ('parent': $parent, 'type': $type, 'depth': $depth, 'name': $name);
+}
+
+@function append-level-rules($ruleMap, $config, $level) {
+  $parent: map.get($level, 'parent');
+  $parentAllowed: if($parent, map.get($parent, 'isAllowed'), true);
+  $isAllowed: $parentAllowed and is-level-allowed-in-rules($ruleMap, $level);
+  $contentOnly: $isAllowed and is-level-content-only($level);
+  $selector: null;
+  $isRoot: is-root-level($level);
+  $emitToRootInConfig: (
+    ($isRoot and globals.emit-content-only-in-root($config)) or globals.emit-content-only-in-all($config)
+  );
+
+  // only block and custom should nest their selectors in root.
+  // or is block levels needed here
+  @if $emitToRootInConfig {
+    $level: set-level-emit-target-to-root($level);
+    $contentOnly: true;
+  } @else if $isRoot and (is-block-level($level) or is-custom-level($level)) {
+    $level: set-level-emit-target-to-nested($level);
+  }
+
+  $level: map.set($level, 'isAllowed', $isAllowed);
+  $level: map.set($level, 'contentOnly', $contentOnly);
+
+  @if $isAllowed and not $contentOnly {
+    $selector: create-level-selector($config, $level);
+  } @else if $isAllowed and is-extra-level($level) and $parent {
+    $selector: get-level-selector($parent);
+  }
+
+  $level: map.set($level, 'selector', $selector);
+
+  @return $level;
+}
+
+@function create-level($ruleMap, $config, $args...) {
+  $level: create-level-data($args...);
+
+  @return append-level-rules($ruleMap, $config, $level);
+}
+
+@function get-current-level($levels) {
+  @return helpers.get-last-list-item($levels);
+}
+
+@function get-level-parent-selector($config, $level) {
+  $parent: get-level-parent($level);
+
+  @if $parent {
+    @return get-level-selector($parent);
+  }
+
+  @return globals.get-root-selector($config);
+}
+
+@function create-level-selector($config, $level) {
+  $shouldEmitAtRoot: should-level-emit-at-root($level);
+  $type: get-level-type($level);
+  $name: get-level-name($level);
+
+  @if helpers.can-value-be-falsy($name) and is-block-type($type) {
+    $name: globals.get-block-name($config);
+  }
+
+  $alias: get-level-alias($level, $config);
+
+  @if $alias {
+    @return selectors.create-selector-with-alias($type, $alias);
+  }
+
+  @return selectors.create-selector($type, $name, $config);
+}
+
+@function get-closest-with-name-or-type($level, $type, $name: null, $startFromLevel: false) {
+  $nameRequired: helpers.can-value-be-truthy($name) and $name != true;
+  $parent: if($startFromLevel, $level, get-level-parent($level));
+
+  @while $parent {
+    @if get-level-type($parent) == $type {
+      @if $nameRequired {
+        @if get-level-name() == $name {
+          @return $parent;
+        }
+      } @else {
+        @return $parent;
+      }
+    }
+
+    $parent: get-level-parent($parent);
+  }
+
+  @return null;
+}
+
+@function get-closest-entity($level, $startFromLevel: true) {
+  $parent: if($startFromLevel, $level, get-level-parent($level));
+
+  @while $parent {
+    $parentType: get-level-type($parent);
+
+    @if is-block-type($parentType) or is-modifier-type($parentType) or is-element-type($parentType) {
+      @return $parent;
+    }
+
+    $parent: get-level-parent($parent);
+  }
+
+  @return null;
+}
+
+@function is-level-allowed-in-rules($ruleMap, $level) {
+  $type: get-level-type($level);
+  $name: get-level-name($level);
+
+  @if is-block-type($type) {
+    @return true;
+  } @else if is-modifier-type($type) {
+    @return rules.is-modifier-allowed($ruleMap, $name);
+  } @else if is-element-type($type) {
+    // get parent modifier
+    $closestModifier: get-closest-with-name-or-type($level, 'modifier');
+
+    @if $closestModifier {
+      @return rules.is-element-allowed-in-modifier($ruleMap, get-level-name($closestModifier), $name);
+    } @else {
+      @return rules.is-element-allowed($ruleMap, $name);
+    }
+
+    @return false;
+  } @else if is-content-type($type) {
+    $closestEntity: get-closest-entity($level);
+
+    @if not $closestEntity {
+      @return true;
+    }
+
+    $closestType: get-level-type($closestEntity);
+
+    @if is-block-type($closestType) {
+      @if not $name or globals.is-base-name($name) {
+        @return rules.is-base-content-allowed($ruleMap);
+      }
+
+      @return rules.is-element-allowed($ruleMap, $name);
+    } @else if not $name {
+      @return true;
+    } @else if is-modifier-type($closestType) {
+      @return rules.is-element-allowed-in-modifier($ruleMap, get-level-name($closestEntity), $name);
+    } @else if is-element-type($closestType) {
+      @return rules.is-element-allowed($ruleMap, get-level-name($closestEntity)) and
+        rules.is-element-allowed($ruleMap, $name);
+    }
+  } @else if is-extra-type($type) {
+    @return rules.is-extra-allowed($ruleMap, $name);
+  } @else if is-custom-type($type) {
+    @if $name {
+      @return rules.is-extra-allowed($ruleMap, $name);
+    }
+
+    @return true;
+  }
+
+  @return false;
+}
+
+@function find-closest-in-current($args...) {
+  $entityProps: helpers.get-map-data-with-value(helpers.get-arg-map-or-arg-list-as-map($args...));
+
+  @if not $entityProps {
+    @return null;
+  }
+
+  $type: map.get($entityProps, 'key');
+  $name: map.get($entityProps, 'value');
+
+  @if $type {
+    $levels: globals.get-multi-sass-levels();
+    $currentLevel: get-current-level($levels);
+    $targetLevel: get-closest-with-name-or-type($currentLevel, $type, $name, $startFromLevel: true);
+
+    @return if($targetLevel, $targetLevel, null);
+  }
+
+  @return null;
+}
+
+@function is-level-content-only($level) {
+  @return is-content-level($level) or is-extra-level($level);
+}
+
+@function get-level-content-only($level) {
+  @return map.get($level, 'contentOnly');
+}
+
+@function get-level-type($level) {
+  @return map.get($level, 'type');
+}
+
+@function get-level-alias($level, $config: null) {
+  $ruleMap: globals.get-multi-sass-rules();
+  $type: get-level-type($level);
+  $name: get-level-name($level);
+
+  @return globals.get-alias-value($name, $config);
+}
+
+@function get-level-name($level) {
+  @return map.get($level, 'name');
+}
+
+@function set-level-name($level, $name) {
+  @return map.set($level, 'name', $name);
+}
+
+@function get-level-parent($level) {
+  @return map.get($level, 'parent');
+}
+
+@function set-level-parent($level, $parent) {
+  @return map.set($level, 'parent', $parent);
+}
+
+@function get-level-depth($level) {
+  @return map.get($level, 'depth');
+}
+
+@function set-level-depth($level, $depth) {
+  @return map.set($level, 'depth', $depth);
+}
+
+@function get-level-selector($level) {
+  @return map.get($level, 'selector');
+}
+
+@function set-level-selector($level, $selector) {
+  @if is-custom-level($level) {
+    $void: set-level-name($level, $selector);
+  }
+
+  @return map.set($level, 'selector', $selector);
+}
+
+@function collect-parent-entity-selectors($level) {
+  $selector: get-level-selector($level);
+  $parent: get-level-parent($level);
+
+  @while $parent {
+    $levelSelector: get-level-selector($parent);
+
+    @if not is-level-content-only($parent) and helpers.can-value-be-truthy($levelSelector) {
+      $selector: '#{$levelSelector}#{$selector}';
+    }
+
+    $parent: get-level-parent($parent);
+  }
+
+  @return $selector;
+}
+
+@function get-level-emit-target($level) {
+  @return map.get($level, 'emitTarget');
+}
+
+@function set-level-emit-target($level, $emitTarget) {
+  @return map.set($level, 'emitTarget', $emitTarget);
+}
+
+@function set-level-emit-target-to-root($level) {
+  @return set-level-emit-target($level, $EMIT_TARGET_ROOT);
+}
+
+@function set-level-emit-target-to-nested($level) {
+  @return set-level-emit-target($level, $EMIT_TARGET_NESTED);
+}
+
+@function should-level-emit-at-root($level) {
+  $target: get-level-emit-target($level);
+
+  @return $target == $EMIT_TARGET_ROOT;
+}
+
+@function should-level-emit-nested($level) {
+  @return get-level-emit-target($level) == $EMIT_TARGET_NESTED;
+}
+
+@function is-level-allowed($level) {
+  @return map.get($level, 'isAllowed') == true;
+}
+
+@function is-root-level($level) {
+  @return helpers.can-value-be-falsy(get-level-parent($level));
+}
+
+@function is-block-type($type) {
+  @return $type == 'block';
+}
+
+@function is-modifier-type($type) {
+  @return $type == 'modifier';
+}
+
+@function is-element-type($type) {
+  @return $type == 'element';
+}
+
+@function is-content-type($type) {
+  @return $type == 'content';
+}
+
+@function is-extra-type($type) {
+  @return $type == 'extra';
+}
+
+@function is-custom-type($type) {
+  @return $type == 'custom';
+}
+
+@function is-block-level($level) {
+  @return is-block-type(get-level-type($level));
+}
+
+@function is-modifier-level($level) {
+  @return is-modifier-type(get-level-type($level));
+}
+
+@function is-element-level($level) {
+  @return is-element-type(get-level-type($level));
+}
+
+@function is-content-level($level) {
+  @return is-content-type(get-level-type($level));
+}
+
+@function is-extra-level($level) {
+  @return is-extra-type(get-level-type($level));
+}
+
+@function is-custom-level($level) {
+  @return is-custom-type(get-level-type($level));
+}

package/lib/utils/multi-sass/_output.scss

@@ -0,0 +1,29 @@
+@use './levels.scss' as levels;
+
+/*
+* Output functions.
+*/
+
+@mixin emit($level) {
+  // remove first check?
+  $contentOnly: levels.is-level-content-only($level) or levels.get-level-content-only($level);
+  $isAllowed: levels.is-level-allowed($level);
+  $selector: levels.get-level-selector($level);
+  $shouldEmitNested: levels.should-level-emit-nested($level);
+
+  @if $isAllowed {
+    @if $contentOnly {
+      @content;
+    } @else {
+      @if $shouldEmitNested {
+        #{$selector} {
+          @content;
+        }
+      } @else {
+        &#{$selector} {
+          @content;
+        }
+      }
+    }
+  }
+}

package/lib/utils/multi-sass/_process.scss

@@ -0,0 +1,46 @@
+/* stylelint-disable scss/function-no-unknown */
+@use "sass:meta";
+@use './globals.scss' as globals;
+@use './levels.scss' as levels;
+@use './rules.scss' as rules;
+@use './helpers.scss' as helpers;
+
+/*
+* Starts, and ends, processing a level.
+*/
+
+@function start($args...) {
+  $newLevel: create-process-level($args...);
+  $void: globals.add-multi-sass-level($newLevel);
+
+  @return $newLevel;
+}
+
+@function end() {
+  @return globals.remove-current-multi-sass-level();
+}
+
+@function create-process-level($args...) {
+  $rules: globals.get-multi-sass-rules();
+  $levels: globals.get-multi-sass-levels();
+  $config: globals.get-multi-sass-config();
+  $parent: levels.get-current-level($levels);
+  $newLevel: levels.create-level($rules, $config, $parent, $args...);
+
+  @return $newLevel;
+}
+
+@function get-current-state() {
+  $rules: globals.get-multi-sass-rules();
+  $levels: globals.get-multi-sass-levels();
+  $config: globals.get-multi-sass-config();
+  $currentLevel: levels.get-current-level($levels);
+
+  @return ('rules': $rules, 'levels': $levels, 'config': $config, 'currentLevel': $currentLevel);
+}
+
+@function get-current-level() {
+  $levels: globals.get-multi-sass-levels();
+
+  @return levels.get-current-level($levels);
+}