@projectwallace/css-code-coverage 0.2.3 → 0.3.0

package/dist/css-code-coverage.js

@@ -1,247 +1,224 @@
-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()
+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()
       })
     )
   })
 );
-function q(t) {
-  return h.safeParse(J, t).success;
+function p(e) {
+  return g.safeParse(m, e).success;
 }
-function X(t) {
+function M(e) {
   try {
-    let e = JSON.parse(t);
-    return q(e) ? e : [];
+    let t = JSON.parse(e);
+    return p(t) ? t : [];
   } catch {
     return [];
   }
 }
-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;
+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;
             break;
           }
-        v || f.push(o);
+        s || l.push(a);
       }
     } else
-      e.set(n, {
-        url: s.url,
-        ranges: s.ranges
+      t.set(r, {
+        url: n.url,
+        ranges: n.ranges
       });
   }
-  return e;
+  return Array.from(t, ([n, { url: r, ranges: o }]) => ({ text: n, url: r, ranges: o }));
 }
-function D(t) {
+function A(e) {
   try {
-    let e = new URL(t);
-    return e.pathname.slice(e.pathname.lastIndexOf(".") + 1);
+    let t = new URL(e);
+    return t.pathname.slice(t.pathname.lastIndexOf(".") + 1);
   } catch {
-    let e = t.lastIndexOf(".");
-    return t.slice(e, t.indexOf("/", e) + 1);
+    let t = e.lastIndexOf(".");
+    return e.slice(t, e.indexOf("/", t) + 1);
   }
 }
-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)
+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)
       });
-    o += g.length;
+    a += c.length;
   }
   return {
-    css: c,
-    ranges: f
+    css: o,
+    ranges: l
   };
 }
-function H(t) {
-  return /<\/?(html|body|head|div|span|script|style)/i.test(t);
+function E(e) {
+  return /<\/?(html|body|head|div|span|script|style)/i.test(e);
 }
-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);
+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);
         continue;
       }
-      if (H(n.text)) {
-        if (!e)
+      if (E(r.text)) {
+        if (!t)
           continue;
-        let { css: f, ranges: o } = G(e, n.text, n.ranges);
-        s.push({
-          url: n.url,
-          text: f,
-          ranges: o
+        let { css: l, ranges: a } = w(t, r.text, r.ranges);
+        n.push({
+          url: r.url,
+          text: l,
+          ranges: a
         });
         continue;
       }
-      s.push({
-        url: n.url,
-        text: n.text,
-        ranges: n.ranges
+      n.push({
+        url: r.url,
+        text: r.text,
+        ranges: r.ranges
       });
     }
   }
-  return s;
+  return n;
 }
-function j(t, e) {
-  return e === 0 ? 0 : t / e;
+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 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 !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
-        });
+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;
+        }
       }
-    }
-    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;
+}
+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
     };
-  }), { 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),
+  });
+  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: 0,
       total_covered_lines: 0,
       total_uncovered_lines: 0,
       total_bytes: 0,
-      total_used_bytes: 0,
-      total_unused_bytes: 0
+      total_covered_bytes: 0,
+      total_uncovered_bytes: 0
     }
   );
   return {
-    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
+    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
   };
 }
 export {
-  Y as calculate_coverage,
-  X as parse_coverage
+  C as calculate_coverage,
+  M as parse_coverage
 };

package/dist/src/chunkify.d.ts

@@ -0,0 +1,9 @@
+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

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

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[]): Map<NonNullable<Coverage['text']>, Pick<Coverage, 'ranges' | 'url'>>;
+export declare function deduplicate_entries(entries: Coverage[]): Coverage[];

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

@@ -0,0 +1,5 @@
+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

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

package/dist/src/index.d.ts

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

package/package.json

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