@projectwallace/css-layer-tree 2.0.0-alpha.0 → 2.0.2

package/dist/css-layer-tree.js

@@ -1,5 +1,5 @@
-import * as u from "css-tree";
-class f {
+import * as p from "css-tree";
+class d {
   /** @param {string} name */
   constructor(e) {
     this.name = e, this.is_anonymous = !1, this.children = /* @__PURE__ */ new Map(), this.locations = [];
@@ -9,15 +9,15 @@ class f {
    * @param {string} name
    * @param {T} location
    */
-  add_child(e, l, p) {
+  add_child(e, a, u) {
     let s = this;
     if (e.forEach((t) => {
       s = s.children.get(t);
-    }), s.children.has(l))
-      s.children.get(l).locations.push(p);
+    }), s.children.has(a))
+      u !== void 0 && s.children.get(a).locations.push(u);
     else {
-      const t = new f(l);
-      t.locations.push(p), t.is_anonymous = l.startsWith("__anonymous"), s.children.set(l, t);
+      const t = new d(a);
+      u !== void 0 && t.locations.push(u), t.is_anonymous = a.startsWith("__anonymous"), s.children.set(a, t);
     }
   }
   /**
@@ -40,8 +40,8 @@ class f {
     };
   }
 }
-function _(a) {
-  let e = a.loc;
+function _(i) {
+  let e = i.loc;
   if (e)
     return {
       line: e.start.line,
@@ -50,67 +50,72 @@ function _(a) {
       end: e.end.offset
     };
 }
-function d(a) {
-  return a.name.toLowerCase() === "layer";
+function h(i) {
+  return i.name.toLowerCase() === "layer";
 }
-function c(a) {
-  return u.generate(a).split(".").map((e) => e.trim());
+function c(i) {
+  return p.generate(i).split(".").map((e) => e.trim());
 }
-function h(a) {
-  let e = [], l = new f("root"), p = 0;
+function g(i) {
+  let e = [], a = new d("root"), u = 0;
   function s() {
-    return p++, `__anonymous-${p}__`;
+    return u++, `__anonymous-${u}__`;
   }
-  return u.walk(a, {
+  return p.walk(i, {
     visit: "Atrule",
     enter(t) {
-      if (d(t)) {
-        let i = _(t);
+      if (h(t)) {
+        let n = _(t);
         if (t.prelude === null) {
           let r = s();
-          l.add_child(e, r, i), e.push(r);
+          a.add_child(e, r, n), e.push(r);
         } else if (t.prelude.type === "AtrulePrelude")
           if (t.block === null) {
-            let r = u.findAll(t.prelude, (n) => n.type === "Layer").map((n) => n.name);
-            for (let n of r)
-              l.add_child(e, n, i);
+            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);
+              }
+            }
           } else
             for (let r of c(t.prelude))
-              l.add_child(e, r, i), e.push(r);
+              a.add_child(e, r, n), e.push(r);
       } else if (t.name.toLowerCase() === "import" && t.prelude !== null && t.prelude.type === "AtrulePrelude") {
-        let i = _(t), r = t.prelude, n = u.find(r, (o) => o.type === "Layer");
-        if (n) {
-          for (let o of c(n))
-            l.add_child(e, o, i), e.push(o);
+        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 (u.find(r, (o) => o.type === "Identifier" && o.name.toLowerCase() === "layer"))
-          return l.add_child([], s(), i), 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 (d(t))
+      if (h(t))
         if (t.prelude !== null && t.prelude.type === "AtrulePrelude") {
-          let i = c(t.prelude);
-          for (let r = 0; r < i.length; r++)
+          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);
     }
-  }), l.to_plain_object().children;
+  }), a.to_plain_object().children;
 }
-function m(a) {
-  let e = u.parse(a, {
+function k(i) {
+  let e = p.parse(i, {
     positions: !0,
     parseAtrulePrelude: !0,
     parseValue: !1,
     parseRulePrelude: !1,
     parseCustomProperty: !1
   });
-  return h(e);
+  return g(e);
 }
 export {
-  m as layer_tree,
-  h as layer_tree_from_ast
+  k as layer_tree,
+  g as layer_tree_from_ast
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectwallace/css-layer-tree",
-  "version": "2.0.0-alpha.0",
+  "version": "2.0.2",
   "description": "Discover the composition of your CSS @layers in a tree-based format.",
   "repository": {
     "type": "git",