@jjlmoya/utils-games-development 1.66.0 → 1.68.0

package/src/tests/qa_claim_evidence.test.ts

@@ -1,69 +1,69 @@
-import { describe, expect, it } from 'vitest';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { displayPath, listToolDirectories, read } from './qa-test-helpers';
-
-const evidenceClaims = [
-  /\bofficial algorithm\b/i,
-  /\balgoritmo oficial\b/i,
-  /\b(?:records|data|rates|tables) updated(?:\s+(?:to|through)\s+20\d{2})?\b/i,
-  /\b(?:registros|datos|tasas|tablas) actualizad[oa]s?(?:\s+(?:a|hasta)\s+20\d{2})?\b/i,
-  /\b(?:validated|verified) (?:method|algorithm|calculation)\b/i,
-  /\b(?:método|algoritmo|cálculo) (?:validado|verificado)\b/i,
-  /\b(?:guarantees|ensures)\b/i,
-  /\bgarantiza\b/i,
-  /\bofficial (?:data|rate|calculation)\b/i,
-  /\b(?:datos|tasa|cálculo) oficial(?:es)?\b/i,
-];
-
-const requiredEvidenceFields = [
-  'reviewedAt',
-  'methodology',
-  'sources',
-  'referenceCases',
-  'limitations',
-];
-
-describe('QA: strong factual claims are traceable', () => {
-  it('requires machine-readable validation evidence beside tools making strong claims', () => {
-    const failures: string[] = [];
-
-    for (const directory of listToolDirectories()) {
-      const localePaths = ['en', 'es']
-        .map((locale) => join(directory, 'i18n', `${locale}.ts`))
-        .filter(existsSync);
-      const claims = localePaths.flatMap((path) => {
-        const source = read(path);
-        return evidenceClaims
-          .filter((pattern) => pattern.test(source))
-          .map((pattern) => `${displayPath(path)} matches ${pattern.source}`);
-      });
-      if (claims.length === 0) continue;
-
-      const evidencePath = join(directory, 'validation.ts');
-      if (!existsSync(evidencePath)) {
-        failures.push(`${displayPath(evidencePath)} missing; claims: ${claims.join(' | ')}`);
-        continue;
-      }
-
-      const evidence = read(evidencePath);
-      const missingFields = requiredEvidenceFields.filter(
-        (field) => !new RegExp(`\\b${field}\\s*:`).test(evidence),
-      );
-      if (missingFields.length > 0) {
-        failures.push(`${displayPath(evidencePath)} missing fields: ${missingFields.join(', ')}`);
-      }
-    }
-
-    expect(
-      failures,
-      [
-        'Claims such as official, validated, guaranteed or updated need inspectable evidence.',
-        'Add validation.ts with reviewedAt, methodology, sources, referenceCases and limitations,',
-        'or weaken/remove the unsupported claim.',
-        ...failures,
-      ].join('\n'),
-    ).toEqual([]);
-  });
-});
-
+import { describe, expect, it } from 'vitest';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { displayPath, listToolDirectories, read } from './qa-test-helpers';
+
+const evidenceClaims = [
+  /\bofficial algorithm\b/i,
+  /\balgoritmo oficial\b/i,
+  /\b(?:records|data|rates|tables) updated(?:\s+(?:to|through)\s+20\d{2})?\b/i,
+  /\b(?:registros|datos|tasas|tablas) actualizad[oa]s?(?:\s+(?:a|hasta)\s+20\d{2})?\b/i,
+  /\b(?:validated|verified) (?:method|algorithm|calculation)\b/i,
+  /\b(?:método|algoritmo|cálculo) (?:validado|verificado)\b/i,
+  /\b(?:guarantees|ensures)\b/i,
+  /\bgarantiza\b/i,
+  /\bofficial (?:data|rate|calculation)\b/i,
+  /\b(?:datos|tasa|cálculo) oficial(?:es)?\b/i,
+];
+
+const requiredEvidenceFields = [
+  'reviewedAt',
+  'methodology',
+  'sources',
+  'referenceCases',
+  'limitations',
+];
+
+describe('QA: strong factual claims are traceable', () => {
+  it('requires machine-readable validation evidence beside tools making strong claims', () => {
+    const failures: string[] = [];
+
+    for (const directory of listToolDirectories()) {
+      const localePaths = ['en', 'es']
+        .map((locale) => join(directory, 'i18n', `${locale}.ts`))
+        .filter(existsSync);
+      const claims = localePaths.flatMap((path) => {
+        const source = read(path);
+        return evidenceClaims
+          .filter((pattern) => pattern.test(source))
+          .map((pattern) => `${displayPath(path)} matches ${pattern.source}`);
+      });
+      if (claims.length === 0) continue;
+
+      const evidencePath = join(directory, 'validation.ts');
+      if (!existsSync(evidencePath)) {
+        failures.push(`${displayPath(evidencePath)} missing; claims: ${claims.join(' | ')}`);
+        continue;
+      }
+
+      const evidence = read(evidencePath);
+      const missingFields = requiredEvidenceFields.filter(
+        (field) => !new RegExp(`\\b${field}\\s*:`).test(evidence),
+      );
+      if (missingFields.length > 0) {
+        failures.push(`${displayPath(evidencePath)} missing fields: ${missingFields.join(', ')}`);
+      }
+    }
+
+    expect(
+      failures,
+      [
+        'Claims such as official, validated, guaranteed or updated need inspectable evidence.',
+        'Add validation.ts with reviewedAt, methodology, sources, referenceCases and limitations,',
+        'or weaken/remove the unsupported claim.',
+        ...failures,
+      ].join('\n'),
+    ).toEqual([]);
+  });
+});
+

