@projectwallace/css-code-coverage 0.3.0 → 0.3.1

package/dist/css-code-coverage.js

@@ -1,224 +1,247 @@
-import * as g from "valibot";
-import { format as x } from "@projectwallace/format-css";
-let m = g.array(
-  g.object({
-    text: g.string(),
-    url: g.string(),
-    ranges: g.array(
-      g.object({
-        start: g.number(),
-        end: g.number()
+import * as h from "valibot";
+import { format as F } from "@projectwallace/format-css";
+import { tokenTypes as x, tokenize as $ } from "css-tree/tokenizer";
+let J = h.array(
+  h.object({
+    text: h.optional(h.string()),
+    url: h.string(),
+    ranges: h.array(
+      h.object({
+        start: h.number(),
+        end: h.number()
       })
     )
   })
 );
-function p(e) {
-  return g.safeParse(m, e).success;
+function q(t) {
+  return h.safeParse(J, t).success;
 }
-function M(e) {
+function X(t) {
   try {
-    let t = JSON.parse(e);
-    return p(t) ? t : [];
+    let e = JSON.parse(t);
+    return q(e) ? e : [];
   } catch {
     return [];
   }
 }
-function k(e) {
-  let t = /* @__PURE__ */ new Map();
-  for (let n of e) {
-    let r = n.text;
-    if (t.has(r)) {
-      let l = t.get(r).ranges;
-      for (let a of n.ranges) {
-        let s = !1;
-        for (let f of l)
-          if (f.start === a.start && f.end === a.end) {
-            s = !0;
+function P(t) {
+  return t.map(({ url: e, text: s, ranges: n }) => {
+    if (!s)
+      return { url: e, text: s, ranges: n };
+    let c = F(s), f = /* @__PURE__ */ new Set([
+      x.EOF,
+      x.BadString,
+      x.BadUrl,
+      x.WhiteSpace,
+      x.Semicolon,
+      x.Comment,
+      x.Colon
+    ]), o = n.map(({ start: a, end: i }) => ({ start: a, end: i, tokens: [] }));
+    function v(a, i) {
+      let r = 0;
+      for (let u of o) {
+        if (u.start > i) return -1;
+        if (u.start <= a && u.end >= i)
+          return r;
+        r++;
+      }
+      return -1;
+    }
+    let _ = 0;
+    $(s, (a, i, r) => {
+      if (f.has(a)) return;
+      _++, a === x.Url && (_ += 2);
+      let u = v(i, r);
+      u !== -1 && o[u].tokens.push(_);
+    });
+    let g = /* @__PURE__ */ new Map();
+    _ = 0, $(c, (a, i, r) => {
+      f.has(a) || (_++, a === x.Url && (_ += 2), g.set(_, { start: i, end: r }));
+    });
+    let y = [];
+    for (let a of o) {
+      let i = g.get(a.tokens.at(0)), r = g.get(a.tokens.at(-1));
+      i !== void 0 && r !== void 0 && y.push({
+        start: i.start,
+        end: r.end
+      });
+    }
+    return { url: e, text: c, ranges: y };
+  });
+}
+function R(t) {
+  let e = /* @__PURE__ */ new Map();
+  for (let s of t) {
+    let n = s.text || "";
+    if (e.has(n)) {
+      let f = e.get(n).ranges;
+      for (let o of s.ranges) {
+        let v = !1;
+        for (let _ of f)
+          if (_.start === o.start && _.end === o.end) {
+            v = !0;
             break;
           }
-        s || l.push(a);
+        v || f.push(o);
       }
     } else
-      t.set(r, {
-        url: n.url,
-        ranges: n.ranges
+      e.set(n, {
+        url: s.url,
+        ranges: s.ranges
       });
   }
-  return Array.from(t, ([n, { url: r, ranges: o }]) => ({ text: n, url: r, ranges: o }));
+  return e;
 }
-function A(e) {
+function D(t) {
   try {
-    let t = new URL(e);
-    return t.pathname.slice(t.pathname.lastIndexOf(".") + 1);
+    let e = new URL(t);
+    return e.pathname.slice(e.pathname.lastIndexOf(".") + 1);
   } catch {
-    let t = e.lastIndexOf(".");
-    return e.slice(t, e.indexOf("/", t) + 1);
+    let e = t.lastIndexOf(".");
+    return t.slice(e, t.indexOf("/", e) + 1);
   }
 }
-function w(e, t, n) {
-  let r = e(t), o = "", l = [], a = 0, s = r.querySelectorAll("style");
-  for (let f of Array.from(s)) {
-    let c = f.textContent;
-    if (!c.trim()) continue;
-    o += c;
-    let i = t.indexOf(c), d = i + c.length;
-    for (let _ of n)
-      _.start >= i && _.end <= d && l.push({
-        start: a + (_.start - i),
-        end: a + (_.end - i)
+function G(t, e, s) {
+  let n = t(e), c = "", f = [], o = 0, v = n.querySelectorAll("style");
+  for (let _ of Array.from(v)) {
+    let g = _.textContent;
+    if (!g.trim()) continue;
+    c += g;
+    let y = e.indexOf(g), a = y + g.length;
+    for (let i of s)
+      i.start >= y && i.end <= a && f.push({
+        start: o + (i.start - y),
+        end: o + (i.end - y)
       });
-    a += c.length;
+    o += g.length;
   }
   return {
-    css: o,
-    ranges: l
+    css: c,
+    ranges: f
   };
 }
-function E(e) {
-  return /<\/?(html|body|head|div|span|script|style)/i.test(e);
+function H(t) {
+  return /<\/?(html|body|head|div|span|script|style)/i.test(t);
 }
-function O(e, t) {
-  let n = [];
-  for (let r of e) {
-    let o = A(r.url).toLowerCase();
-    if (o !== "js") {
-      if (o === "css") {
-        n.push(r);
+function K(t, e) {
+  let s = [];
+  for (let n of t) {
+    if (!n.text) continue;
+    let c = D(n.url).toLowerCase();
+    if (c !== "js") {
+      if (c === "css") {
+        s.push(n);
         continue;
       }
-      if (E(r.text)) {
-        if (!t)
+      if (H(n.text)) {
+        if (!e)
           continue;
-        let { css: l, ranges: a } = w(t, r.text, r.ranges);
-        n.push({
-          url: r.url,
-          text: l,
-          ranges: a
+        let { css: f, ranges: o } = G(e, n.text, n.ranges);
+        s.push({
+          url: n.url,
+          text: f,
+          ranges: o
         });
         continue;
       }
-      n.push({
-        url: r.url,
-        text: r.text,
-        ranges: r.ranges
+      s.push({
+        url: n.url,
+        text: n.text,
+        ranges: n.ranges
       });
     }
   }
-  return n;
+  return s;
 }
-function L(e) {
-  let t = [], n = 0;
-  for (let r of e.ranges)
-    n !== r.start && (t.push({
-      start_offset: n,
-      end_offset: r.start,
-      is_covered: !1
-    }), n = r.start), t.push({
-      start_offset: r.start,
-      end_offset: r.end,
-      is_covered: !0
-    }), n = r.end;
-  return n !== e.text.length && t.push({
-    start_offset: n,
-    end_offset: e.text.length,
-    is_covered: !1
-  }), {
-    ...e,
-    chunks: t
-  };
+function j(t, e) {
+  return e === 0 ? 0 : t / e;
 }
-function N(e) {
-  for (let n of e)
-    for (let r of n.ranges)
-      for (let o = 1; o >= -28; o--) {
-        let l = r.start + o;
-        if (n.text.charAt(l) === "@") {
-          r.start = l;
-          break;
-        }
+function Y(t, e) {
+  let s = t.length;
+  if (!q(t))
+    throw new TypeError("No valid coverage data found");
+  let n = K(t, e), c = P(n), f = R(c), o = Array.from(f).map(([r, { url: u, ranges: L }]) => {
+    function M(l, d) {
+      let b = d + l.length, N = b + 1, W = /^\s*$/.test(l), k = l.endsWith("}");
+      if (!W && !k) {
+        for (let m of L)
+          if (!(m.start > b || m.end < d)) {
+            if (m.start <= d && m.end >= b)
+              return !0;
+            if (l.startsWith("@") && m.start > d && m.start < N)
+              return !0;
+          }
       }
-  return e;
-}
-function S(e) {
-  let t = 1, n = 0, r = e.chunks.map((l, a) => {
-    let s = x(e.text.slice(l.start_offset, l.end_offset));
-    l.is_covered && (a === 0 ? s = s + `
-` : a === e.chunks.length - 1 ? s = `
-` + s : s = `
-` + s + `
-`);
-    let f = s.split(`
-`).length, c = n, i = Math.max(n + s.length - 1, 0), d = t, _ = t + f;
-    return t = _, n = i, {
-      ...l,
-      start_offset: c,
-      start_line: d,
-      end_line: _ - 1,
-      end_offset: i,
-      css: s,
-      total_lines: _ - d
+      return !1;
+    }
+    let S = r.split(`
+`), O = S.length, p = new Uint8Array(O), C = 0, B = r.length, U = 0, E = 0;
+    for (let l = 0; l < S.length; l++) {
+      let d = S[l], b = E, W = E + d.length + 1, k = /^\s*$/.test(d), m = d.endsWith("}"), z = M(d, b), w = !1, T = l > 0 && p[l - 1] === 1;
+      (z && !m && !k || (k || m) && T || k && !T && M(S[l + 1], W)) && (w = !0), p[l] = w ? 1 : 0, w && (C++, U += d.length + 1), E = W;
+    }
+    let A = [
+      {
+        start_line: 1,
+        is_covered: p[0] === 1,
+        end_line: 1,
+        total_lines: 1
+      }
+    ];
+    for (let l = 1; l < p.length; l++) {
+      let d = p[l];
+      if (d !== p[l - 1]) {
+        let b = A.at(-1);
+        b.end_line = l, b.total_lines = l - b.start_line + 1, A.push({
+          start_line: l + 1,
+          is_covered: d === 1,
+          end_line: l,
+          total_lines: 0
+        });
+      }
+    }
+    let I = A.at(-1);
+    return I.total_lines = p.length + 1 - I.start_line, I.end_line = p.length, {
+      url: u,
+      text: r,
+      ranges: L,
+      unused_bytes: B - U,
+      used_bytes: U,
+      total_bytes: B,
+      line_coverage_ratio: j(C, O),
+      byte_coverage_ratio: j(U, B),
+      line_coverage: p,
+      total_lines: O,
+      covered_lines: C,
+      uncovered_lines: O - C,
+      chunks: A
     };
-  });
-  return {
-    ...e,
-    // TODO: update ranges as well?? Or remove them because we have chunks now
-    chunks: r,
-    text: r.map(({ css: l }) => l).join("")
-  };
-}
-function y(e, t) {
-  return t === 0 ? 0 : e / t;
-}
-function T(e) {
-  let { text: t, url: n, chunks: r } = e, o = 0, l = 0, a = 0, s = 0, f = 0, c = 0;
-  for (let i of r) {
-    let d = i.total_lines, _ = i.end_offset - i.start_offset;
-    s += d, a += _, i.is_covered ? (f += d, l += _) : (c += d, o += _);
-  }
-  return {
-    url: n,
-    text: t,
-    uncovered_bytes: o,
-    covered_bytes: l,
-    total_bytes: a,
-    line_coverage_ratio: y(f, s),
-    byte_coverage_ratio: y(l, a),
-    total_lines: s,
-    covered_lines: f,
-    uncovered_lines: c,
-    chunks: r
-  };
-}
-function C(e, t) {
-  let n = e.length;
-  if (!p(e))
-    throw new TypeError("No valid coverage data found");
-  let r = O(e, t), o = k(r), f = N(o).map((u) => L(u)).map((u) => S(u)).map((u) => T(u)), { total_lines: c, total_covered_lines: i, total_uncovered_lines: d, total_bytes: _, total_covered_bytes: h, total_uncovered_bytes: b } = f.reduce(
-    (u, v) => (u.total_lines += v.total_lines, u.total_covered_lines += v.covered_lines, u.total_uncovered_lines += v.uncovered_lines, u.total_bytes += v.total_bytes, u.total_covered_bytes += v.covered_bytes, u.total_uncovered_bytes += v.uncovered_bytes, u),
+  }), { total_lines: v, total_covered_lines: _, total_uncovered_lines: g, total_bytes: y, total_used_bytes: a, total_unused_bytes: i } = o.reduce(
+    (r, u) => (r.total_lines += u.total_lines, r.total_covered_lines += u.covered_lines, r.total_uncovered_lines += u.uncovered_lines, r.total_bytes += u.total_bytes, r.total_used_bytes += u.used_bytes, r.total_unused_bytes += u.unused_bytes, r),
     {
       total_lines: 0,
       total_covered_lines: 0,
       total_uncovered_lines: 0,
       total_bytes: 0,
-      total_covered_bytes: 0,
-      total_uncovered_bytes: 0
+      total_used_bytes: 0,
+      total_unused_bytes: 0
     }
   );
   return {
-    total_files_found: n,
-    total_bytes: _,
-    total_lines: c,
-    covered_bytes: h,
-    covered_lines: i,
-    uncovered_bytes: b,
-    uncovered_lines: d,
-    byte_coverage_ratio: y(h, _),
-    line_coverage_ratio: y(i, c),
-    coverage_per_stylesheet: f,
-    total_stylesheets: f.length
+    total_files_found: s,
+    total_bytes: y,
+    total_lines: v,
+    used_bytes: a,
+    covered_lines: _,
+    unused_bytes: i,
+    uncovered_lines: g,
+    byte_coverage_ratio: j(a, y),
+    line_coverage_ratio: j(_, v),
+    coverage_per_stylesheet: o,
+    total_stylesheets: o.length
   };
 }
 export {
-  C as calculate_coverage,
-  M as parse_coverage
+  Y as calculate_coverage,
+  X as parse_coverage
 };

package/dist/src/decuplicate.d.ts

@@ -6,4 +6,4 @@ import { Coverage } from './parse-coverage.ts';
  * - if a duplicate stylesheet enters the room, we add it's ranges to the existing stylesheet's ranges
  * - only bytes of deduplicated stylesheets are counted
  */
-export declare function deduplicate_entries(entries: Coverage[]): Coverage[];
+export declare function deduplicate_entries(entries: Coverage[]): Map<NonNullable<Coverage['text']>, Pick<Coverage, 'ranges' | 'url'>>;

package/dist/src/index.d.ts

@@ -1,9 +1,8 @@
-import { Coverage } from './parse-coverage.ts';
+import { Coverage, Range } from './parse-coverage.ts';
 import { Parser } from './types.ts';
-import { PrettifiedChunk } from './prettify.ts';
 export type CoverageData = {
-    uncovered_bytes: number;
-    covered_bytes: number;
+    unused_bytes: number;
+    used_bytes: number;
     total_bytes: number;
     line_coverage_ratio: number;
     byte_coverage_ratio: number;
@@ -14,7 +13,14 @@ export type CoverageData = {
 export type StylesheetCoverage = CoverageData & {
     url: string;
     text: string;
-    chunks: PrettifiedChunk[];
+    ranges: Range[];
+    line_coverage: Uint8Array;
+    chunks: {
+        is_covered: boolean;
+        start_line: number;
+        end_line: number;
+        total_lines: number;
+    }[];
 };
 export type CoverageResult = CoverageData & {
     total_files_found: number;

package/dist/src/parse-coverage.d.ts

@@ -4,7 +4,7 @@ export type Range = {
 };
 export type Coverage = {
     url: string;
-    text: string;
+    text?: string;
     ranges: Range[];
 };
 export declare function is_valid_coverage(input: unknown): boolean;

package/dist/src/prettify.d.ts

@@ -1,12 +1,2 @@
-import { Coverage } from './parse-coverage';
-import { ChunkedCoverage } from './chunkify';
-export type PrettifiedChunk = ChunkedCoverage['chunks'][0] & {
-    start_line: number;
-    end_line: number;
-    total_lines: number;
-    css: string;
-};
-export type PrettifiedCoverage = Omit<Coverage, 'ranges'> & {
-    chunks: PrettifiedChunk[];
-};
-export declare function prettify(stylesheet: ChunkedCoverage): PrettifiedCoverage;
+import { Coverage } from './parse-coverage.ts';
+export declare function prettify(coverage: Coverage[]): Coverage[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectwallace/css-code-coverage",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "",
   "author": "Bart Veneman <bart@projectwallace.com>",
   "repository": {
@@ -52,6 +52,7 @@
   },
   "dependencies": {
     "@projectwallace/format-css": "^2.1.1",
+    "css-tree": "^3.1.0",
     "valibot": "^1.1.0"
   }
 }

package/dist/src/chunkify.d.ts

@@ -1,9 +0,0 @@
-import { Coverage } from './parse-coverage';
-export type ChunkedCoverage = Coverage & {
-    chunks: {
-        start_offset: number;
-        end_offset: number;
-        is_covered: boolean;
-    }[];
-};
-export declare function chunkify_stylesheet(stylesheet: Coverage): ChunkedCoverage;

package/dist/src/chunkify.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/extend-ranges.d.ts

@@ -1,5 +0,0 @@
-import { Coverage } from './parse-coverage';
-/**
- * WARNING: mutates the ranges array
- */
-export declare function extend_ranges(coverage: Coverage[]): Coverage[];

package/dist/src/extend-ranges.test.d.ts

@@ -1 +0,0 @@
-export {};