@projectwallace/css-layer-tree 2.0.2 → 2.1.1

package/dist/css-layer-tree.js

@@ -1,23 +1,23 @@
-import * as p from "css-tree";
-class d {
+import { traverse as g, AT_RULE as m, LAYER_NAME as _, parse as b } from "@projectwallace/css-parser";
+class p {
   /** @param {string} name */
-  constructor(e) {
-    this.name = e, this.is_anonymous = !1, this.children = /* @__PURE__ */ new Map(), this.locations = [];
+  constructor(l) {
+    this.name = l, this.is_anonymous = !1, this.children = /* @__PURE__ */ new Map(), this.locations = [];
   }
   /**
    * @param {string[]} path
    * @param {string} name
    * @param {T} location
    */
-  add_child(e, a, u) {
+  add_child(l, i, c) {
     let s = this;
-    if (e.forEach((t) => {
-      s = s.children.get(t);
-    }), s.children.has(a))
-      u !== void 0 && s.children.get(a).locations.push(u);
+    if (l.forEach((e) => {
+      s = s.children.get(e);
+    }), s.children.has(i))
+      c !== void 0 && s.children.get(i).locations.push(c);
     else {
-      const t = new d(a);
-      u !== void 0 && t.locations.push(u), t.is_anonymous = a.startsWith("__anonymous"), s.children.set(a, t);
+      const e = new p(i);
+      c !== void 0 && e.locations.push(c), e.is_anonymous = i.startsWith("__anonymous"), s.children.set(i, e);
     }
   }
   /**
@@ -36,86 +36,96 @@ class d {
       name: this.name,
       is_anonymous: this.is_anonymous,
       locations: this.locations,
-      children: Array.from(this.children.values(), (e) => e.to_plain_object())
+      children: Array.from(this.children.values(), (l) => l.to_plain_object())
     };
   }
 }
-function _(i) {
-  let e = i.loc;
-  if (e)
-    return {
-      line: e.start.line,
-      column: e.start.column,
-      start: e.start.offset,
-      end: e.end.offset
-    };
+function d(a) {
+  return a.split(".").map((l) => l.trim());
 }
-function h(i) {
-  return i.name.toLowerCase() === "layer";
+function u(a) {
+  return {
+    line: a.line,
+    column: a.column,
+    start: a.start,
+    end: a.end
+  };
 }
-function c(i) {
-  return p.generate(i).split(".").map((e) => e.trim());
-}
-function g(i) {
-  let e = [], a = new d("root"), u = 0;
+function k(a) {
+  let l = [], i = new p("root"), c = 0;
   function s() {
-    return u++, `__anonymous-${u}__`;
+    return c++, `__anonymous-${c}__`;
   }
-  return p.walk(i, {
-    visit: "Atrule",
-    enter(t) {
-      if (h(t)) {
-        let n = _(t);
-        if (t.prelude === null) {
-          let r = s();
-          a.add_child(e, r, n), e.push(r);
-        } else if (t.prelude.type === "AtrulePrelude")
-          if (t.block === null) {
-            let r = p.findAll(t.prelude, (o) => o.type === "Layer").map((o) => o.name);
-            for (let o of r) {
-              let f = o.split(".").map((l) => l.trim());
-              for (let l = 0; l < f.length; l++) {
-                let y = f.slice(0, l), m = f[l], w = l === f.length - 1 ? { ...n } : void 0;
-                a.add_child(y, m, w);
+  return g(a, {
+    enter(e) {
+      if (e.type === m) {
+        if (e.name === "layer")
+          if (e.prelude) {
+            let n = e.prelude.text.split(",").map((t) => t.trim());
+            if (e.has_block) {
+              let t = [];
+              for (let r of e.prelude.children)
+                r.type === _ && t.push(r.text);
+              for (let r = 0; r < t.length; r++) {
+                let o = t[r];
+                if (!o) continue;
+                let h = t.slice(0, r), f = r === t.length - 1 ? u(e) : void 0;
+                i.add_child(l.concat(h), o, f);
+              }
+              l.push(...t);
+            } else
+              for (let t of n) {
+                let r = d(t);
+                for (let o = 0; o < r.length; o++) {
+                  let h = r.slice(0, o), f = r[o];
+                  if (f) {
+                    let y = o === r.length - 1 ? u(e) : void 0;
+                    i.add_child(h, f, y);
+                  }
+                }
               }
+          } else {
+            let n = s();
+            i.add_child(l, n, u(e)), l.push(n);
+          }
+        else if (e.name === "import" && e.prelude) {
+          for (let n of e.prelude.children)
+            if (n.type === _) {
+              if (n.name.trim())
+                for (let t of d(n.name))
+                  i.add_child(l, t, u(e)), l.push(t);
+              else {
+                let t = s();
+                i.add_child([], t, u(e));
+              }
+              break;
             }
-          } else
-            for (let r of c(t.prelude))
-              a.add_child(e, r, n), e.push(r);
-      } else if (t.name.toLowerCase() === "import" && t.prelude !== null && t.prelude.type === "AtrulePrelude") {
-        let n = _(t), r = t.prelude, o = p.find(r, (l) => l.type === "Layer");
-        if (o) {
-          for (let l of c(o))
-            a.add_child(e, l, n), e.push(l);
-          return this.skip;
         }
-        if (p.find(r, (l) => l.type === "Identifier" && l.name.toLowerCase() === "layer"))
-          return a.add_child([], s(), n), this.skip;
       }
     },
-    leave(t) {
-      if (h(t))
-        if (t.prelude !== null && t.prelude.type === "AtrulePrelude") {
-          let n = c(t.prelude);
-          for (let r = 0; r < n.length; r++)
-            e.pop();
-        } else
-          e.pop();
-      else t.name.toLowerCase() === "import" && (e.length = 0);
+    leave(e) {
+      if (e.type === m)
+        if (e.name === "layer")
+          if (e.prelude && e.has_block) {
+            let n = 0;
+            for (let t of e.prelude.children)
+              t.type === _ && n++;
+            for (let t = 0; t < n; t++)
+              l.pop();
+          } else
+            l.pop();
+        else e.name === "import" && (l.length = 0);
     }
-  }), a.to_plain_object().children;
+  }), i.to_plain_object().children;
 }
-function k(i) {
-  let e = p.parse(i, {
-    positions: !0,
-    parseAtrulePrelude: !0,
-    parseValue: !1,
-    parseRulePrelude: !1,
-    parseCustomProperty: !1
+function w(a) {
+  let l = b(a, {
+    parse_selectors: !1,
+    parse_values: !1
   });
-  return g(e);
+  return k(l);
 }
 export {
-  k as layer_tree,
-  g as layer_tree_from_ast
+  w as layer_tree,
+  k as layer_tree_from_ast
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectwallace/css-layer-tree",
-  "version": "2.0.2",
+  "version": "2.1.1",
   "description": "Discover the composition of your CSS @layers in a tree-based format.",
   "repository": {
     "type": "git",
@@ -25,21 +25,17 @@
   "scripts": {
     "build": "vite build",
     "test": "c8 --reporter=lcov uvu",
-    "check": "tsc",
+    "check": "tsc --noEmit",
     "prettier": "prettier --check src/**/*.js test/**/*.js"
   },
   "devDependencies": {
     "@codecov/vite-plugin": "^1.2.1",
-    "@types/css-tree": "^2.3.8",
     "c8": "^10.1.2",
     "prettier": "^3.3.3",
     "typescript": "5.4.2",
     "uvu": "^0.5.6",
     "vite": "^5.4.10"
   },
-  "dependencies": {
-    "css-tree": "^3.0.0"
-  },
   "files": [
     "dist",
     "index.d.ts"
@@ -58,5 +54,8 @@
     "useTabs": true,
     "printWidth": 140,
     "singleQuote": true
+  },
+  "dependencies": {
+    "@projectwallace/css-parser": "^0.12.2"
   }
-}
+}