@projectwallace/css-code-coverage 0.1.0 → 0.1.2

package/README.md

@@ -36,11 +36,14 @@ npm install @projectwallace/css-code-coverage
    //     { start: 0, end: 46 }
    //   ]
    // }
+   import { parse_coverage } from '@projectwallace/css-code-coverage'
+
    let files = await fs.glob('./css-coverage/**/*.json')
    let coverage_data = []
+
    for (let file of files) {
    	let json_content = await fs.readFile(file, 'urf-8')
-   	coverage_data.push(JSON.parse(json_content))
+   	coverage_data.push(...parse_coverage(json_content))
    }
    ```
 

package/dist/css-code-coverage.js

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

package/dist/src/index.d.ts

@@ -18,8 +18,8 @@ export type StylesheetCoverage = CoverageData & {
 };
 export type CoverageResult = CoverageData & {
     total_files_found: number;
-    coverage_per_stylesheet: StylesheetCoverage[];
     total_stylesheets: number;
+    coverage_per_stylesheet: StylesheetCoverage[];
 };
 /**
  * @description
@@ -33,3 +33,6 @@ export type CoverageResult = CoverageData & {
  * 5. Calculate line-coverage, byte-coverage per stylesheet
  */
 export declare function calculate_coverage(coverage: Coverage[], parse_html: Parser): CoverageResult;
+export type { Coverage, Range } from './parse-coverage.ts';
+export { parse_coverage } from './parse-coverage.ts';
+export type { Parser } from './types.ts';

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectwallace/css-code-coverage",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "",
   "author": "Bart Veneman <bart@projectwallace.com>",
   "repository": {