@atlaskit/stylelint-design-system/dist/cjs/rules/no-unsafe-design-token-usage/index.js

Stylelint plugin for use with the Atlassian Design System.

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ruleName = exports.messages = exports.default = void 0;
var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
var _stylelint = _interopRequireDefault(require("stylelint"));
var _renameMapping = _interopRequireDefault(require("@atlaskit/tokens/rename-mapping"));
var _getCssCustomProperty = require("@atlaskit/tokens/utils/get-css-custom-property");
var _getDefaultTokenValue = require("../../utils/get-default-token-value");
var _isFunction = require("../../utils/is-function");
var _isToken = require("../../utils/is-token");
var _isVar = require("../../utils/is-var");
var _isWord = require("../../utils/is-word");
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
var ruleName = exports.ruleName = 'design-system/no-unsafe-design-token-usage';
var messages = exports.messages = _stylelint.default.utils.ruleMessages(ruleName, {
  invalidToken: function invalidToken(name) {
    return "The token '".concat(name, "' does not exist. You can find the design tokens reference at <https://atlaskit.atlassian.com/packages/design-system/tokens/docs/tokens-reference>.");
  },
  tokenRemoved: function tokenRemoved(name, replacement) {
    return "The token '".concat(name, "' has been deleted. Please use ").concat(replacement, " instead.");
  },
  missingFallback: 'Token usage is missing a fallback.',
  hasFallback: 'Token usage has a fallback.'
});
var isInvalidToken = function isInvalidToken(node) {
  return (0, _isWord.isWord)(node) && node.value.startsWith('--ds-') && !(0, _isToken.isToken)(node);
};
var isDeletedToken = function isDeletedToken(node) {
  return (0, _isWord.isWord)(node) && node.value.startsWith('--ds-') && _renameMapping.default.filter(function (_ref) {
    var state = _ref.state;
    return state === 'deleted';
  }).some(function (token) {
    return (0, _getCssCustomProperty.getCSSCustomProperty)(token.path) === node.value;
  });
};
var ruleBase = function ruleBase(isEnabled) {
  var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var context = arguments.length > 2 ? arguments[2] : undefined;
  return function (root, result) {
    var validOptions = _stylelint.default.utils.validateOptions(result, ruleName, {
      actual: isEnabled,
      possible: [true, false]
    }, {
      actual: flags,
      possible: {
        shouldEnsureFallbackUsage: [true, false],
        fallbackUsage: ['forced', 'optional', 'none']
      },
      optional: true
    });
    if (!validOptions || !isEnabled) {
      return;
    }
    var _ref2 = flags,
      shouldEnsureFallbackUsage = _ref2.shouldEnsureFallbackUsage,
      _ref2$fallbackUsage = _ref2.fallbackUsage,
      fallbackUsage = _ref2$fallbackUsage === void 0 ? 'optional' : _ref2$fallbackUsage;
    var fallbackUsageStrategy = fallbackUsage;
    if (shouldEnsureFallbackUsage) {
      fallbackUsageStrategy = 'forced';
    } else if (shouldEnsureFallbackUsage === false) {
      fallbackUsageStrategy = 'none';
    }
    root.walkDecls(function (decl) {
      var parsedValue = (0, _postcssValueParser.default)(decl.value);
      parsedValue.walk(function (node) {
        if (!(0, _isFunction.isFunction)(node) || !(0, _isVar.isVar)(node)) {
          return;
        }
        var _node$nodes = (0, _toArray2.default)(node.nodes),
          head = _node$nodes[0],
          tail = _arrayLikeToArray(_node$nodes).slice(1);
        if (!head) {
          return;
        }
        if (isDeletedToken(head)) {
          var tokenMeta = _renameMapping.default.find(function (_ref3) {
            var path = _ref3.path;
            return (0, _getCssCustomProperty.getCSSCustomProperty)(path) === head.value;
          });
          if (!tokenMeta) {
            return;
          }
          if (tokenMeta.replacement) {
            var replacement = (0, _getCssCustomProperty.getCSSCustomProperty)(tokenMeta.replacement);
            if (context.fix) {
              decl.value = decl.value.replace(head.value, replacement);
              return;
            } else {
              return _stylelint.default.utils.report({
                message: messages.tokenRemoved(head.value, replacement),
                node: decl,
                word: node.value,
                result: result,
                ruleName: ruleName
              });
            }
          }
        }
        if (isInvalidToken(head)) {
          return _stylelint.default.utils.report({
            message: messages.invalidToken(head.value),
            node: decl,
            word: node.value,
            result: result,
            ruleName: ruleName
          });
        }
        var isTokenUsage = (0, _isToken.isToken)(head);
        if (!isTokenUsage) {
          return;
        }
        var hasFallback = tail.some(function (node) {
          return !(0, _isToken.isToken)(node);
        });
        if (fallbackUsageStrategy === 'optional' || fallbackUsageStrategy === 'forced' && hasFallback || fallbackUsageStrategy === 'none' && !hasFallback) {
          return;
        }
        if (context.fix && !hasFallback) {
          var defaultFallback = (0, _getDefaultTokenValue.getDefaultTokenValue)(head);
          if (defaultFallback) {
            decl.value = decl.value.replace(head.value, "".concat(head.value, ", ").concat(defaultFallback));
            return;
          }
        }
        _stylelint.default.utils.report({
          message: hasFallback ? messages.hasFallback : messages.missingFallback,
          node: decl,
          word: node.value,
          result: result,
          ruleName: ruleName
        });
      });
    });
  };
};
var rule = Object.assign(ruleBase, {
  ruleName: ruleName,
  messages: messages
});
var plugin = _stylelint.default.createPlugin(ruleName, rule);

// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
var _default = exports.default = plugin;