fix #5, #9

Author: Jackardios

src/TailwindConverter.ts

@@ -91,12 +91,14 @@ export class TailwindConverter {
 
     const nodes = nodesManager.getNodes();
     nodes.forEach(node => {
-      node.rule.prepend(
-        new AtRule({
-          name: 'apply',
-          params: node.tailwindClasses.join(' '),
-        })
-      );
+      if (node.tailwindClasses.length) {
+        node.rule.prepend(
+          new AtRule({
+            name: 'apply',
+            params: node.tailwindClasses.join(' '),
+          })
+        );
+      }
     });
 
     this.cleanRaws(parsed.root);
@@ -185,17 +187,17 @@ export class TailwindConverter {
     if (containerClassPrefix) {
       return {
         key: baseSelector,
-        fallbackRule: rule,
-        classesPrefixWhenFound: containerClassPrefix + classPrefix,
+        originalRule: rule,
+        classesPrefix: containerClassPrefix + classPrefix,
         tailwindClasses,
       };
     }
 
     if (classPrefix) {
       return {
         key: TailwindNodesManager.convertRuleToKey(rule, baseSelector),
-        fallbackRule: rule,
-        classesPrefixWhenFound: classPrefix,
+        originalRule: rule,
+        classesPrefix: classPrefix,
         tailwindClasses,
       };
     }

src/TailwindNodesManager.ts

@@ -1,4 +1,4 @@
-import type { AtRule, Rule } from 'postcss';
+import { type AtRule, type Node, Rule, ChildNode } from 'postcss';
 import { isAtRuleNode } from './utils/isAtRuleNode';
 import { isChildNode } from './utils/isChildNode';
 
@@ -9,8 +9,8 @@ export interface ResolvedTailwindNode {
 
 export interface UnresolvedTailwindNode {
   key: string;
-  fallbackRule: Rule;
-  classesPrefixWhenFound: string;
+  originalRule: Rule;
+  classesPrefix: string;
   tailwindClasses: string[];
 }
 
@@ -40,33 +40,43 @@ export class TailwindNodesManager {
 
   mergeNode(node: TailwindNode) {
     const nodeIsResolved = isResolvedTailwindNode(node);
-    const key = nodeIsResolved
+    const nodeKey = nodeIsResolved
       ? TailwindNodesManager.convertRuleToKey(node.rule)
       : node.key;
-    const foundNode = this.nodesMap.get(key);
-
-    if (!foundNode) {
-      if (nodeIsResolved) {
-        this.nodesMap.set(key, node);
-      } else {
-        this.nodesMap.set(
-          TailwindNodesManager.convertRuleToKey(node.fallbackRule),
-          {
-            rule: node.fallbackRule,
-            tailwindClasses: node.tailwindClasses,
-          }
-        );
-      }
+    const foundNode = this.nodesMap.get(nodeKey);
+
+    if (foundNode) {
+      foundNode.tailwindClasses = foundNode.tailwindClasses.concat(
+        nodeIsResolved
+          ? node.tailwindClasses
+          : node.tailwindClasses.map(
+              className => `${node.classesPrefix}${className}`
+            )
+      );
+
       return;
     }
 
-    foundNode.tailwindClasses = foundNode.tailwindClasses.concat(
-      nodeIsResolved
-        ? node.tailwindClasses
-        : node.tailwindClasses.map(
-            className => `${node.classesPrefixWhenFound}${className}`
-          )
-    );
+    if (nodeIsResolved) {
+      this.nodesMap.set(nodeKey, node);
+    } else {
+      const newRule = new Rule({
+        // TODO: CONVERT NODE KEY TO RULE!!
+        selector: nodeKey,
+      });
+
+      const rootChild = this.upToRootChild(node.originalRule);
+      if (rootChild) {
+        node.originalRule.root().insertBefore(rootChild, newRule);
+      }
+
+      this.nodesMap.set(nodeKey, {
+        rule: newRule,
+        tailwindClasses: node.tailwindClasses.map(
+          className => `${node.classesPrefix}${className}`
+        ),
+      });
+    }
   }
 
   mergeNodes(nodes: TailwindNode[]) {
@@ -87,6 +97,21 @@ export class TailwindNodesManager {
     return Array.from(this.nodesMap.values());
   }
 
+  protected upToRootChild(node: Node) {
+    let childNode: ChildNode | null = null;
+
+    while (
+      node.parent &&
+      node.parent.type !== 'root' &&
+      isChildNode(node.parent)
+    ) {
+      childNode = node = node.parent;
+      continue;
+    }
+
+    return childNode;
+  }
+
   static convertRuleToKey(
     rule: Rule,
     overriddenSelector: string | null = null