expose parse_coverage helper

Author: bartveneman

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))
    }
    ```
 

src/index.test.ts

@@ -196,3 +196,45 @@ test.describe('from coverage data downloaded directly from the browser as JSON',
 		)
 	})
 })
+
+test('handles empty input', () => {
+	let result = calculate_coverage([], html_parser)
+	expect(result.total_files_found).toBe(0)
+	expect(result.total_bytes).toBe(0)
+	expect(result.used_bytes).toBe(0)
+	expect(result.unused_bytes).toBe(0)
+	expect(result.total_lines).toBe(0)
+	expect(result.covered_lines).toBe(0)
+	expect(result.uncovered_lines).toBe(0)
+	expect(result.line_coverage_ratio).toBe(0)
+	expect(result.total_stylesheets).toBe(0)
+	expect(result.coverage_per_stylesheet).toEqual([])
+})
+
+test.describe('garbage input', () => {
+	test('garbage Array', () => {
+		expect(() =>
+			calculate_coverage(
+				[
+					{
+						test: 1,
+						garbage: true,
+					},
+				] as unknown as Coverage[],
+				html_parser,
+			),
+		).toThrow('No valid coverage data found')
+	})
+
+	test('garbage Object', () => {
+		expect(() =>
+			calculate_coverage(
+				{
+					test: 1,
+					garbage: true,
+				} as unknown as Coverage[],
+				html_parser,
+			),
+		).toThrow('No valid coverage data found')
+	})
+})

src/index.ts

@@ -1,4 +1,4 @@
-import type { Coverage, Range } from './parse-coverage.ts'
+import { is_valid_coverage, type Coverage, type Range } from './parse-coverage.ts'
 import { prettify } from './prettify.ts'
 import { deduplicate_entries } from './decuplicate.ts'
 import { filter_coverage } from './filter-entries.ts'
@@ -28,6 +28,11 @@ export type CoverageResult = CoverageData & {
 	coverage_per_stylesheet: StylesheetCoverage[]
 }
 
+function ratio(fraction: number, total: number) {
+	if (total === 0) return 0
+	return fraction / total
+}
+
 /**
  * @description
  * CSS Code Coverage calculation
@@ -41,6 +46,11 @@ export type CoverageResult = CoverageData & {
  */
 export function calculate_coverage(coverage: Coverage[], parse_html: Parser): CoverageResult {
 	let total_files_found = coverage.length
+
+	if (!is_valid_coverage(coverage)) {
+		throw new TypeError('No valid coverage data found')
+	}
+
 	let filtered_coverage = filter_coverage(coverage, parse_html)
 	let prettified_coverage = prettify(filtered_coverage)
 	let deduplicated = deduplicate_entries(prettified_coverage)
@@ -114,8 +124,8 @@ export function calculate_coverage(coverage: Coverage[], parse_html: Parser): Co
 			unused_bytes: file_total_bytes - file_bytes_covered,
 			used_bytes: file_bytes_covered,
 			total_bytes: file_total_bytes,
-			line_coverage_ratio: file_lines_covered / total_file_lines,
-			byte_coverage_ratio: file_bytes_covered / file_total_bytes,
+			line_coverage_ratio: ratio(file_lines_covered, total_file_lines),
+			byte_coverage_ratio: ratio(file_bytes_covered, file_total_bytes),
 			line_coverage,
 			total_lines: total_file_lines,
 			covered_lines: file_lines_covered,
@@ -154,9 +164,13 @@ export function calculate_coverage(coverage: Coverage[], parse_html: Parser): Co
 		covered_lines: total_covered_lines,
 		unused_bytes: total_unused_bytes,
 		uncovered_lines: total_uncovered_lines,
-		byte_coverage_ratio: total_used_bytes / total_bytes,
-		line_coverage_ratio: total_covered_lines / total_lines,
+		byte_coverage_ratio: ratio(total_used_bytes, total_bytes),
+		line_coverage_ratio: ratio(total_covered_lines, total_lines),
 		coverage_per_stylesheet,
 		total_stylesheets: coverage_per_stylesheet.length,
 	}
 }
+
+export type { Coverage, Range } from './parse-coverage.ts'
+export { parse_coverage } from './parse-coverage.ts'
+export type { Parser } from './types.ts'

src/parse-coverage.test.ts

@@ -1,5 +1,5 @@
 import { test, expect } from '@playwright/test'
-import { parse_json } from './parse-coverage.ts'
+import { parse_coverage } from './parse-coverage.ts'
 
 test('parses valid JSON', () => {
 	let input = `
@@ -13,7 +13,7 @@ test('parses valid JSON', () => {
 		}
 	]
 	`
-	let result = parse_json(input)
+	let result = parse_coverage(input)
 	expect(result).toEqual([
 		{
 			url: 'example.com',
@@ -34,7 +34,7 @@ test('allows entries without text', () => {
 		}
 	]
 	`
-	let result = parse_json(input)
+	let result = parse_coverage(input)
 	expect(result).toEqual([
 		{
 			url: 'example.com',
@@ -45,7 +45,7 @@ test('allows entries without text', () => {
 
 test('returns empty array for invalid JSON', () => {
 	let input = `invalid json`
-	let result = parse_json(input)
+	let result = parse_coverage(input)
 	expect(result).toEqual([])
 })
 
@@ -60,6 +60,6 @@ test('returns empty array for JSON not matching schema', () => {
 		}
 	]
 	`
-	let result = parse_json(input)
+	let result = parse_coverage(input)
 	expect(result).toEqual([])
 })

src/parse-coverage.ts

@@ -24,11 +24,15 @@ let CoverageSchema = v.array(
 	}),
 )
 
-export function parse_json(input: string) {
+export function is_valid_coverage(input: unknown): boolean {
+	let result = v.safeParse(CoverageSchema, input)
+	return result.success
+}
+
+export function parse_coverage(input: string) {
 	try {
 		let parse_result = JSON.parse(input)
-		v.parse(CoverageSchema, parse_result)
-		return parse_result as Coverage[]
+		return is_valid_coverage(parse_result) ? (parse_result as Coverage[]) : ([] as Coverage[])
 	} catch {
 		return [] as Coverage[]
 	}