Function checkPatternCoverage

src/helpers/coverage.js:503–574

(schema, positiveTests, negativeTests)

 * @param {Map<string, unknown>} negativeTests
 */
export function checkPatternCoverage(schema, positiveTests, negativeTests) {
  const patterns = walkProperties(schema)
    .filter(
      (p) => typeof p.propSchema.pattern === 'string' && p.propSchema.pattern,
    )
    .map((p) => ({
      path: p.path,
      name: p.name,
      pattern: /** @type {string} */ (p.propSchema.pattern),
    }))

  if (patterns.length === 0) {
    return { status: 'skip', reason: 'No pattern constraints' }
  }

  const issues = []
  for (const { path: pPath, name, pattern } of patterns) {
    let regex
    try {
      regex = new RegExp(pattern)
    } catch {
      issues.push({ path: pPath, type: 'invalid_regex', pattern })
      continue
    }

    // Positive: at least one value matches (use path-aware collection)
    let hasMatch = false
    const testedPosFiles = []
    for (const [fname, data] of positiveTests) {
      const vals = collectValuesByPath(data, pPath)
      if (vals.length > 0) {
        testedPosFiles.push(fname)
        for (const v of vals) {
          if (typeof v === 'string' && regex.test(v)) {
            hasMatch = true
            break
          }
        }
      }
      if (hasMatch) break
    }
    if (!hasMatch) {
      issues.push({
        path: pPath,
        type: 'no_positive_match',
        pattern,
        testedFiles: [...new Set(testedPosFiles)],
      })
    }

    // Negative: at least one value violates
    let hasViolation = false
    for (const data of negativeTests.values()) {
      for (const v of collectValuesByPath(data, pPath)) {
        if (typeof v === 'string' && !regex.test(v)) {
          hasViolation = true
          break
        }