aesthetic-utils/esm/index.js

Utility functions for Aesthetic.

function _extends() {
  _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];

      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }

    return target;
  };

  return _extends.apply(this, arguments);
}

function toArray(value) {
  if (!value) {
    return [];
  }

  return Array.isArray(value) ? value : [value];
}

var FORMATS = {
  '.eot': 'embedded-opentype',
  '.otf': 'opentype',
  '.svg': 'svg',
  '.svgz': 'svg',
  '.ttf': 'truetype',
  '.woff': 'woff',
  '.woff2': 'woff2'
};
function formatFontFace(properties) {
  var fontFace = _extends({}, properties);

  var src = [];

  if (fontFace.local) {
    toArray(fontFace.local).forEach(function (alias) {
      src.push("local('" + String(alias) + "')");
    });
    delete fontFace.local;
  }

  if (Array.isArray(fontFace.srcPaths)) {
    toArray(fontFace.srcPaths).forEach(function (srcPath) {
      var ext = srcPath.slice(srcPath.lastIndexOf('.'));

      if (ext.includes('?')) {
        var _ext$split = ext.split('?');

        ext = _ext$split[0];
      }

      if (FORMATS[ext]) {
        src.push("url('" + srcPath + "') format('" + FORMATS[ext] + "')");
      } else if ("production" !== process.env.NODE_ENV) {
        throw new Error("Unsupported font format \"" + ext + "\".");
      }
    });
    delete fontFace.srcPaths;
  } else {
    return fontFace;
  }

  fontFace.src = src.join(', ');
  return fontFace;
}

var QUERY_GROUP = /\([\x2Da-z\u017F\u212A]+:/gi;
function hasQueryCondition(value) {
  return !!value.match(QUERY_GROUP);
}

function getFlushedStyles(styles) {
  return toArray(styles).reduce(function (css, style) {
    var sheet = style.sheet;
    var content = '';

    if (sheet && sheet.cssRules) {
      content = Array.from(sheet.cssRules).map(function (rule) {
        return rule ? rule.cssText : '';
      }).join('\n');
    } else if (style.textContent) {
      content = style.textContent;
    }

    if (!content) {
      return css;
    }

    if (style.media && hasQueryCondition(style.media)) {
      content = "@media " + style.media + " { " + content + " }";
    }

    return (css + "\n" + content).trim();
  }, '');
}

function getStyleElements(namespace) {
  if (typeof document === 'undefined') {
    return [];
  }

  return Array.from(document.querySelectorAll(namespace ? "style[" + namespace + "]" : 'style'));
}

function isObject(value) {
  return value !== null && !Array.isArray(value) && typeof value === 'object';
}

function isRTL(dir) {
  return !!dir && dir === 'rtl';
}

var NON_GLOBAL_PREFIX = /^(#|\.|@)/;

function containsNestedRules(rule) {
  return typeof CSSStyleSheet !== 'undefined' && rule instanceof CSSStyleSheet || typeof CSSMediaRule !== 'undefined' && rule instanceof CSSMediaRule || typeof CSSSupportsRule !== 'undefined' && rule instanceof CSSSupportsRule;
}

function deleteRule(parent, ruleToDelete) {
  var filterList = false;
  Array.from(parent.cssRules).some(function (rule, index) {
    if (rule === ruleToDelete && parent.cssRules[index]) {
      if (typeof parent.deleteRule === 'function') {
        parent.deleteRule(index);
      } else {
        filterList = true;
        delete parent.cssRules[index];
      }

      return true;
    }

    return false;
  });

  if (filterList || process.env.NODE_ENV === 'test') {
    parent.cssRules = parent.cssRules.filter(Boolean);
  }

  if (parent.cssRules.length === 0 && parent instanceof CSSRule) {
    if (containsNestedRules(parent.parentRule)) {
      deleteRule(parent.parentRule, parent);
    }

    if (containsNestedRules(parent.parentStyleSheet)) {
      deleteRule(parent.parentStyleSheet, parent);
    }
  }
}

function purgeRules(parent, onlyGlobals) {
  if (onlyGlobals === void 0) {
    onlyGlobals = false;
  }

  if (!parent.cssRules) {
    return;
  }

  var rulesToDelete = [];
  Array.from(parent.cssRules).forEach(function (rule) {
    if (containsNestedRules(rule)) {
      purgeRules(rule);
    }

    if (onlyGlobals && NON_GLOBAL_PREFIX.test(rule.cssText)) {
      return;
    }

    rulesToDelete.push(rule);
  });
  rulesToDelete.forEach(function (rule) {
    deleteRule(parent, rule);
  });
}

function purgeStyles(styles, onlyGlobals) {
  if (onlyGlobals === void 0) {
    onlyGlobals = false;
  }

  toArray(styles).forEach(function (style) {
    style.textContent = '';

    if (containsNestedRules(style.sheet)) {
      purgeRules(style.sheet, onlyGlobals);
    }
  });
}

function stripClassPrefix(name) {
  return name.charAt(0) === '.' ? name.slice(1) : name;
}

function toObjectRecursive(map, cb) {
  var object = {};

  if (map instanceof Map) {
    map.forEach(function (obj, key) {
      object[key] = obj.toObject();

      if (cb) {
        cb(key, object[key]);
      }
    });
  } else {
    Object.keys(map).forEach(function (key) {
      object[key] = map[key].toObject();

      if (cb) {
        cb(key, object[key]);
      }
    });
  }

  return object;
}

export { NON_GLOBAL_PREFIX, formatFontFace, getFlushedStyles, getStyleElements, hasQueryCondition, isObject, isRTL, purgeStyles, stripClassPrefix, toArray, toObjectRecursive };