@hypergood/css-core 0.0.1 → 0.0.3

package/dist/plugin.js

@@ -67084,7 +67084,6 @@ var atomizers = {
     const ast = csstree.parse(value2, { context: "value" });
     const matchResult = csstree.lexer.matchProperty("animation", ast);
     const match = matchResult.matched?.match;
-    console.log({ match: JSON.stringify(match) });
     if (!match) return void 0;
     const animationNames = [];
     const animationDurations = [];
@@ -67352,51 +67351,129 @@ function cssJsLogger() {
 }
 
 // src/evaluate.ts
-var UNKNOWN = {
+var UNKNOWN = (badNode) => ({
   confident: false,
-  value: void 0
-};
+  value: void 0,
+  badNode
+});
 var known = (value2) => ({
   confident: true,
   value: value2
 });
 function evaluateBabelExpression(node, knownConstants) {
-  if (!node) return UNKNOWN;
+  if (!node) return UNKNOWN(node);
   switch (node.type) {
+    case "ArrayExpression":
+      return evaluateArrayExpression(node, knownConstants);
     case "BinaryExpression":
       return evaluateBinaryExpression(node, knownConstants);
     case "Identifier":
       return evaluateIdentifier(node, knownConstants);
-    case "NumericLiteral":
-      return evaluateNumericLiteral(node);
     case "MemberExpression":
       return evaluateMemberExpression(node, knownConstants);
+    case "NullLiteral":
+      return evaluateNullLiteral(node);
+    case "NumericLiteral":
+      return evaluateNumericLiteral(node);
     case "ObjectExpression":
       return evaluateObjectExpression(node, knownConstants);
     case "StringLiteral":
       return evaluateStringLiteral(node);
+    case "TemplateLiteral":
+      return evaluateTemplateLiteral(node, knownConstants);
+    case "UnaryExpression":
+      return evaluateUnaryExpression(node, knownConstants);
     default:
-      return UNKNOWN;
+      return UNKNOWN(node);
   }
 }
+function evaluateArrayExpression(node, knownConstants) {
+  const elements = [];
+  for (const item of node.elements) {
+    if (!item) return UNKNOWN(node);
+    if (item.type === "SpreadElement") {
+      const spreadElements = evaluateBabelExpression(
+        item.argument,
+        knownConstants
+      );
+      if (spreadElements.confident) {
+        elements.push(...spreadElements.value);
+        continue;
+      } else {
+        return UNKNOWN(spreadElements.badNode);
+      }
+    }
+    const result = evaluateBabelExpression(item, knownConstants);
+    if (result.confident) {
+      elements.push(result.value);
+    } else {
+      return UNKNOWN(result.badNode);
+    }
+  }
+  return known(elements);
+}
 function evaluateBinaryExpression(node, knownConstants) {
   const left = evaluateBabelExpression(node.left, knownConstants);
   const right = evaluateBabelExpression(node.right, knownConstants);
-  if (!left.confident || !right.confident) return UNKNOWN;
+  if (!left.confident) return UNKNOWN(left.badNode);
+  if (!right.confident) return UNKNOWN(right.badNode);
   switch (node.operator) {
-    case "*":
-      return known(left.value * right.value);
     case "+":
       return known(left.value + right.value);
+    case "-":
+      return known(left.value - right.value);
+    case "/":
+      return known(left.value / right.value);
+    case "%":
+      return known(left.value % right.value);
+    case "*":
+      return known(left.value * right.value);
+    case "**":
+      return known(left.value ** right.value);
+    case "&":
+      return known(left.value & right.value);
+    case "|":
+      return known(left.value | right.value);
+    case ">>":
+      return known(left.value >> right.value);
+    case ">>>":
+      return known(left.value >>> right.value);
+    case "<<":
+      return known(left.value << right.value);
+    case "^":
+      return known(left.value ^ right.value);
+    case "==":
+      return known(left.value == right.value);
+    case "===":
+      return known(left.value === right.value);
+    case "!=":
+      return known(left.value != right.value);
+    case "!==":
+      return known(left.value !== right.value);
+    case "in":
+      return known(left.value in right.value);
+    case "instanceof":
+      return known(left.value instanceof right.value);
+    case ">":
+      return known(left.value > right.value);
+    case "<":
+      return known(left.value < right.value);
+    case ">=":
+      return known(left.value >= right.value);
+    case "<=":
+      return known(left.value <= right.value);
     default:
-      return UNKNOWN;
+      return UNKNOWN(node);
   }
 }
 function evaluateIdentifier(node, knownConstants) {
   if (node.name in knownConstants) {
     return known(knownConstants[node.name]);
   }
-  return UNKNOWN;
+  if (node.name === "undefined") {
+    return known(void 0);
+  }
+  return UNKNOWN(node);
 }
 function evaluateMemberExpression(node, knownConstants) {
   const obj = evaluateBabelExpression(node.object, knownConstants);
@@ -67408,12 +67485,15 @@ function evaluateMemberExpression(node, knownConstants) {
     if (propertyNode.type === "Identifier") {
       property = known(propertyNode.name);
     } else {
-      return UNKNOWN;
+      return UNKNOWN(node);
     }
   }
-  if (!obj.confident || !property.confident) return UNKNOWN;
+  if (!obj.confident || !property.confident) return UNKNOWN(node);
   return known(obj.value[property.value]);
 }
+function evaluateNullLiteral(node) {
+  return known(null);
+}
 function evaluateNumericLiteral(node) {
   return known(node.value);
 }
@@ -67422,9 +67502,9 @@ function evaluateObjectExpression(node, knownConstants) {
   for (const property of node.properties) {
     switch (property.type) {
       case "ObjectMethod":
-        return UNKNOWN;
+        return UNKNOWN(property);
       case "SpreadElement":
-        return UNKNOWN;
+        return UNKNOWN(property);
       case "ObjectProperty": {
         const keyNode = property.key;
         let key2;
@@ -67436,11 +67516,12 @@ function evaluateObjectExpression(node, knownConstants) {
           } else if (keyNode.type === "Identifier") {
             key2 = known(keyNode.name);
           } else {
-            return UNKNOWN;
+            return UNKNOWN(property);
           }
         }
         const value2 = evaluateBabelExpression(property.value, knownConstants);
-        if (!key2 || !key2.confident || !value2.confident) return UNKNOWN;
+        if (!key2 || !key2.confident || !value2.confident)
+          return UNKNOWN(property);
         result[key2.value] = value2.value;
       }
     }
@@ -67450,6 +67531,45 @@ function evaluateObjectExpression(node, knownConstants) {
 function evaluateStringLiteral(node) {
   return known(node.value);
 }
+function evaluateTemplateLiteral(node, knownConstants) {
+  const quasisAsStrings = node.quasis.map((q) => q.value.cooked ?? q.value.raw);
+  const expressions = node.expressions.map(
+    (e) => evaluateBabelExpression(e, knownConstants)
+  );
+  if (expressions.some((e) => !e.confident)) {
+    return UNKNOWN(node);
+  }
+  const expressionValues = expressions.map((e) => e.value);
+  let result = "";
+  for (let i = 0; i < quasisAsStrings.length; i++) {
+    result += quasisAsStrings[i];
+    if (i < expressionValues.length) {
+      let value2 = expressionValues[i];
+      result += value2;
+    }
+  }
+  return known(result);
+}
+function evaluateUnaryExpression(node, knownConstants) {
+  const argument = evaluateBabelExpression(node.argument, knownConstants);
+  if (!argument.confident) return UNKNOWN(argument.badNode);
+  switch (node.operator) {
+    case "+":
+      return known(+argument.value);
+    case "-":
+      return known(-argument.value);
+    case "void":
+      return known(void argument.value);
+    case "!":
+      return known(!argument.value);
+    case "~":
+      return known(~argument.value);
+    case "typeof":
+      return known(typeof argument.value);
+    default:
+      return UNKNOWN(node);
+  }
+}
 
 // src/runtime.ts
 function mergeClassNames(classNames) {
@@ -67483,7 +67603,7 @@ ${styleRules2.map((rule) => `    ${rule.property}: ${rule.value};`).join("\n")}
   });
   const tree = groupStyleRules(styleRules, []);
   const rulesSection = renderStyleRuleNode(tree, styleRuleToClassName);
-  return keyframesSection + "\n" + rulesSection + "\n/* " + JSON.stringify(styleRules, null, 2) + " */";
+  return keyframesSection + "\n" + rulesSection;
 }
 function renderStyleRuleNode(node, styleRuleToClassName, indent = 0) {
   const rulesSection = node.rules.sort((a, b) => a.value.localeCompare(b.value)).sort((a, b) => a.property.localeCompare(b.property)).sort((a, b) => a.selector.length - b.selector.length).sort((a, b) => a.atRules.length - b.atRules.length).map((rule) => {
@@ -67939,7 +68059,7 @@ function babelPluginReplaceCssProp({
           }
         }
       },
-      JSXAttribute(path) {
+      JSXAttribute(path, state) {
         if (path.node.name && path.node.name.type === "JSXIdentifier" && path.node.name.name === "css") {
           const value2 = path.node.value;
           if (value2?.type !== "JSXExpressionContainer") return;
@@ -67952,9 +68072,18 @@ function babelPluginReplaceCssProp({
               );
               let styleObject = styleObjectResult.value;
               if (!styleObjectResult.confident) {
-                throw new Error(
-                  "COULD NOT EVALUATE CSS: L" + expression.loc?.start.line
-                );
+                const badNode = styleObjectResult.badNode;
+                if (badNode) {
+                  const { start, end } = badNode;
+                  const rawCode = state.file.code.slice(start, end);
+                  console.error(`COULD NOT EVALUATE CSS: \`${rawCode}\``);
+                  return;
+                } else {
+                  console.error(
+                    "COULD NOT EVALUATE CSS: L" + expression.loc?.start.line
+                  );
+                  return;
+                }
               }
               const classNames = styleObjectToClassNames(styleObject);
               path.node.name.name = "className";