@una-ui/extractor-vue-script-edge 0.64.0-29260635.86853d3 → 0.64.0-29262088.1cb0816

package/dist/index.mjs

@@ -1,5 +1,10 @@
+import traverseDefault from '@babel/traverse';
 import { defaultSplitRE } from '@unocss/core';
+import { parse } from '@vue/compiler-sfc';
+import { parseModule } from 'magicast';
+import { parsePath } from 'ufo';
 
+const traverse = "default" in traverseDefault ? traverseDefault.default : traverseDefault;
 function generateSelectors(prefix, values) {
   prefix = prefix.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
   return values.filter((v) => Boolean(v) && v !== ":").map((v) => `[${prefix}~="${v}"]`);
@@ -8,50 +13,92 @@ function normalizePrefixes(prefixes) {
   const camelCasePrefixes = prefixes.map((prefix) => prefix.replace(/-([a-z])/g, (_, c) => c.toUpperCase()));
   return [.../* @__PURE__ */ new Set([...prefixes, ...camelCasePrefixes])];
 }
-function splitCodeWithArbitraryVariants(code, prefixes) {
-  const result = [];
-  const normalizedPrefixes = normalizePrefixes(prefixes);
-  for (const prefix of normalizedPrefixes) {
-    const regex = new RegExp(`\\b${prefix}\\s*:\\s*(?:['"]([^'"]*)['"]|{[^}]*\\bdefault\\s*:\\s*['"]([^'"]*)['"]\\s*,?.*?})`, "gms");
-    let match;
-    while ((match = regex.exec(code)) !== null) {
-      const values = (match[1] ?? match[2]).split(defaultSplitRE);
-      const selectors = generateSelectors(prefix, values);
-      result.push(...selectors);
+function getLiteralValue(node) {
+  if (node.type === "ConditionalExpression") {
+    return [node.consequent, node.alternate].map(getLiteralValue);
+  }
+  if (node.type === "StringLiteral") {
+    return node.value;
+  }
+  if (node.type === "TemplateLiteral") {
+    if (node.expressions.length > 0) {
+      return void 0;
     }
+    return node.quasis.map((q) => q.value.cooked).join("");
   }
-  return result;
+  if (node.type === "ObjectExpression") {
+    return getObjectLiteralValue(node);
+  }
+  return void 0;
+}
+function getObjectLiteralValue(node) {
+  return Object.fromEntries(
+    node.properties.filter((prop) => prop.type === "ObjectProperty").filter((prop) => prop.key.type === "Identifier").map((prop) => {
+      const key = prop.key.name;
+      return [key, getLiteralValue(prop.value)];
+    })
+  );
 }
-function extractConditionalStatements(code, prefixes) {
+function discoverVariants(node, prefixes) {
   const result = [];
-  const normalizedPrefixes = normalizePrefixes(prefixes);
-  for (const prefix of normalizedPrefixes) {
-    const ternaryRegex = new RegExp(
-      `\\b${prefix}\\s*:\\s*[^?]*?\\?\\s*['"\`]([^'"\`]*?)['"\`]\\s*:\\s*['"\`]([^'"\`]*?)['"\`]`,
-      "gms"
-    );
-    let match;
-    while ((match = ternaryRegex.exec(code)) !== null) {
-      const [, trueValue, falseValue] = match;
-      const allValues = [
-        ...trueValue.split(defaultSplitRE),
-        ...falseValue.split(defaultSplitRE)
-      ];
-      const selectors = generateSelectors(prefix, allValues);
-      result.push(...selectors);
+  traverse(node, {
+    noScope: true,
+    // scope doesn't work for some reason.
+    enter({ node: node2 }) {
+      if (node2.type === "ObjectExpression") {
+        const object = getObjectLiteralValue(node2);
+        for (let [key, value] of Object.entries(object)) {
+          if (prefixes.includes(key) && value) {
+            if (!Array.isArray(value)) {
+              value = [value];
+            }
+            for (let v of value) {
+              if (typeof v === "object" && v !== null && "default" in v) {
+                v = v.default;
+              }
+              if (typeof v !== "string") {
+                continue;
+              }
+              result.push([key, v]);
+            }
+          }
+        }
+      }
+      if (node2.type === "AssignmentPattern") {
+        const { left, right } = node2;
+        if (left.type === "Identifier" && right.type === "StringLiteral") {
+          const prefix = left.name;
+          const value = right.value;
+          if (prefixes.includes(prefix)) {
+            result.push([prefix, value]);
+          }
+        }
+      }
     }
-  }
-  return result;
+  });
+  return result.flatMap(([key, v]) => {
+    const values = v.split(defaultSplitRE);
+    return generateSelectors(key, values);
+  });
 }
 function extractorVueScript(options) {
   return {
     name: "@una-ui/extractor-vue-script",
     order: 0,
-    async extract({ code }) {
-      const prefixes = options?.prefixes ?? [];
-      const regularResults = splitCodeWithArbitraryVariants(code, prefixes);
-      const conditionalResults = extractConditionalStatements(code, prefixes);
-      return [.../* @__PURE__ */ new Set([...regularResults, ...conditionalResults])];
+    async extract({ code, id }) {
+      const cleanPath = parsePath(id).pathname;
+      if (cleanPath.endsWith(".vue")) {
+        const sfc = parse(code, {
+          filename: cleanPath
+        });
+        code = sfc.descriptor.scriptSetup?.content || sfc.descriptor.script?.content || "";
+      }
+      const { $ast: node } = parseModule(code, {
+        sourceFileName: id
+      });
+      const prefixes = normalizePrefixes(options?.prefixes ?? []);
+      const regularResults = discoverVariants(node, prefixes);
+      return [...new Set(regularResults)];
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@una-ui/extractor-vue-script-edge",
-  "version": "0.64.0-29260635.86853d3",
+  "version": "0.64.0-29262088.1cb0816",
   "description": "Unocss extractor for Vue script",
   "author": "Phojie Rengel <phojrengel@gmail.com>",
   "license": "MIT",
@@ -34,7 +34,16 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@babel/parser": "^7.28.3",
+    "@babel/traverse": "^7.28.3",
+    "@vue/compiler-sfc": "^3.5.18",
+    "magicast": "^0.3.5",
+    "ufo": "^1.6.1"
+  },
   "devDependencies": {
+    "@babel/types": "^7.28.2",
+    "@types/babel__traverse": "^7.28.0",
     "@unocss/core": "^66.4.2",
     "vitest": "^3.2.4"
   },