tailwindcss 0.0.0-insiders.df011dc → 0.0.0-insiders.e2d5f21

package/lib/util/pluginUtils.js

@@ -1,318 +1,186 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.applyPseudoToMarker = applyPseudoToMarker;
 exports.updateAllClasses = updateAllClasses;
-exports.updateLastClasses = updateLastClasses;
-exports.transformAllSelectors = transformAllSelectors;
-exports.transformAllClasses = transformAllClasses;
-exports.transformLastClasses = transformLastClasses;
 exports.asValue = asValue;
-exports.asUnit = asUnit;
 exports.asColor = asColor;
-exports.asAngle = asAngle;
-exports.asLength = asLength;
 exports.asLookupValue = asLookupValue;
 exports.coerceValue = coerceValue;
-
 var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
-
 var _escapeCommas = _interopRequireDefault(require("./escapeCommas"));
-
 var _withAlphaVariable = require("./withAlphaVariable");
-
-var _isKeyframeRule = _interopRequireDefault(require("./isKeyframeRule"));
-
-var _color = require("./color");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function applyPseudoToMarker(selector, marker, state, join) {
-  let states = [state];
-  let markerIdx = selector.indexOf(marker + ':');
-
-  if (markerIdx !== -1) {
-    let existingMarker = selector.slice(markerIdx, selector.indexOf(' ', markerIdx));
-    states = states.concat(selector.slice(markerIdx + marker.length + 1, existingMarker.length).split(':'));
-    selector = selector.replace(existingMarker, '');
-  }
-
-  return join(`${[marker, ...states].join(':')}`, selector);
-}
-
-function updateAllClasses(selectors, updateClass) {
-  let parser = (0, _postcssSelectorParser.default)(selectors => {
-    selectors.walkClasses(sel => {
-      let updatedClass = updateClass(sel.value, {
-        withPseudo(className, pseudo) {
-          sel.parent.insertAfter(sel, _postcssSelectorParser.default.pseudo({
-            value: `${pseudo}`
-          }));
-          return className;
-        }
-
-      });
-      sel.value = updatedClass;
-
-      if (sel.raws && sel.raws.value) {
-        sel.raws.value = (0, _escapeCommas.default)(sel.raws.value);
-      }
+var _dataTypes = require("./dataTypes");
+var _negateValue = _interopRequireDefault(require("./negateValue"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function updateAllClasses(selectors1, updateClass) {
+    let parser = (0, _postcssSelectorParser).default((selectors)=>{
+        selectors.walkClasses((sel)=>{
+            let updatedClass = updateClass(sel.value);
+            sel.value = updatedClass;
+            if (sel.raws && sel.raws.value) {
+                sel.raws.value = (0, _escapeCommas).default(sel.raws.value);
+            }
+        });
     });
-  });
-  let result = parser.processSync(selectors);
-  return result;
+    let result = parser.processSync(selectors1);
+    return result;
 }
-
-function updateLastClasses(selectors, updateClass) {
-  let parser = (0, _postcssSelectorParser.default)(selectors => {
-    selectors.each(sel => {
-      let lastClass = sel.filter(({
-        type
-      }) => type === 'class').pop();
-
-      if (lastClass === undefined) {
-        return;
-      }
-
-      let updatedClass = updateClass(lastClass.value, {
-        withPseudo(className, pseudo) {
-          lastClass.parent.insertAfter(lastClass, _postcssSelectorParser.default.pseudo({
-            value: `${pseudo}`
-          }));
-          return className;
-        }
-
-      });
-      lastClass.value = updatedClass;
-
-      if (lastClass.raws && lastClass.raws.value) {
-        lastClass.raws.value = (0, _escapeCommas.default)(lastClass.raws.value);
-      }
-    });
-  });
-  let result = parser.processSync(selectors);
-  return result;
-}
-
-function splitByNotEscapedCommas(str) {
-  let chunks = [];
-  let currentChunk = '';
-
-  for (let i = 0; i < str.length; i++) {
-    if (str[i] === ',' && str[i - 1] !== '\\') {
-      chunks.push(currentChunk);
-      currentChunk = '';
-    } else {
-      currentChunk += str[i];
+function resolveArbitraryValue(modifier, validate) {
+    if (!isArbitraryValue(modifier)) {
+        return undefined;
     }
-  }
-
-  chunks.push(currentChunk);
-  return chunks;
-}
-
-function transformAllSelectors(transformSelector, {
-  wrap,
-  withRule
-} = {}) {
-  return ({
-    container
-  }) => {
-    container.walkRules(rule => {
-      if ((0, _isKeyframeRule.default)(rule)) {
-        return rule;
-      }
-
-      let transformed = splitByNotEscapedCommas(rule.selector).map(transformSelector).join(',');
-      rule.selector = transformed;
-
-      if (withRule) {
-        withRule(rule);
-      }
-
-      return rule;
-    });
-
-    if (wrap) {
-      let wrapper = wrap();
-      let nodes = container.nodes;
-      container.removeAll();
-      wrapper.append(nodes);
-      container.append(wrapper);
+    let value = modifier.slice(1, -1);
+    if (!validate(value)) {
+        return undefined;
     }
-  };
+    return (0, _dataTypes).normalize(value);
 }
-
-function transformAllClasses(transformClass, {
-  wrap,
-  withRule
-} = {}) {
-  return ({
-    container
-  }) => {
-    container.walkRules(rule => {
-      let selector = rule.selector;
-      let variantSelector = updateAllClasses(selector, transformClass);
-      rule.selector = variantSelector;
-
-      if (withRule) {
-        withRule(rule);
-      }
-
-      return rule;
-    });
-
-    if (wrap) {
-      let wrapper = wrap();
-      let nodes = container.nodes;
-      container.removeAll();
-      wrapper.append(nodes);
-      container.append(wrapper);
+function asNegativeValue(modifier, lookup = {
+}, validate) {
+    let positiveValue = lookup[modifier];
+    if (positiveValue !== undefined) {
+        return (0, _negateValue).default(positiveValue);
     }
-  };
-}
-
-function transformLastClasses(transformClass, {
-  wrap,
-  withRule
-} = {}) {
-  return ({
-    container
-  }) => {
-    container.walkRules(rule => {
-      let selector = rule.selector;
-      let variantSelector = updateLastClasses(selector, transformClass);
-      rule.selector = variantSelector;
-
-      if (withRule) {
-        withRule(rule);
-      }
-
-      return rule;
-    });
-
-    if (wrap) {
-      let wrapper = wrap();
-      let nodes = container.nodes;
-      container.removeAll();
-      wrapper.append(nodes);
-      container.append(wrapper);
+    if (isArbitraryValue(modifier)) {
+        let resolved = resolveArbitraryValue(modifier, validate);
+        if (resolved === undefined) {
+            return undefined;
+        }
+        return (0, _negateValue).default(resolved);
     }
-  };
-}
-
-function asValue(modifier, lookup = {}, {
-  validate = () => true
-} = {}) {
-  let value = lookup[modifier];
-
-  if (value !== undefined) {
-    return value;
-  }
-
-  if (modifier[0] !== '[' || modifier[modifier.length - 1] !== ']') {
-    return undefined;
-  }
-
-  value = modifier.slice(1, -1);
-
-  if (!validate(value)) {
-    return undefined;
-  } // convert `_` to ` `, escept for escaped underscores `\_`
-
-
-  value = value.replace(/([^\\])_/g, '$1 ').replace(/^_/g, ' ').replace(/\\_/g, '_'); // add spaces around operators inside calc() that do not follow an operator or (
-
-  return value.replace(/(-?\d*\.?\d(?!\b-.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g, '$1 $2 ');
 }
-
-function asUnit(modifier, units, lookup = {}) {
-  return asValue(modifier, lookup, {
-    validate: value => {
-      let unitsPattern = `(?:${units.join('|')})`;
-      return new RegExp(`${unitsPattern}$`).test(value) || new RegExp(`^calc\\(.+?${unitsPattern}`).test(value);
+function asValue(modifier, options = {
+}, { validate =()=>true
+  } = {
+}) {
+    var ref;
+    let value = (ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier];
+    if (value !== undefined) {
+        return value;
+    }
+    if (options.supportsNegativeValues && modifier.startsWith('-')) {
+        return asNegativeValue(modifier.slice(1), options.values, validate);
     }
-  });
+    return resolveArbitraryValue(modifier, validate);
 }
-
 function isArbitraryValue(input) {
-  return input.startsWith('[') && input.endsWith(']');
+    return input.startsWith('[') && input.endsWith(']');
 }
-
 function splitAlpha(modifier) {
-  let slashIdx = modifier.lastIndexOf('/');
-
-  if (slashIdx === -1 || slashIdx === modifier.length - 1) {
-    return [modifier];
-  }
-
-  return [modifier.slice(0, slashIdx), modifier.slice(slashIdx + 1)];
-}
-
-function asColor(modifier, lookup = {}, tailwindConfig = {}) {
-  if (lookup[modifier] !== undefined) {
-    return lookup[modifier];
-  }
-
-  let [color, alpha] = splitAlpha(modifier);
-
-  if (lookup[color] !== undefined) {
-    var _tailwindConfig$theme, _tailwindConfig$theme2;
-
-    if (isArbitraryValue(alpha)) {
-      return (0, _withAlphaVariable.withAlphaValue)(lookup[color], alpha.slice(1, -1));
+    let slashIdx = modifier.lastIndexOf('/');
+    if (slashIdx === -1 || slashIdx === modifier.length - 1) {
+        return [
+            modifier
+        ];
     }
-
-    if (((_tailwindConfig$theme = tailwindConfig.theme) === null || _tailwindConfig$theme === void 0 ? void 0 : (_tailwindConfig$theme2 = _tailwindConfig$theme.opacity) === null || _tailwindConfig$theme2 === void 0 ? void 0 : _tailwindConfig$theme2[alpha]) === undefined) {
-      return undefined;
+    return [
+        modifier.slice(0, slashIdx),
+        modifier.slice(slashIdx + 1)
+    ];
+}
+function asColor(modifier, options = {
+}, { tailwindConfig ={
+}  } = {
+}) {
+    var ref;
+    if (((ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier]) !== undefined) {
+        var ref1;
+        return (ref1 = options.values) === null || ref1 === void 0 ? void 0 : ref1[modifier];
     }
-
-    return (0, _withAlphaVariable.withAlphaValue)(lookup[color], tailwindConfig.theme.opacity[alpha]);
-  }
-
-  return asValue(modifier, lookup, {
-    validate: value => (0, _color.parseColor)(value) !== null
-  });
-}
-
-function asAngle(modifier, lookup = {}) {
-  return asUnit(modifier, ['deg', 'grad', 'rad', 'turn'], lookup);
+    let [color, alpha] = splitAlpha(modifier);
+    if (alpha !== undefined) {
+        var ref2, ref3, ref4;
+        var ref5;
+        let normalizedColor = (ref5 = (ref2 = options.values) === null || ref2 === void 0 ? void 0 : ref2[color]) !== null && ref5 !== void 0 ? ref5 : isArbitraryValue(color) ? color.slice(1, -1) : undefined;
+        if (normalizedColor === undefined) {
+            return undefined;
+        }
+        if (isArbitraryValue(alpha)) {
+            return (0, _withAlphaVariable).withAlphaValue(normalizedColor, alpha.slice(1, -1));
+        }
+        if (((ref3 = tailwindConfig.theme) === null || ref3 === void 0 ? void 0 : (ref4 = ref3.opacity) === null || ref4 === void 0 ? void 0 : ref4[alpha]) === undefined) {
+            return undefined;
+        }
+        return (0, _withAlphaVariable).withAlphaValue(normalizedColor, tailwindConfig.theme.opacity[alpha]);
+    }
+    return asValue(modifier, options, {
+        validate: _dataTypes.color
+    });
 }
-
-function asLength(modifier, lookup = {}) {
-  return asUnit(modifier, ['cm', 'mm', 'Q', 'in', 'pc', 'pt', 'px', 'em', 'ex', 'ch', 'rem', 'lh', 'vw', 'vh', 'vmin', 'vmax', '%'], lookup);
+function asLookupValue(modifier, options = {
+}) {
+    var ref;
+    return (ref = options.values) === null || ref === void 0 ? void 0 : ref[modifier];
 }
-
-function asLookupValue(modifier, lookup = {}) {
-  return lookup[modifier];
+function guess(validate) {
+    return (modifier, options)=>{
+        return asValue(modifier, options, {
+            validate
+        });
+    };
 }
-
 let typeMap = {
-  any: asValue,
-  color: asColor,
-  angle: asAngle,
-  length: asLength,
-  lookup: asLookupValue
+    any: asValue,
+    color: asColor,
+    url: guess(_dataTypes.url),
+    image: guess(_dataTypes.image),
+    length: guess(_dataTypes.length),
+    percentage: guess(_dataTypes.percentage),
+    position: guess(_dataTypes.position),
+    lookup: asLookupValue,
+    'generic-name': guess(_dataTypes.genericName),
+    'family-name': guess(_dataTypes.familyName),
+    number: guess(_dataTypes.number),
+    'line-width': guess(_dataTypes.lineWidth),
+    'absolute-size': guess(_dataTypes.absoluteSize),
+    'relative-size': guess(_dataTypes.relativeSize),
+    shadow: guess(_dataTypes.shadow)
 };
-
+let supportedTypes = Object.keys(typeMap);
 function splitAtFirst(input, delim) {
-  return (([first, ...rest]) => [first, rest.join(delim)])(input.split(delim));
-}
-
-function coerceValue(type, modifier, values, tailwindConfig) {
-  let [scaleType, arbitraryType = scaleType] = [].concat(type);
-
-  if (isArbitraryValue(modifier)) {
-    let [explicitType, value] = splitAtFirst(modifier.slice(1, -1), ':');
-
-    if (value.length > 0 && Object.keys(typeMap).includes(explicitType)) {
-      return [asValue(`[${value}]`, values, tailwindConfig), explicitType];
+    let idx = input.indexOf(delim);
+    if (idx === -1) return [
+        undefined,
+        input
+    ];
+    return [
+        input.slice(0, idx),
+        input.slice(idx + 1)
+    ];
+}
+function coerceValue(types, modifier, options, tailwindConfig) {
+    if (isArbitraryValue(modifier)) {
+        let arbitraryValue = modifier.slice(1, -1);
+        let [explicitType, value] = splitAtFirst(arbitraryValue, ':');
+        // It could be that this resolves to `url(https` which is not a valid
+        // identifier. We currently only support "simple" words with dashes or
+        // underscores. E.g.: family-name
+        if (!/^[\w-_]+$/g.test(explicitType)) {
+            value = arbitraryValue;
+        } else if (explicitType !== undefined && !supportedTypes.includes(explicitType)) {
+            return [];
+        }
+        if (value.length > 0 && supportedTypes.includes(explicitType)) {
+            return [
+                asValue(`[${value}]`, options),
+                explicitType
+            ];
+        }
+    }
+    // Find first matching type
+    for (let type of [].concat(types)){
+        let result = typeMap[type](modifier, options, {
+            tailwindConfig
+        });
+        if (result) return [
+            result,
+            type
+        ];
     }
-
-    return [typeMap[arbitraryType](modifier, values, tailwindConfig), arbitraryType];
-  }
-
-  return [typeMap[scaleType](modifier, values, tailwindConfig), scaleType];
-}
+    return [];
+}

package/lib/util/prefixSelector.js

@@ -1,23 +1,21 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
 exports.default = _default;
-
 var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
-
 var _tap = require("./tap");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function _default(prefix, selector) {
-  const getPrefix = typeof prefix === 'function' ? prefix : () => prefix === undefined ? '' : prefix;
-  return (0, _postcssSelectorParser.default)(selectors => {
-    selectors.walkClasses(classSelector => {
-      (0, _tap.tap)(classSelector.value, baseClass => {
-        classSelector.value = `${getPrefix('.' + baseClass)}${baseClass}`;
-      });
-    });
-  }).processSync(selector);
-}
+    return (0, _postcssSelectorParser).default((selectors)=>{
+        selectors.walkClasses((classSelector)=>{
+            (0, _tap).tap(classSelector.value, (baseClass)=>{
+                classSelector.value = `${prefix}${baseClass}`;
+            });
+        });
+    }).processSync(selector);
+}