zeplin-extension-style-kit/elements/fontFace.js

Models and utilities to generate CSS-like style code in Zeplin extensions.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _fontFamily = _interopRequireDefault(require("../declarations/fontFamily"));

var _fontStyle = _interopRequireDefault(require("../declarations/fontStyle"));

var _fontStretch = _interopRequireDefault(require("../declarations/fontStretch"));

var _fontWeight = _interopRequireDefault(require("../declarations/fontWeight"));

var _atRule = _interopRequireDefault(require("../atRule"));

var _fontSrc = _interopRequireDefault(require("../declarations/fontSrc"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

var FONT_STYLE_PRECEDENCE = Object.freeze({
  normal: 2,
  italic: 1,
  oblique: 0
});

var FontFace = /*#__PURE__*/function () {
  function FontFace(fontObject) {
    _classCallCheck(this, FontFace);

    this.font = fontObject;
    this.declarations = this.collectDeclarations();
  }

  _createClass(FontFace, [{
    key: "collectDeclarations",
    value: function collectDeclarations() {
      var font = this.font;
      var variable = ("fontVariationSettings" in font);
      var declarations = [new _fontFamily.default(font.fontFamily), new _fontSrc.default(font.fontFace, variable)];

      if (!variable) {
        declarations.push(new _fontWeight.default(font.fontWeight), new _fontStyle.default(font.fontStyle), new _fontStretch.default(font.fontStretch));
      }

      return declarations;
    }
  }, {
    key: "style",
    get: function get() {
      return new _atRule.default(_atRule.default.Rule.FONT_FACE, this.declarations);
    }
  }], [{
    key: "comparator",
    value: function comparator(prev, cur) {
      // Sort font families alphabetically
      if (prev.fontFamily < cur.fontFamily) {
        return -1;
      }

      if (prev.fontFamily > cur.fontFamily) {
        return 1;
      } // Then sort by weight


      if (prev.fontWeight !== cur.fontWeight) {
        return prev.fontWeight - cur.fontWeight;
      } // Then sort by style


      if (prev.fontStyle !== cur.fontStyle) {
        return FONT_STYLE_PRECEDENCE[prev.fontStyle] - FONT_STYLE_PRECEDENCE[cur.fontStyle];
      }

      return 1;
    }
  }]);

  return FontFace;
}();

var _default = FontFace;
exports.default = _default;