package/src/tests/qa_logic_reference_coverage.test.ts

@@ -1,46 +1,46 @@
-import { describe, expect, it } from 'vitest';
-import { basename, join } from 'node:path';
-import { existsSync } from 'node:fs';
-import {
-  displayPath,
-  findFiles,
-  listToolDirectories,
-  read,
-  repositoryRoot,
-} from './qa-test-helpers';
-
-function hasDedicatedLogicTest(toolDirectory: string): boolean {
-  const localCandidates = [
-    join(toolDirectory, 'logic.test.ts'),
-    join(toolDirectory, 'logic.spec.ts'),
-    join(toolDirectory, '__tests__', 'logic.test.ts'),
-    join(toolDirectory, '__tests__', 'logic.spec.ts'),
-  ];
-  if (localCandidates.some(existsSync)) return true;
-
-  const toolName = basename(toolDirectory);
-  const centralTests = findFiles(join(repositoryRoot, 'src', 'tests'), ['.test.ts', '.spec.ts']);
-  return centralTests.some((testPath) => {
-    const source = read(testPath).replace(/\\/g, '/');
-    return source.includes(`/tool/${toolName}/logic`) || source.includes(`../tool/${toolName}/logic`);
-  });
-}
-
-describe('QA: calculation logic has reference tests', () => {
-  it('gives every public calculator logic module its own behavioral test suite', () => {
-    const failures = listToolDirectories()
-      .filter((directory) => existsSync(join(directory, 'logic.ts')))
-      .filter((directory) => !hasDedicatedLogicTest(directory))
-      .map((directory) => `${displayPath(join(directory, 'logic.ts'))} -> no test imports this module`);
-
-    expect(
-      failures,
-      [
-        'Add behavioral tests through each logic module public API.',
-        'At minimum cover a documented reference case, boundaries, invalid input and invariants.',
-        ...failures,
-      ].join('\n'),
-    ).toEqual([]);
-  });
-});
-
+import { describe, expect, it } from 'vitest';
+import { basename, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import {
+  displayPath,
+  findFiles,
+  listToolDirectories,
+  read,
+  repositoryRoot,
+} from './qa-test-helpers';
+
+function hasDedicatedLogicTest(toolDirectory: string): boolean {
+  const localCandidates = [
+    join(toolDirectory, 'logic.test.ts'),
+    join(toolDirectory, 'logic.spec.ts'),
+    join(toolDirectory, '__tests__', 'logic.test.ts'),
+    join(toolDirectory, '__tests__', 'logic.spec.ts'),
+  ];
+  if (localCandidates.some(existsSync)) return true;
+
+  const toolName = basename(toolDirectory);
+  const centralTests = findFiles(join(repositoryRoot, 'src', 'tests'), ['.test.ts', '.spec.ts']);
+  return centralTests.some((testPath) => {
+    const source = read(testPath).replace(/\\/g, '/');
+    return source.includes(`/tool/${toolName}/logic`) || source.includes(`../tool/${toolName}/logic`);
+  });
+}
+
+describe('QA: calculation logic has reference tests', () => {
+  it('gives every public calculator logic module its own behavioral test suite', () => {
+    const failures = listToolDirectories()
+      .filter((directory) => existsSync(join(directory, 'logic.ts')))
+      .filter((directory) => !hasDedicatedLogicTest(directory))
+      .map((directory) => `${displayPath(join(directory, 'logic.ts'))} -> no test imports this module`);
+
+    expect(
+      failures,
+      [
+        'Add behavioral tests through each logic module public API.',
+        'At minimum cover a documented reference case, boundaries, invalid input and invariants.',
+        ...failures,
+      ].join('\n'),
+    ).toEqual([]);
+  });
+});
+

package/src/tests/qa_runtime_i18n.test.ts

@@ -1,100 +1,100 @@
-import { describe, expect, it } from 'vitest';
-import { basename, join } from 'node:path';
-import { existsSync } from 'node:fs';
-import {
-  displayPath,
-  findFiles,
-  listToolDirectories,
-  read,
-  repositoryRoot,
-} from './qa-test-helpers';
-
-interface VisibleLiteral {
-  line: number;
-  value: string;
-}
-
-const domTextAssignment = /\.(?:innerText|textContent|innerHTML)\s*=/;
-const quotedLiteral = /(['"`])((?:\\.|(?!\1).)*)\1/g;
-
-function visibleWords(value: string): string {
-  return value
-    .replace(/\$\{[^}]*\}/g, ' ')
-    .replace(/<[^>]+>/g, ' ')
-    .replace(/&[a-z]+;/gi, ' ')
-    .replace(/[\d\p{P}\p{S}_]+/gu, ' ')
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-function isTechnicalLiteral(value: string): boolean {
-  return ['.', '#', '['].some((prefix) => value.startsWith(prefix))
-    || /^data-[a-z0-9-]+$/i.test(value);
-}
-
-function hardcodedVisibleLiterals(source: string): VisibleLiteral[] {
-  const failures: VisibleLiteral[] = [];
-
-  source.split(/\r?\n/).forEach((line, index) => {
-    if (!domTextAssignment.test(line)) return;
-
-    const assignment = line.slice(line.search(domTextAssignment));
-    for (const match of assignment.matchAll(quotedLiteral)) {
-      const literal = match[2] ?? '';
-      if (isTechnicalLiteral(literal)) continue;
-      const words = visibleWords(literal);
-      if (words && /\p{L}/u.test(words)) {
-        failures.push({ line: index + 1, value: literal });
-      }
-    }
-  });
-
-  return failures;
-}
-
-function runtimeSources(toolDirectory: string): string {
-  return findFiles(toolDirectory, ['.astro', '.ts', '.js'])
-    .filter((path) => !path.includes(`${join(toolDirectory, 'i18n')}`))
-    .filter((path) => basename(path) !== 'ui.ts')
-    .map(read)
-    .join('\n');
-}
-
-describe('QA: runtime copy is localized', () => {
-  const componentFiles = findFiles(join(repositoryRoot, 'src', 'tool'), ['.astro']);
-
-  it('does not write user-facing string literals directly into the DOM', () => {
-    const failures = componentFiles.flatMap((path) =>
-      hardcodedVisibleLiterals(read(path)).map(
-        ({ line, value }) => `${displayPath(path)}:${line} -> ${JSON.stringify(value)}`,
-      ),
-    );
-
-    expect(
-      failures,
-      `Move visible browser copy to the tool UI locale contract:\n${failures.join('\n')}`,
-    ).toEqual([]);
-  });
-
-  it('uses every string declared by each UI locale contract', () => {
-    const failures: string[] = [];
-
-    for (const directory of listToolDirectories()) {
-      const uiPath = join(directory, 'ui.ts');
-      if (!existsSync(uiPath)) continue;
-
-      const keys = Array.from(read(uiPath).matchAll(/^\s*(\w+)\??:\s*string\s*;/gm), (match) => match[1]);
-      const runtime = runtimeSources(directory);
-      const unused = keys.filter((key) => !new RegExp(`\\b${key}\\b`).test(runtime));
-
-      if (unused.length > 0) {
-        failures.push(`${displayPath(uiPath)} -> unused: ${unused.join(', ')}`);
-      }
-    }
-
-    expect(
-      failures,
-      `Unused locale keys are dead copy or may mean the browser bypasses translations:\n${failures.join('\n')}`,
-    ).toEqual([]);
-  });
-});
+import { describe, expect, it } from 'vitest';
+import { basename, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import {
+  displayPath,
+  findFiles,
+  listToolDirectories,
+  read,
+  repositoryRoot,
+} from './qa-test-helpers';
+
+interface VisibleLiteral {
+  line: number;
+  value: string;
+}
+
+const domTextAssignment = /\.(?:innerText|textContent|innerHTML)\s*=/;
+const quotedLiteral = /(['"`])((?:\\.|(?!\1).)*)\1/g;
+
+function visibleWords(value: string): string {
+  return value
+    .replace(/\$\{[^}]*\}/g, ' ')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&[a-z]+;/gi, ' ')
+    .replace(/[\d\p{P}\p{S}_]+/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function isTechnicalLiteral(value: string): boolean {
+  return ['.', '#', '['].some((prefix) => value.startsWith(prefix))
+    || /^data-[a-z0-9-]+$/i.test(value);
+}
+
+function hardcodedVisibleLiterals(source: string): VisibleLiteral[] {
+  const failures: VisibleLiteral[] = [];
+
+  source.split(/\r?\n/).forEach((line, index) => {
+    if (!domTextAssignment.test(line)) return;
+
+    const assignment = line.slice(line.search(domTextAssignment));
+    for (const match of assignment.matchAll(quotedLiteral)) {
+      const literal = match[2] ?? '';
+      if (isTechnicalLiteral(literal)) continue;
+      const words = visibleWords(literal);
+      if (words && /\p{L}/u.test(words)) {
+        failures.push({ line: index + 1, value: literal });
+      }
+    }
+  });
+
+  return failures;
+}
+
+function runtimeSources(toolDirectory: string): string {
+  return findFiles(toolDirectory, ['.astro', '.ts', '.js'])
+    .filter((path) => !path.includes(`${join(toolDirectory, 'i18n')}`))
+    .filter((path) => basename(path) !== 'ui.ts')
+    .map(read)
+    .join('\n');
+}
+
+describe('QA: runtime copy is localized', () => {
+  const componentFiles = findFiles(join(repositoryRoot, 'src', 'tool'), ['.astro']);
+
+  it('does not write user-facing string literals directly into the DOM', () => {
+    const failures = componentFiles.flatMap((path) =>
+      hardcodedVisibleLiterals(read(path)).map(
+        ({ line, value }) => `${displayPath(path)}:${line} -> ${JSON.stringify(value)}`,
+      ),
+    );
+
+    expect(
+      failures,
+      `Move visible browser copy to the tool UI locale contract:\n${failures.join('\n')}`,
+    ).toEqual([]);
+  });
+
+  it('uses every string declared by each UI locale contract', () => {
+    const failures: string[] = [];
+
+    for (const directory of listToolDirectories()) {
+      const uiPath = join(directory, 'ui.ts');
+      if (!existsSync(uiPath)) continue;
+
+      const keys = Array.from(read(uiPath).matchAll(/^\s*(\w+)\??:\s*string\s*;/gm), (match) => match[1]);
+      const runtime = runtimeSources(directory);
+      const unused = keys.filter((key) => !new RegExp(`\\b${key}\\b`).test(runtime));
+
+      if (unused.length > 0) {
+        failures.push(`${displayPath(uiPath)} -> unused: ${unused.join(', ')}`);
+      }
+    }
+
+    expect(
+      failures,
+      `Unused locale keys are dead copy or may mean the browser bypasses translations:\n${failures.join('\n')}`,
+    ).toEqual([]);
+  });
+});

package/src/tests/schemas_fulfillment.test.ts

@@ -1,23 +1,23 @@
-import { describe, it, expect } from 'vitest';
-import { ALL_TOOLS } from '../tools';
-import type { ToolLocaleContent } from '../types';
-
-describe('Schemas Fulfillment Validation', () => {
-  ALL_TOOLS.forEach((tool) => {
-    describe(`Tool: ${tool.entry.id}`, () => {
-      Object.keys(tool.entry.i18n).forEach((locale) => {
-        it(`Locale: ${locale} should have faqSchema, appSchema and howToSchema`, async () => {
-          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
-          if (!loader) return;
-          const content = (await loader()) as ToolLocaleContent;
-
-          const schemaTypes = content.schemas.map((s: any) => s['@type']);
-
-          expect(schemaTypes, `Tool "${tool.entry.id}" locale "${locale}" is missing FAQPage schema`).toContain('FAQPage');
-          expect(schemaTypes, `Tool "${tool.entry.id}" locale "${locale}" is missing SoftwareApplication schema`).toContain('SoftwareApplication');
-          expect(schemaTypes, `Tool "${tool.entry.id}" locale "${locale}" is missing HowTo schema`).toContain('HowTo');
-        });
-      });
-    });
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+describe('Schemas Fulfillment Validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(tool.entry.i18n).forEach((locale) => {
+        it(`Locale: ${locale} should have faqSchema, appSchema and howToSchema`, async () => {
+          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+          if (!loader) return;
+          const content = (await loader()) as ToolLocaleContent;
+
+          const schemaTypes = content.schemas.map((s: any) => s['@type']);
+
+          expect(schemaTypes, `Tool "${tool.entry.id}" locale "${locale}" is missing FAQPage schema`).toContain('FAQPage');
+          expect(schemaTypes, `Tool "${tool.entry.id}" locale "${locale}" is missing SoftwareApplication schema`).toContain('SoftwareApplication');
+          expect(schemaTypes, `Tool "${tool.entry.id}" locale "${locale}" is missing HowTo schema`).toContain('HowTo');
+        });
+      });
+    });
+  });
+});